[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Xen-devel] domain reboots broken (and suspend too)



The xend patches that Alastair committed today appear to solve part of
the reboot issue.  However, the following case still causes problems:
 #> xm new <config>
 #> xm start <domname>
 #> xm reboot <domname>

During domU restart, xend.log shows that XendDomainInfo complains the
rebooted domU's name already exists:

File "XendDomainInfo.py", line 1033, in _restart
  new_dom = XendDomain.instance().domain_create(config)
File "XendDomain.py", line 819, in domain_create
  dominfo = XendDomainInfo.create(config)
File "XendDomainInfo.py", line 148, in create
  vm = XendDomainInfo(XendConfig(sxp = config))
File "XendDomainInfo.py", line 419, in __init__
  self._checkName(self.info['name'])
File "XendDomainInfo.py", line 1635, in _checkName
  raise VmError("VM name '%s' already exists" % name)

------------

Also, the patches did not improve suspend:

[Start Cut&Paste]

#> xm new <vmconfig>
#> xm start <vmconfig>
#> xm suspend <domname>
Error: Domain is not managed by Xend lifecycle support.
Usage: xm suspend <DomainName>

Suspend a Xend maanged domain

[End Cut&Paste]

See attached for a xend trace of the above suspend example in which the
domU's name is "fc5-1"

-Chris
|> server/SrvDaemon.py:fork_pid
|  78         self.child = os.fork()
|  80         if self.child:
|  88         return self.child
|< server/SrvDaemon.py:fork_pid
|> server/SrvDaemon.py:run
| 294         try:
| 295             log.info("Xend Daemon started")
| 297             xc = xen.lowlevel.xc.xc()
| 298             xinfo = xc.xeninfo()
| 299             log.info("Xend changeset: %s.", xinfo['xen_changeset'])
| 300             del xc
| 302             try:
| 303                 from xen import VERSION
|! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/server/SrvDaemon.py", line 303, in run
    from xen import VERSION
ImportError: cannot import name VERSION
| 305             except ImportError:
| 306                 log.info("Xend version: Unknown.")
|  80         if self.child:
|  82             pidfile = open(XEND_PID_FILE, 'w')
|  83             try:
|  84                 pidfile.write(str(self.child))
|  86                 pidfile.close()
|  88         return self.child
|< server/SrvDaemon.py:fork_pid
| 308             relocate.listenRelocation()
| > server/relocate.py:listenRelocation
|  117     xroot = XendRoot.instance()
|  > XendRoot.py:instance
|   301     try:
|   302         inst
|   305     return inst
|  < XendRoot.py:instance
|  118     if xroot.get_xend_unix_server():
|  > XendRoot.py:get_xend_unix_server
|   245         return self.get_config_bool("xend-unix-server", 
self.xend_unix_server_default)
|   > XendRoot.py:get_config_bool
|    178         v = string.lower(str(self.get_config_value(name, val)))
|    > XendRoot.py:get_config_value
|     175         return sxp.child_value(self.config, name, val=val)
|    < XendRoot.py:get_config_value
|    179         if v in ['yes', 'y', '1', 'on',  'true',  't']:
|    181         if v in ['no',  'n', '0', 'off', 'false', 'f']:
|    182             return False
|   < XendRoot.py:get_config_bool
|  < XendRoot.py:get_xend_unix_server
|  121     if xroot.get_xend_relocation_server():
|  > XendRoot.py:get_xend_relocation_server
|   208         return self.get_config_bool("xend-relocation-server",
|   209                                     self.xend_relocation_server_default)
|   > XendRoot.py:get_config_bool
|    178         v = string.lower(str(self.get_config_value(name, val)))
|    > XendRoot.py:get_config_value
|     175         return sxp.child_value(self.config, name, val=val)
|    < XendRoot.py:get_config_value
|    179         if v in ['yes', 'y', '1', 'on',  'true',  't']:
|    180             return True
|   < XendRoot.py:get_config_bool
|  < XendRoot.py:get_xend_relocation_server
|  122         port = xroot.get_xend_relocation_port()
|  > XendRoot.py:get_xend_relocation_port
|   219         return self.get_config_int('xend-relocation-port',
|   220                                    self.xend_relocation_port_default)
|   > XendRoot.py:get_config_int
|    186         v = self.get_config_value(name, val)
|    > XendRoot.py:get_config_value
|     175         return sxp.child_value(self.config, name, val=val)
|    < XendRoot.py:get_config_value
|    187         try:
|    188             return int(v)
|   < XendRoot.py:get_config_int
|  < XendRoot.py:get_xend_relocation_port
|  123         interface = xroot.get_xend_relocation_address()
|  > XendRoot.py:get_xend_relocation_address
|   240         return self.get_config_value('xend-relocation-address', 
self.xend_relocation_address_default)
|   > XendRoot.py:get_config_value
|    175         return sxp.child_value(self.config, name, val=val)
|   < XendRoot.py:get_config_value
|  < XendRoot.py:get_xend_relocation_address
|  125         hosts_allow = xroot.get_xend_relocation_hosts_allow()
|  > XendRoot.py:get_xend_relocation_hosts_allow
|   223         return self.get_config_value("xend-relocation-hosts-allow",
|   224                                      
self.xend_relocation_hosts_allow_default)
|   > XendRoot.py:get_config_value
|    175         return sxp.child_value(self.config, name, val=val)
|   < XendRoot.py:get_config_value
|  < XendRoot.py:get_xend_relocation_hosts_allow
|  126         if hosts_allow == '':
|  129             hosts_allow = map(re.compile, hosts_allow.split(" "))
|  131         tcp.TCPListener(RelocationProtocol, port, interface = interface,
|  132                         hosts_allow = hosts_allow)
| < server/relocate.py:listenRelocation
| 309             servers = SrvServer.create()
| > server/SrvServer.py:create
|  131     root = SrvDir()
|  132     root.putChild('xend', SrvRoot())
|  > server/SrvRoot.py:__init__
|    36         SrvDir.__init__(self)
|    37         for (name, klass) in self.subdirs:
|    38             self.add(name, klass)
|    37         for (name, klass) in self.subdirs:
|    38             self.add(name, klass)
|    37         for (name, klass) in self.subdirs:
|    38             self.add(name, klass)
|    37         for (name, klass) in self.subdirs:
|    39         for (name, klass) in self.subdirs:
|    40             self.get(name)
|   > server/SrvNode.py:?
|     19 from xen.web.SrvDir import SrvDir
|     20 from xen.xend import sxp
|     21 from xen.xend import XendNode
|     22 from xen.xend.Args import FormFn
|     24 class SrvNode(SrvDir):
|    > server/SrvNode.py:SrvNode
|      24 class SrvNode(SrvDir):
|      28     def __init__(self):
|      34     def op_shutdown(self, _1, _2):
|      38     def op_reboot(self, _1, _2):
|      42     def render_POST(self, req):
|      45     def render_GET(self, req):
|      63     def info(self):
|    < server/SrvNode.py:SrvNode
|   < server/SrvNode.py:?
|   > server/SrvNode.py:__init__
|     29         SrvDir.__init__(self)
|     30         self.xn = XendNode.instance()
|    > XendNode.py:instance
|     217     try:
|     218         inst
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendNode.py", line 218, in instance
    inst
NameError: global name 'inst' is not defined
|     219     except:
|     220         inst = XendNode()
|    |> XendNode.py:__init__
|    |  30         self.xc = xen.lowlevel.xc.xc()
|    |  31         self.uuid = uuid.createString()
|    | > uuid.py:createString
|    |   69     return toString(create())
|    |  > uuid.py:create
|    |    66     return uuidFactory()
|    |   > uuid.py:getUuidRandom
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |     50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |   < uuid.py:getUuidRandom
|    |  < uuid.py:create
|    |  > uuid.py:toString
|    |    58     return "-".join(["%02x" * 4, "%02x" * 2, "%02x" * 2, "%02x" * 
2,
|    |  < uuid.py:toString
|    | < uuid.py:createString
|    |  32         self.cpus = {}
|    |  33         self.name = socket.gethostname()
|    |  34         self.desc = ""
|    |  35         self.sr = XendStorageRepository()
|    | > XendStorageRepository.py:__init__
|    |   65         self.storage_dir = storage_dir
|    |   66         self.storage_max = storage_max
|    |   67         self.storage_free = 0
|    |   68         self.images = {}
|    |   71         self.uuid = self._sr_uuid()
|    |  > XendStorageRepository.py:_sr_uuid
|    |    81         uuid_file = os.path.join(XEND_STORAGE_DIR, 'uuid')
|    |    82         try:
|    |    83             if uuid_file and os.path.exists(uuid_file):
|    |    84                 return open(uuid_file, 'r').read().strip()
|    |  < XendStorageRepository.py:_sr_uuid
|    |   72         self.type = "qcow-file"
|    |   73         self.location = self.storage_dir
|    |   74         self.name_label = "Local"
|    |   75         self.name_description = "Xend Storage Repository"
|    |   77         self.lock = threading.RLock()
|    |   78         self._refresh()        
|    |  > XendStorageRepository.py:_refresh
|    |    99         self.lock.acquire()
|    |   100         try:
|    |   102             if not os.path.exists(XEND_STORAGE_DIR):
|    |   107             total_used = 0
|    |   108             seen_images = []
|    |   109             for filename in os.listdir(XEND_STORAGE_DIR):
|    |   110                 if filename[-5:] == 
XEND_STORAGE_QCOW_FILENAME[-5:]:
|    |   109             for filename in os.listdir(XEND_STORAGE_DIR):
|    |   135             for image_uuid in self.images.keys():
|    |   144             if self.storage_max != XEND_STORAGE_MAX_IGNORE:
|    |   147                 self.storage_free = self._get_free_space()
|    |   > XendStorageRepository.py:_get_free_space
|    |    159         stfs = os.statvfs(self.storage_dir)
|    |    160         return stfs.f_bavail * stfs.f_frsize
|    |   < XendStorageRepository.py:_get_free_space
|    |   150             self.lock.release()
|    |  < XendStorageRepository.py:_refresh
|    | < XendStorageRepository.py:__init__
|    |  37         physinfo = self.physinfo_dict()
|    | > XendNode.py:physinfo_dict
|    |  210         return dict(self.physinfo())
|    |  > XendNode.py:physinfo
|    |   155         info = self.xc.physinfo()
|    |   157         info['nr_cpus'] = (info['nr_nodes'] *
|    |   161         info['cpu_mhz'] = info['cpu_khz'] / 1000
|    |   163         info['total_memory'] = info['total_memory'] / 1024
|    |   164         info['free_memory']  = info['free_memory'] / 1024
|    |   166         ITEM_ORDER = ['nr_cpus',
|    |   177         return [[k, info[k]] for k in ITEM_ORDER]
|    |   177         return [[k, info[k]] for k in ITEM_ORDER]
|    |   177         return [[k, info[k]] for k in ITEM_ORDER]
|    |   177         return [[k, info[k]] for k in ITEM_ORDER]
|    |   177         return [[k, info[k]] for k in ITEM_ORDER]
|    |   177         return [[k, info[k]] for k in ITEM_ORDER]
|    |   177         return [[k, info[k]] for k in ITEM_ORDER]
|    |   177         return [[k, info[k]] for k in ITEM_ORDER]
|    |   177         return [[k, info[k]] for k in ITEM_ORDER]
|    |   177         return [[k, info[k]] for k in ITEM_ORDER]
|    |  < XendNode.py:physinfo
|    | < XendNode.py:physinfo_dict
|    |  38         cpu_count = physinfo['nr_cpus']
|    |  39         cpu_features = physinfo['hw_caps']
|    |  41         for i in range(cpu_count):
|    |  44             cpu_uuid = self.uuid + '-%04d' % i
|    |  45             cpu_info = {'uuid': cpu_uuid,
|    |  49             self.cpus[cpu_uuid] = cpu_info
|    |  41         for i in range(cpu_count):
|    |  44             cpu_uuid = self.uuid + '-%04d' % i
|    |  45             cpu_info = {'uuid': cpu_uuid,
|    |  49             self.cpus[cpu_uuid] = cpu_info
|    |  41         for i in range(cpu_count):
|    |< XendNode.py:__init__
|     221     return inst
|    < XendNode.py:instance
|     31         self.add('dmesg', 'SrvDmesg')
|     32         self.add('log', 'SrvXendLog')
|   < server/SrvNode.py:__init__
|    39         for (name, klass) in self.subdirs:
|    40             self.get(name)
|   > server/SrvDomainDir.py:?
|     18 import traceback
|     19 from StringIO import StringIO
|     21 from xen.web import http
|     23 from xen.xend import sxp
|     24 from xen.xend import XendDomain
|     25 from xen.xend.XendDomainInfo import XendDomainInfo
|     26 from xen.xend.Args import FormFn
|     27 from xen.xend.XendError import XendError
|     29 from xen.web.SrvDir import SrvDir
|     30 from SrvDomain import SrvDomain
|    > server/SrvDomain.py:?
|      19 from xen.web import http
|      21 from xen.xend import sxp
|      22 from xen.xend import XendDomain
|      23 from xen.xend.Args import FormFn
|      25 from xen.web.SrvDir import SrvDir
|      27 class SrvDomain(SrvDir):
|    |> server/SrvDomain.py:SrvDomain
|    |  27 class SrvDomain(SrvDir):
|    |  31     def __init__(self, dom):
|    |  36     def op_configure(self, _, req):
|    |  46     def op_unpause(self, _1, _2):
|    |  50     def op_pause(self, _1, _2):
|    |  54     def acceptCommand(self, req):
|    |  58     def op_rename(self, _, req):
|    |  62     def op_shutdown(self, _, req):
|    |  66     def op_sysrq(self, _, req):
|    |  70     def op_wait_for_devices(self, _, req):
|    |  74     def op_destroy(self, _, req):
|    |  78     def op_save(self, op, req):
|    |  82     def do_save(self, _, req):
|    |  85     def op_migrate(self, op, req):
|    |  88     def do_migrate(self, _, req):
|    |  97     def op_pincpu(self, _, req):
|    | 105     def op_cpu_sedf_get(self, _, req):
|    | 112     def op_cpu_sedf_set(self, _, req):
|    | 123     def op_domain_sched_credit_get(self, _, req):
|    | 130     def op_domain_sched_credit_set(self, _, req):
|    | 137     def op_maxmem_set(self, _, req):
|    | 145     def call(self, fn, args, req):
|    | 149     def op_mem_target_set(self, _, req):
|    | 154     def op_devices(self, _, req):
|    | 159     def op_device_create(self, _, req):
|    | 164     def op_device_destroy(self, _, req):
|    | 170     def op_device_configure(self, _, req):
|    | 177     def op_vif_limit_set(self, _, req):
|    | 186     def op_set_vcpus(self, _, req):
|    | 192     def op_vcpuinfo(self, _1, req):
|    | 196     def render_POST(self, req):
|    | 199     def render_GET(self, req):
|    | 224     def form(self, req):
|    |< server/SrvDomain.py:SrvDomain
|    < server/SrvDomain.py:?
|     33 class SrvDomainDir(SrvDir):
|    > server/SrvDomainDir.py:SrvDomainDir
|      33 class SrvDomainDir(SrvDir):
|      37     def __init__(self):
|      41     def domain(self, x):
|      47     def get(self, x):
|      54     def op_create(self, _, req):
|      84     def _op_create_cb(self, dominfo, configstring, req):
|     104     def op_restore(self, op, req):
|     110     def do_restore(self, _, req):
|     129     def op_list(self, _, req):
|     134     def render_POST(self, req):
|     137     def render_GET(self, req):
|     141     def _list(self, req, detail):
|     154     def ls_domain(self, req, detail, use_sxp):
|     176     def form(self, req):
|    < server/SrvDomainDir.py:SrvDomainDir
|   < server/SrvDomainDir.py:?
|   > server/SrvDomainDir.py:__init__
|     38         SrvDir.__init__(self)
|     39         self.xd = XendDomain.instance()
|    > XendDomain.py:instance
|    1333     try:
|    1334         inst
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendDomain.py", line 1334, in instance
    inst
NameError: global name 'inst' is not defined
|    1335     except:
|    1336         inst = XendDomain()
|    |> XendDomain.py:__init__
|    |  72         self.domains = {}
|    |  73         self.managed_domains = {}
|    |  74         self.domains_lock = threading.RLock()
|    |  78         self._allow_new_domains = True
|    |< XendDomain.py:__init__
|    1337         inst.init()
|    |> XendDomain.py:init
|    |  88         dom_path = self._managed_path()
|    | > XendDomain.py:_managed_path
|    |  205         dom_path = xroot.get_xend_domains_path()
|    |  > XendRoot.py:get_xend_domains_path
|    |   255         return self.get_config_value("xend-domains-path", 
self.xend_domains_path_default)
|    |   > XendRoot.py:get_config_value
|    |    175         return sxp.child_value(self.config, name, val=val)
|    |   < XendRoot.py:get_config_value
|    |  < XendRoot.py:get_xend_domains_path
|    |  206         if domuuid:
|    |  208         return dom_path
|    | < XendDomain.py:_managed_path
|    |  89         try:
|    |  90             os.stat(dom_path)
|    |  95         xstransact.Mkdir(XS_VMROOT)
|    | > xenstore/xstransact.py:Mkdir
|    |  345         complete(path, lambda t: t.mkdir(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      16         xs_lock.acquire()
|    |      17         if not xs_handle:
|    |      18             xs_handle = xen.lowlevel.xs.xs()
|    |      19         xs_lock.release()
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    345         complete(path, lambda t: t.mkdir(*args))
|    |    > xenstore/xstransact.py:mkdir
|    |     217         if len(args) == 0:
|    |     218             xshandle().mkdir(self.transaction, self.path)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |    < xenstore/xstransact.py:mkdir
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Mkdir
|    |  96         xstransact.SetPermissions(XS_VMROOT, {'dom': DOM0_ID})
|    | > xenstore/xstransact.py:SetPermissions
|    |  341         complete(path, lambda t: t.set_permissions(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    341         complete(path, lambda t: t.set_permissions(*args))
|    |    > xenstore/xstransact.py:set_permissions
|    |     253         if len(args) == 0:
|    |     255         elif isinstance(args[0], str):
|    |     258             if not self.path:
|    |     261             xshandle().set_permissions(self.transaction, 
self.path,
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |     262                                        list(args))
|    |    < xenstore/xstransact.py:set_permissions
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:SetPermissions
|    |  98         self.domains_lock.acquire()
|    |  99         try:
|    | 100             try:
|    | 101                 dom0info = [d for d in self._running_domains() \
|    | > XendDomain.py:_running_domains
|    |  343         try:
|    |  344             return xc.domain_getinfo()
|    | < XendDomain.py:_running_domains
|    | 101                 dom0info = [d for d in self._running_domains() \
|    | 104                 dom0info['name'] = DOM0_NAME
|    | 105                 dom0 = XendDomainInfo.recreate(dom0info, True)
|    | > XendDomainInfo.py:recreate
|    |  174     log.debug("XendDomainInfo.recreate(%s)", info)
|    |  176     assert not info['dying']
|    |  178     xeninfo = XendConfig(cfg = info)
|    |  > XendConfig.py:__init__
|    |   265         format = 'unknown'
|    |   267         self.xenapi = {}
|    |   > XendConfig.py:__setattr__
|    |    322         try:
|    |    323             return dict.__setattr__(self, name, value)
|    |   < XendConfig.py:__setattr__
|    |   269         if filename and not fd:
|    |   272         if fd:
|    |   275         if fd:
|    |   288         if sxp:
|    |   290         if xml:
|    |   292         if pycfg:
|    |   294         if xenapi_vm:
|    |   297         if cfg:
|    |   298             self.update(cfg)
|    |   300         if xenapi_vm:
|    |   303         log.debug('XendConfig: %s' % str(self))
|    |   304         self.validate()
|    |   > XendConfig.py:validate
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     190     ('uuid',         lambda info: uuid.createString()),
|    |    |> uuid.py:createString
|    |    |  69     return toString(create())
|    |    | > uuid.py:create
|    |    |   66     return uuidFactory()
|    |    |  > uuid.py:getUuidRandom
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |  < uuid.py:getUuidRandom
|    |    | < uuid.py:create
|    |    | > uuid.py:toString
|    |    |   58     return "-".join(["%02x" * 4, "%02x" * 2, "%02x" * 2, 
"%02x" * 2,
|    |    | < uuid.py:toString
|    |    |< uuid.py:createString
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     193     ('on_poweroff',  lambda info: 'destroy'),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     194     ('on_reboot',    lambda info: 'restart'),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     195     ('on_crash',     lambda info: 'restart'),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     196     ('features',     lambda info: ''),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     199     ('memory',       lambda info: 0),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     200     ('shadow_memory',lambda info: 0),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     201     ('maxmem',       lambda info: 0),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     202     ('bootloader',   lambda info: None),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     203     ('bootloader_args', lambda info: None),            
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     204     ('backend',      lambda info: []),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     205     ('device',       lambda info: {}),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     206     ('image',        lambda info: None),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     207     ('security',     lambda info: []),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     208     ('on_xend_start', lambda info: 'ignore'),    
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     209     ('on_xend_stop', lambda info: 'ignore'),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     211     ('cpus',         lambda info: []),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     212     ('cpu_cap',      lambda info: 0),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     213     ('cpu_weight',   lambda info: 256),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     214     ('vcpus',        lambda info: DEFAULT_VCPUS(info)),
|    |    |> XendConfig.py:DEFAULT_VCPUS
|    |    | 186     if 'max_vcpu_id' in info: return int(info['max_vcpu_id']) + 
1
|    |    |< XendConfig.py:DEFAULT_VCPUS
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     217     ('vcpu_avail',   lambda info: (1<<info['vcpus'])-1),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     220     ('kernel_kernel', lambda info: ''),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     221     ('kernel_initrd', lambda info: ''),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     222     ('kernel_args',   lambda info: ''),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    765         if 'image' in self and isinstance(self['image'], str):
|    |    767         if 'security' in self and isinstance(self['security'], 
str):
|    |    769         if self['memory'] == 0 and 'mem_kb' in self:
|    |    770             self['memory'] = (self['mem_kb'] + 1023)/1024
|    |    771         if self['memory'] <= 0:
|    |    775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |    778         if 'mem_kb' in self:
|    |    779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |    782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |    787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |    793         if 'vif_refs' not in self:
|    |    794             self['vif_refs'] = []
|    |    795         if 'vbd_refs' not in self:
|    |    796             self['vbd_refs'] = []
|    |    797         if 'vtpm_refs' not in self:
|    |    798             self['vtpm_refs'] = []
|    |   < XendConfig.py:validate
|    |  < XendConfig.py:__init__
|    |  179     domid = xeninfo['domid']
|    |  180     uuid1 = xeninfo['handle']
|    |  181     xeninfo['uuid'] = uuid.toString(uuid1)
|    |  > uuid.py:toString
|    |    58     return "-".join(["%02x" * 4, "%02x" * 2, "%02x" * 2, "%02x" * 
2,
|    |  < uuid.py:toString
|    |  182     needs_reinitialising = False
|    |  184     dompath = GetDomainPath(domid)
|    |  > xenstore/xsutil.py:GetDomainPath
|    |    26     return xshandle().get_domain_path(domid)
|    |   > xenstore/xsutil.py:xshandle
|    |     15     if not xs_handle:
|    |     20     return xs_handle
|    |   < xenstore/xsutil.py:xshandle
|    |  < xenstore/xsutil.py:GetDomainPath
|    |  185     if not dompath:
|    |  189     log.info("Recreating domain %d, UUID %s. at %s" %
|    |  200     try:
|    |  201         vmpath = xstransact.Read(dompath, "vm")
|    |  > xenstore/xstransact.py:Read
|    |   297         return complete(path, lambda t: t.read(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     297         return complete(path, lambda t: t.read(*args))
|    |    |> xenstore/xstransact.py:read
|    |    |  59         if len(args) == 0:
|    |    |  61         if len(args) == 1:
|    |    |  62             return self._read(args[0])
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    |< xenstore/xstransact.py:read
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Read
|    |  202         if not vmpath:
|    |  208         uuid2_str = xstransact.Read(vmpath, "uuid")
|    |  > xenstore/xstransact.py:Read
|    |   297         return complete(path, lambda t: t.read(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     297         return complete(path, lambda t: t.read(*args))
|    |    |> xenstore/xstransact.py:read
|    |    |  59         if len(args) == 0:
|    |    |  61         if len(args) == 1:
|    |    |  62             return self._read(args[0])
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    |< xenstore/xstransact.py:read
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Read
|    |  209         if not uuid2_str:
|    |  215         uuid2 = uuid.fromString(uuid2_str)
|    |  > uuid.py:fromString
|    |    62     s = s.replace('-', '')
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |  < uuid.py:fromString
|    |  216         if uuid1 != uuid2:
|    |  223     vm = XendDomainInfo(xeninfo, domid, dompath, augment = True, 
priv = priv)
|    |  > XendDomainInfo.py:__init__
|    |   376         self.info = info
|    |   377         if domid == None:
|    |   380             self.domid = domid
|    |   394         self.vmpath  = XS_VMROOT + self.info['uuid']
|    |   395         self.dompath = dompath
|    |   397         self.image = None
|    |   398         self.store_port = None
|    |   399         self.store_mfn = None
|    |   400         self.console_port = None
|    |   401         self.console_mfn = None
|    |   403         self.vmWatch = None
|    |   404         self.shutdownWatch = None
|    |   405         self.shutdownStartTime = None
|    |   407         self.state = DOM_STATE_HALTED
|    |   408         self.state_updated = threading.Condition()
|    |   409         self.refresh_shutdown_lock = threading.Condition()
|    |   411         self._deviceControllers = {}
|    |   413         for state in DOM_STATES_OLD:
|    |   414             self.info[state] = 0
|    |   413         for state in DOM_STATES_OLD:
|    |   414             self.info[state] = 0
|    |   413         for state in DOM_STATES_OLD:
|    |   414             self.info[state] = 0
|    |   413         for state in DOM_STATES_OLD:
|    |   414             self.info[state] = 0
|    |   413         for state in DOM_STATES_OLD:
|    |   414             self.info[state] = 0
|    |   413         for state in DOM_STATES_OLD:
|    |   414             self.info[state] = 0
|    |   413         for state in DOM_STATES_OLD:
|    |   416         if augment:
|    |   417             self._augmentInfo(priv)
|    |   > XendDomainInfo.py:_augmentInfo
|    |    612         def useIfNeeded(name, val):
|    |    616         if priv:
|    |    617             entries = VM_STORE_ENTRIES[:]
|    |    618             entries.remove(('memory', int))
|    |    619             entries.remove(('maxmem', int))
|    |    622         entries.append(('image', str))
|    |    623         entries.append(('security', str))
|    |    625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    626             self._readVMDetails(entries))
|    |    > XendDomainInfo.py:_readVMDetails
|    |    1485         try:
|    |    1486             return self._gatherVm(*params)
|    |    |> XendDomainInfo.py:_gatherVm
|    |    | 653         return xstransact.Gather(self.vmpath, *args)
|    |    | > xenstore/xstransact.py:Gather
|    |    |  333         return complete(path, lambda t: t.gather(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    333         return complete(path, lambda t: t.gather(*args))
|    |    |    > xenstore/xstransact.py:gather
|    |    |     169         if len(args) and type(args[0]) != tuple:
|    |    |     171         ret = []
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     188                 val = fn(val)
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     188                 val = fn(val)
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     188                 val = fn(val)
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     188                 val = fn(val)
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     186                 val = defval
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     188                 val = fn(val)
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     188                 val = fn(val)
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     188                 val = fn(val)
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     188                 val = fn(val)
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     188                 val = fn(val)
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     188                 val = fn(val)
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     186                 val = defval
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     188                 val = fn(val)
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     190         if len(ret) == 1:
|    |    |     192         return ret
|    |    |    < xenstore/xstransact.py:gather
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:Gather
|    |    |< XendDomainInfo.py:_gatherVm
|    |    < XendDomainInfo.py:_readVMDetails
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    > XendDomainInfo.py:<lambda>
|    |     625         map(lambda x, y: useIfNeeded(x[0], y), entries,
|    |    |> XendDomainInfo.py:useIfNeeded
|    |    | 613             if not self._infoIsSet(name) and val is not None:
|    |    | > XendDomainInfo.py:_infoIsSet
|    |    | 1604         return name in self.info and self.info[name] is not 
None
|    |    | < XendDomainInfo.py:_infoIsSet
|    |    |< XendDomainInfo.py:useIfNeeded
|    |    < XendDomainInfo.py:<lambda>
|    |    628         devices = []
|    |    630         for devclass in XendDevices.valid_devices():
|    |    > XendDevices.py:valid_devices
|    |      48         return cls.controllers.keys()
|    |    < XendDevices.py:valid_devices
|    |    631             devconfig = 
self.getDeviceController(devclass).configurations()
|    |    > XendDomainInfo.py:getDeviceController
|    |    1152         if name not in self._deviceControllers:
|    |    1153             devController = XendDevices.make_controller(name, 
self)
|    |    |> XendDevices.py:make_controller
|    |    |  62         if name in cls.controllers.keys():
|    |    |  63             cls.controllers[name].deviceClass = name
|    |    |  64             return cls.controllers[name](domain)
|    |    | > server/netif.py:__init__
|    |    |  137         DevController.__init__(self, vm)
|    |    |  > server/DevController.py:__init__
|    |    |    72         self.vm = vm
|    |    |  < server/DevController.py:__init__
|    |    | < server/netif.py:__init__
|    |    |< XendDevices.py:make_controller
|    |    1154             if not devController:
|    |    1156             self._deviceControllers[name] = devController
|    |    1158         return self._deviceControllers[name]
|    |    < XendDomainInfo.py:getDeviceController
|    |    > server/DevController.py:configurations
|    |     216         return map(self.configuration, self.deviceIDs())
|    |    |> server/DevController.py:deviceIDs
|    |    | 368         fe = self.backendRoot()
|    |    | > server/DevController.py:backendRoot
|    |    |  476         from xen.xend.XendDomain import DOM0_ID
|    |    |  477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |  478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |  > xenstore/xsutil.py:GetDomainPath
|    |    |    26     return xshandle().get_domain_path(domid)
|    |    |   > xenstore/xsutil.py:xshandle
|    |    |     15     if not xs_handle:
|    |    |     20     return xs_handle
|    |    |   < xenstore/xsutil.py:xshandle
|    |    |  < xenstore/xsutil.py:GetDomainPath
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    | < server/DevController.py:backendRoot
|    |    | 369         if transaction:
|    |    | 372             return map(int, xstransact.List(fe))
|    |    | > xenstore/xstransact.py:List
|    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    319         return complete(path, lambda t: t.list(*args))
|    |    |    > xenstore/xstransact.py:list
|    |    |     129         if len(args) == 0:
|    |    |     130             ret = xshandle().ls(self.transaction, self.path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     131             if ret is None:
|    |    |     132                 return []
|    |    |    < xenstore/xstransact.py:list
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:List
|    |    |< server/DevController.py:deviceIDs
|    |    < server/DevController.py:configurations
|    |    632             if devconfig:
|    |    630         for devclass in XendDevices.valid_devices():
|    |    631             devconfig = 
self.getDeviceController(devclass).configurations()
|    |    > XendDomainInfo.py:getDeviceController
|    |    1152         if name not in self._deviceControllers:
|    |    1153             devController = XendDevices.make_controller(name, 
self)
|    |    |> XendDevices.py:make_controller
|    |    |  62         if name in cls.controllers.keys():
|    |    |  63             cls.controllers[name].deviceClass = name
|    |    |  64             return cls.controllers[name](domain)
|    |    | > server/usbif.py:__init__
|    |    |   36         DevController.__init__(self, vm)
|    |    |  > server/DevController.py:__init__
|    |    |    72         self.vm = vm
|    |    |  < server/DevController.py:__init__
|    |    | < server/usbif.py:__init__
|    |    |< XendDevices.py:make_controller
|    |    1154             if not devController:
|    |    1156             self._deviceControllers[name] = devController
|    |    1158         return self._deviceControllers[name]
|    |    < XendDomainInfo.py:getDeviceController
|    |    > server/DevController.py:configurations
|    |     216         return map(self.configuration, self.deviceIDs())
|    |    |> server/DevController.py:deviceIDs
|    |    | 368         fe = self.backendRoot()
|    |    | > server/DevController.py:backendRoot
|    |    |  476         from xen.xend.XendDomain import DOM0_ID
|    |    |  477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |  478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |  > xenstore/xsutil.py:GetDomainPath
|    |    |    26     return xshandle().get_domain_path(domid)
|    |    |   > xenstore/xsutil.py:xshandle
|    |    |     15     if not xs_handle:
|    |    |     20     return xs_handle
|    |    |   < xenstore/xsutil.py:xshandle
|    |    |  < xenstore/xsutil.py:GetDomainPath
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    | < server/DevController.py:backendRoot
|    |    | 369         if transaction:
|    |    | 372             return map(int, xstransact.List(fe))
|    |    | > xenstore/xstransact.py:List
|    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    319         return complete(path, lambda t: t.list(*args))
|    |    |    > xenstore/xstransact.py:list
|    |    |     129         if len(args) == 0:
|    |    |     130             ret = xshandle().ls(self.transaction, self.path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     131             if ret is None:
|    |    |     132                 return []
|    |    |    < xenstore/xstransact.py:list
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:List
|    |    |< server/DevController.py:deviceIDs
|    |    < server/DevController.py:configurations
|    |    632             if devconfig:
|    |    630         for devclass in XendDevices.valid_devices():
|    |    631             devconfig = 
self.getDeviceController(devclass).configurations()
|    |    > XendDomainInfo.py:getDeviceController
|    |    1152         if name not in self._deviceControllers:
|    |    1153             devController = XendDevices.make_controller(name, 
self)
|    |    |> XendDevices.py:make_controller
|    |    |  62         if name in cls.controllers.keys():
|    |    |  63             cls.controllers[name].deviceClass = name
|    |    |  64             return cls.controllers[name](domain)
|    |    | > server/blkif.py:__init__
|    |    |   36         DevController.__init__(self, vm)
|    |    |  > server/DevController.py:__init__
|    |    |    72         self.vm = vm
|    |    |  < server/DevController.py:__init__
|    |    | < server/blkif.py:__init__
|    |    |< XendDevices.py:make_controller
|    |    1154             if not devController:
|    |    1156             self._deviceControllers[name] = devController
|    |    1158         return self._deviceControllers[name]
|    |    < XendDomainInfo.py:getDeviceController
|    |    > server/DevController.py:configurations
|    |     216         return map(self.configuration, self.deviceIDs())
|    |    |> server/DevController.py:deviceIDs
|    |    | 368         fe = self.backendRoot()
|    |    | > server/DevController.py:backendRoot
|    |    |  476         from xen.xend.XendDomain import DOM0_ID
|    |    |  477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |  478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |  > xenstore/xsutil.py:GetDomainPath
|    |    |    26     return xshandle().get_domain_path(domid)
|    |    |   > xenstore/xsutil.py:xshandle
|    |    |     15     if not xs_handle:
|    |    |     20     return xs_handle
|    |    |   < xenstore/xsutil.py:xshandle
|    |    |  < xenstore/xsutil.py:GetDomainPath
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    | < server/DevController.py:backendRoot
|    |    | 369         if transaction:
|    |    | 372             return map(int, xstransact.List(fe))
|    |    | > xenstore/xstransact.py:List
|    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    319         return complete(path, lambda t: t.list(*args))
|    |    |    > xenstore/xstransact.py:list
|    |    |     129         if len(args) == 0:
|    |    |     130             ret = xshandle().ls(self.transaction, self.path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     131             if ret is None:
|    |    |     132                 return []
|    |    |    < xenstore/xstransact.py:list
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:List
|    |    |< server/DevController.py:deviceIDs
|    |    < server/DevController.py:configurations
|    |    632             if devconfig:
|    |    630         for devclass in XendDevices.valid_devices():
|    |    631             devconfig = 
self.getDeviceController(devclass).configurations()
|    |    > XendDomainInfo.py:getDeviceController
|    |    1152         if name not in self._deviceControllers:
|    |    1153             devController = XendDevices.make_controller(name, 
self)
|    |    |> XendDevices.py:make_controller
|    |    |  62         if name in cls.controllers.keys():
|    |    |  63             cls.controllers[name].deviceClass = name
|    |    |  64             return cls.controllers[name](domain)
|    |    | > server/irqif.py:__init__
|    |    |   40         DevController.__init__(self, vm)
|    |    |  > server/DevController.py:__init__
|    |    |    72         self.vm = vm
|    |    |  < server/DevController.py:__init__
|    |    | < server/irqif.py:__init__
|    |    |< XendDevices.py:make_controller
|    |    1154             if not devController:
|    |    1156             self._deviceControllers[name] = devController
|    |    1158         return self._deviceControllers[name]
|    |    < XendDomainInfo.py:getDeviceController
|    |    > server/DevController.py:configurations
|    |     216         return map(self.configuration, self.deviceIDs())
|    |    |> server/DevController.py:deviceIDs
|    |    | 368         fe = self.backendRoot()
|    |    | > server/DevController.py:backendRoot
|    |    |  476         from xen.xend.XendDomain import DOM0_ID
|    |    |  477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |  478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |  > xenstore/xsutil.py:GetDomainPath
|    |    |    26     return xshandle().get_domain_path(domid)
|    |    |   > xenstore/xsutil.py:xshandle
|    |    |     15     if not xs_handle:
|    |    |     20     return xs_handle
|    |    |   < xenstore/xsutil.py:xshandle
|    |    |  < xenstore/xsutil.py:GetDomainPath
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    | < server/DevController.py:backendRoot
|    |    | 369         if transaction:
|    |    | 372             return map(int, xstransact.List(fe))
|    |    | > xenstore/xstransact.py:List
|    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    319         return complete(path, lambda t: t.list(*args))
|    |    |    > xenstore/xstransact.py:list
|    |    |     129         if len(args) == 0:
|    |    |     130             ret = xshandle().ls(self.transaction, self.path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     131             if ret is None:
|    |    |     132                 return []
|    |    |    < xenstore/xstransact.py:list
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:List
|    |    |< server/DevController.py:deviceIDs
|    |    < server/DevController.py:configurations
|    |    632             if devconfig:
|    |    630         for devclass in XendDevices.valid_devices():
|    |    631             devconfig = 
self.getDeviceController(devclass).configurations()
|    |    > XendDomainInfo.py:getDeviceController
|    |    1152         if name not in self._deviceControllers:
|    |    1153             devController = XendDevices.make_controller(name, 
self)
|    |    |> XendDevices.py:make_controller
|    |    |  62         if name in cls.controllers.keys():
|    |    |  63             cls.controllers[name].deviceClass = name
|    |    |  64             return cls.controllers[name](domain)
|    |    | > server/pciif.py:__init__
|    |    |   51         DevController.__init__(self, vm)
|    |    |  > server/DevController.py:__init__
|    |    |    72         self.vm = vm
|    |    |  < server/DevController.py:__init__
|    |    | < server/pciif.py:__init__
|    |    |< XendDevices.py:make_controller
|    |    1154             if not devController:
|    |    1156             self._deviceControllers[name] = devController
|    |    1158         return self._deviceControllers[name]
|    |    < XendDomainInfo.py:getDeviceController
|    |    > server/DevController.py:configurations
|    |     216         return map(self.configuration, self.deviceIDs())
|    |    |> server/DevController.py:deviceIDs
|    |    | 368         fe = self.backendRoot()
|    |    | > server/DevController.py:backendRoot
|    |    |  476         from xen.xend.XendDomain import DOM0_ID
|    |    |  477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |  478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |  > xenstore/xsutil.py:GetDomainPath
|    |    |    26     return xshandle().get_domain_path(domid)
|    |    |   > xenstore/xsutil.py:xshandle
|    |    |     15     if not xs_handle:
|    |    |     20     return xs_handle
|    |    |   < xenstore/xsutil.py:xshandle
|    |    |  < xenstore/xsutil.py:GetDomainPath
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    | < server/DevController.py:backendRoot
|    |    | 369         if transaction:
|    |    | 372             return map(int, xstransact.List(fe))
|    |    | > xenstore/xstransact.py:List
|    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    319         return complete(path, lambda t: t.list(*args))
|    |    |    > xenstore/xstransact.py:list
|    |    |     129         if len(args) == 0:
|    |    |     130             ret = xshandle().ls(self.transaction, self.path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     131             if ret is None:
|    |    |     132                 return []
|    |    |    < xenstore/xstransact.py:list
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:List
|    |    |< server/DevController.py:deviceIDs
|    |    < server/DevController.py:configurations
|    |    632             if devconfig:
|    |    630         for devclass in XendDevices.valid_devices():
|    |    631             devconfig = 
self.getDeviceController(devclass).configurations()
|    |    > XendDomainInfo.py:getDeviceController
|    |    1152         if name not in self._deviceControllers:
|    |    1153             devController = XendDevices.make_controller(name, 
self)
|    |    |> XendDevices.py:make_controller
|    |    |  62         if name in cls.controllers.keys():
|    |    |  63             cls.controllers[name].deviceClass = name
|    |    |  64             return cls.controllers[name](domain)
|    |    | > server/iopif.py:__init__
|    |    |   50         DevController.__init__(self, vm)
|    |    |  > server/DevController.py:__init__
|    |    |    72         self.vm = vm
|    |    |  < server/DevController.py:__init__
|    |    | < server/iopif.py:__init__
|    |    |< XendDevices.py:make_controller
|    |    1154             if not devController:
|    |    1156             self._deviceControllers[name] = devController
|    |    1158         return self._deviceControllers[name]
|    |    < XendDomainInfo.py:getDeviceController
|    |    > server/DevController.py:configurations
|    |     216         return map(self.configuration, self.deviceIDs())
|    |    |> server/DevController.py:deviceIDs
|    |    | 368         fe = self.backendRoot()
|    |    | > server/DevController.py:backendRoot
|    |    |  476         from xen.xend.XendDomain import DOM0_ID
|    |    |  477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |  478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |  > xenstore/xsutil.py:GetDomainPath
|    |    |    26     return xshandle().get_domain_path(domid)
|    |    |   > xenstore/xsutil.py:xshandle
|    |    |     15     if not xs_handle:
|    |    |     20     return xs_handle
|    |    |   < xenstore/xsutil.py:xshandle
|    |    |  < xenstore/xsutil.py:GetDomainPath
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    | < server/DevController.py:backendRoot
|    |    | 369         if transaction:
|    |    | 372             return map(int, xstransact.List(fe))
|    |    | > xenstore/xstransact.py:List
|    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    319         return complete(path, lambda t: t.list(*args))
|    |    |    > xenstore/xstransact.py:list
|    |    |     129         if len(args) == 0:
|    |    |     130             ret = xshandle().ls(self.transaction, self.path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     131             if ret is None:
|    |    |     132                 return []
|    |    |    < xenstore/xstransact.py:list
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:List
|    |    |< server/DevController.py:deviceIDs
|    |    < server/DevController.py:configurations
|    |    632             if devconfig:
|    |    630         for devclass in XendDevices.valid_devices():
|    |    631             devconfig = 
self.getDeviceController(devclass).configurations()
|    |    > XendDomainInfo.py:getDeviceController
|    |    1152         if name not in self._deviceControllers:
|    |    1153             devController = XendDevices.make_controller(name, 
self)
|    |    |> XendDevices.py:make_controller
|    |    |  62         if name in cls.controllers.keys():
|    |    |  63             cls.controllers[name].deviceClass = name
|    |    |  64             return cls.controllers[name](domain)
|    |    | > server/BlktapController.py:__init__
|    |    |    9         BlkifController.__init__(self, vm)
|    |    |  > server/blkif.py:__init__
|    |    |    36         DevController.__init__(self, vm)
|    |    |   > server/DevController.py:__init__
|    |    |     72         self.vm = vm
|    |    |   < server/DevController.py:__init__
|    |    |  < server/blkif.py:__init__
|    |    | < server/BlktapController.py:__init__
|    |    |< XendDevices.py:make_controller
|    |    1154             if not devController:
|    |    1156             self._deviceControllers[name] = devController
|    |    1158         return self._deviceControllers[name]
|    |    < XendDomainInfo.py:getDeviceController
|    |    > server/DevController.py:configurations
|    |     216         return map(self.configuration, self.deviceIDs())
|    |    |> server/DevController.py:deviceIDs
|    |    | 368         fe = self.backendRoot()
|    |    | > server/DevController.py:backendRoot
|    |    |  476         from xen.xend.XendDomain import DOM0_ID
|    |    |  477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |  478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |  > xenstore/xsutil.py:GetDomainPath
|    |    |    26     return xshandle().get_domain_path(domid)
|    |    |   > xenstore/xsutil.py:xshandle
|    |    |     15     if not xs_handle:
|    |    |     20     return xs_handle
|    |    |   < xenstore/xsutil.py:xshandle
|    |    |  < xenstore/xsutil.py:GetDomainPath
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    | < server/DevController.py:backendRoot
|    |    | 369         if transaction:
|    |    | 372             return map(int, xstransact.List(fe))
|    |    | > xenstore/xstransact.py:List
|    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    319         return complete(path, lambda t: t.list(*args))
|    |    |    > xenstore/xstransact.py:list
|    |    |     129         if len(args) == 0:
|    |    |     130             ret = xshandle().ls(self.transaction, self.path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     131             if ret is None:
|    |    |     132                 return []
|    |    |    < xenstore/xstransact.py:list
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:List
|    |    |< server/DevController.py:deviceIDs
|    |    < server/DevController.py:configurations
|    |    632             if devconfig:
|    |    630         for devclass in XendDevices.valid_devices():
|    |    631             devconfig = 
self.getDeviceController(devclass).configurations()
|    |    > XendDomainInfo.py:getDeviceController
|    |    1152         if name not in self._deviceControllers:
|    |    1153             devController = XendDevices.make_controller(name, 
self)
|    |    |> XendDevices.py:make_controller
|    |    |  62         if name in cls.controllers.keys():
|    |    |  63             cls.controllers[name].deviceClass = name
|    |    |  64             return cls.controllers[name](domain)
|    |    | > server/tpmif.py:__init__
|    |    |   41         DevController.__init__(self, vm)
|    |    |  > server/DevController.py:__init__
|    |    |    72         self.vm = vm
|    |    |  < server/DevController.py:__init__
|    |    | < server/tpmif.py:__init__
|    |    |< XendDevices.py:make_controller
|    |    1154             if not devController:
|    |    1156             self._deviceControllers[name] = devController
|    |    1158         return self._deviceControllers[name]
|    |    < XendDomainInfo.py:getDeviceController
|    |    > server/DevController.py:configurations
|    |     216         return map(self.configuration, self.deviceIDs())
|    |    |> server/DevController.py:deviceIDs
|    |    | 368         fe = self.backendRoot()
|    |    | > server/DevController.py:backendRoot
|    |    |  476         from xen.xend.XendDomain import DOM0_ID
|    |    |  477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |  478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |  > xenstore/xsutil.py:GetDomainPath
|    |    |    26     return xshandle().get_domain_path(domid)
|    |    |   > xenstore/xsutil.py:xshandle
|    |    |     15     if not xs_handle:
|    |    |     20     return xs_handle
|    |    |   < xenstore/xsutil.py:xshandle
|    |    |  < xenstore/xsutil.py:GetDomainPath
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    | < server/DevController.py:backendRoot
|    |    | 369         if transaction:
|    |    | 372             return map(int, xstransact.List(fe))
|    |    | > xenstore/xstransact.py:List
|    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    319         return complete(path, lambda t: t.list(*args))
|    |    |    > xenstore/xstransact.py:list
|    |    |     129         if len(args) == 0:
|    |    |     130             ret = xshandle().ls(self.transaction, self.path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     131             if ret is None:
|    |    |     132                 return []
|    |    |    < xenstore/xstransact.py:list
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:List
|    |    |< server/DevController.py:deviceIDs
|    |    < server/DevController.py:configurations
|    |    632             if devconfig:
|    |    630         for devclass in XendDevices.valid_devices():
|    |    635         if not self.info['device'] and devices is not None:
|    |    636             for device in devices:
|    |   < XendDomainInfo.py:_augmentInfo
|    |   419         self._checkName(self.info['name'])
|    |   > XendDomainInfo.py:_checkName
|    |   1614         from xen.xend import XendDomain
|    |   1616         if name is None or name == '':
|    |   1619         if not re.search(r'^[A-Za-z0-9_\-\.\:\/\+]+$', name):
|    |   1622         dom =  XendDomain.instance().domain_lookup_nr(name)
|    |    > XendDomain.py:instance
|    |    1333     try:
|    |    1334         inst
|    |    1338     return inst
|    |    < XendDomain.py:instance
|    |    > XendDomain.py:domain_lookup_nr
|    |     485         self.domains_lock.acquire()
|    |     486         try:
|    |     488             match = [dom for dom in self.domains.values() \
|    |     490             if match:
|    |     493             match = [dom for dom in 
self.managed_domains.values() \
|    |     495             if match:
|    |     499             try:
|    |     500                 if int(domid) in self.domains:
|    |    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendDomain.py", line 500, in domain_lookup_nr
    if int(domid) in self.domains:
ValueError: invalid literal for int(): Domain-0
|    |     502             except ValueError:
|    |     503                 pass
|    |     506             match = [dom for dom in self.domains.values() \
|    |     508             if match:
|    |     512             if domid in self.managed_domains:
|    |     515             return None
|    |     517             self.domains_lock.release()
|    |    < XendDomain.py:domain_lookup_nr
|    |   1623         if dom and dom != self and not dom.info['dying']:
|    |   < XendDomainInfo.py:_checkName
|    |   420         self.setResume(resume)
|    |   > XendDomainInfo.py:setResume
|    |    842         self.info['resume'] = state
|    |   < XendDomainInfo.py:setResume
|    |  < XendDomainInfo.py:__init__
|    |  225     if needs_reinitialising:
|    |  231     vm._registerWatches()
|    |  > XendDomainInfo.py:_registerWatches
|    |   729         self.vmWatch = xswatch(self.vmpath, self._storeChanged)
|    |   > xenstore/xswatch.py:__init__
|    |     29         self.path = path
|    |     30         self.fn = fn
|    |     31         self.args = args
|    |     32         self.kwargs = kwargs
|    |     33         watchStart()
|    |    > xenstore/xswatch.py:watchStart
|    |      49     xslock.acquire()
|    |      50     try:
|    |      51         if watchThread:
|    |      53         xs = xshandle()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      54         watchThread = threading.Thread(name="Watcher", 
target=watchMain)
|    |      55         watchThread.setDaemon(True)
|    |      56         watchThread.start()
|    |      58         xslock.release()
|    |    < xenstore/xswatch.py:watchStart
|    |     34         xs.watch(path, self)
|    |    > xenstore/xswatch.py:watchMain
|    |      62     while True:
|    |      63         try:
|    |      64             we = xs.read_watch()
|    |    < xenstore/xswatch.py:__init__
|    |    730         self.shutdownWatch = xswatch(self.dompath + 
'/control/shutdown',
|    |    731                                      self._handleShutdownWatch)
|    |    > xenstore/xswatch.py:__init__
|    |      29         self.path = path
|    |      30         self.fn = fn
|    |      31         self.args = args
|    |      32         self.kwargs = kwargs
|    |      33         watchStart()
|    |    |> xenstore/xswatch.py:watchStart
|    |    |  49     xslock.acquire()
|    |    |  50     try:
|    |    |  51         if watchThread:
|    |    |  52             return
|    |    |  58         xslock.release()
|    |    |< xenstore/xswatch.py:watchStart
|    |      34         xs.watch(path, self)
|    |   |    |    < xenstore/xswatch.py:__init__
|    |   < XendDomainInfo.py:_registerWatches
|    |   232     vm.refreshShutdown(xeninfo)
|    |   > XendDomainInfo.py:refreshShutdown
|    |    856         restart_reason = None
|    |    858         self.refresh_shutdown_lock.acquire()
|    |    859         try:
|    |    860             if xeninfo is None:
|    |    874             if xeninfo['dying']:
|    |    886             elif xeninfo['crashed']:
|    |    901             elif xeninfo['shutdown']:
|    |    928             elif self.dompath is None:
|    |    936                 if xeninfo['paused']:
|    |    939                     self._stateSet(DOM_STATE_RUNNING)
|    |    > XendDomainInfo.py:_stateSet
|    |    1595         self.state_updated.acquire()
|    |    1596         try:
|    |    1597             if self.state != state:
|    |    1598                 self.state = state
|    |    1599                 self.state_updated.notifyAll()
|    |    1601             self.state_updated.release()
|    |    < XendDomainInfo.py:_stateSet
|    |    941                 if self.shutdownStartTime:
|    |    950             self.refresh_shutdown_lock.release()
|    |    952         if restart_reason:
|    |   < XendDomainInfo.py:refreshShutdown
|    |   233     return vm
|    |  < XendDomainInfo.py:recreate
|    |  106                 self._add_domain(dom0)
|    |  > XendDomain.py:_add_domain
|    |   402         log.debug("Adding Domain: %s" % info.getDomid())
|    |   > XendDomainInfo.py:getDomid
|    |    789         return self.domid
|    |   < XendDomainInfo.py:getDomid
|    |   403         self.domains[info.getDomid()] = info
|    |   > XendDomainInfo.py:getDomid
|    |    789         return self.domid
|    |   < XendDomainInfo.py:getDomid
 |   65             watch = we[1]
   |    |    66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
||     < XendDomain.py:_add_domain
 | |      |   110             self._setDom0CPUCount()
> XendDomainInfo.py:_storeChanged
| |    |    734         log.trace("XendDomainInfo.storeChanged");
 |    |    > XendLogging.py:trace
  |   > XendDomain.py:_setDom0CPUCount
|    |     356         dom0 = self.privilegedDomain()
|    |    |    |    |> XendDomain.py:privilegedDomain
||   36         self.log(logging.TRACE, *args, **kwargs)
 |    |    |< XendLogging.py:trace
 |    |     736         changed = False
 |    |     738         def f(x, y):
||    |     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
 |      | |    |> XendDomainInfo.py:_readVMDetails
 524         self.domains_lock.acquire()
| |    |    | 525         try:
 |     |    |1485         try:
 |    |    |1486             return self._gatherVm(*params)
|    | 526             return self.domains[DOM0_ID]
|    |    | > XendDomainInfo.py:_gatherVm
|    |    |  528             self.domains_lock.release()
|    |    |  653         return xstransact.Gather(self.vmpath, *args)
|    |    | < XendDomain.py:privilegedDomain
| |    |    | > xenstore/xstransact.py:Gather
 |     |  |      |  333         return complete(path, lambda t: t.gather(*args))
 |    |    |  > xenstore/xstransact.py:complete
||    |    |   350     while True:
 359         target = int(xroot.get_dom0_vcpus())
| |    |    |   > XendRoot.py:get_dom0_vcpus
   |    |   351         t = xstransact(path)
||       | |        | |     284         return self.get_config_int('dom0-cpus', 
self.dom0_vcpus_default)
 |     |    |    |> XendRoot.py:get_config_int
> xenstore/xstransact.py:__init__
| |     |    |     |  |       | 186         v = self.get_config_value(name, val)
||    |    |    | > XendRoot.py:get_config_value
  14         assert path is not None
| |    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
 |    |    |    |   19         self.path = path.rstrip("/")
 |    |    |    |   20         self.transaction = xshandle().transaction_start()
 |  |   |    |  175         return sxp.child_value(self.config, name, val=val)
 |    |    |    |  < XendRoot.py:get_config_value
 |  |    |    |  > xenstore/xsutil.py:xshandle
 |    |  |    |    |  187         try:
 |    |    |    |  188             return int(v)
  |    |    |    | < XendRoot.py:get_config_int
 | |    |   15     if not xs_handle:
 |    |    |    |  20     return xs_handle
 |    |    |  |    |    |< XendRoot.py:get_dom0_vcpus
 |    |    |       360         log.debug("number of vcpus to use is %d", target)
|< xenstore/xsutil.py:xshandle
|    |    |    363         if target > 0:
|    |    |   < XendDomain.py:_setDom0CPUCount
|    |    |   116             xswatch("@introduceDomain", 
self._on_domains_changed)
|    |    |   > xenstore/xswatch.py:__init__
|    |    |     29         self.path = path
|    |    |     30         self.fn = fn
|    |    |     31         self.args = args
|    |    |     32         self.kwargs = kwargs
|    |    |     33         watchStart()
|    |    |    > xenstore/xswatch.py:watchStart
|    |    |      49     xslock.acquire()
|    |    |      50     try:
|    |    |      51         if watchThread:
|    |    |      52             return
|    |    |      58         xslock.release()
|    |    |    < xenstore/xswatch.py:watchStart
|    |    |     34         xs.watch(path, self)
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    333         return complete(path, lambda t: t.gather(*args))
|    |    |    > xenstore/xstransact.py:gather
|    |    |     169         if len(args) and type(args[0]) != tuple:
|    |    |     171         ret = []
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xswatch.py:__init__
|    |    |     117             xswatch("@releaseDomain",   
self._on_domains_changed)
|    |    |    |> xenstore/xswatch.py:__init__
|    |    |    |  29         self.path = path
|    |    |    |  30         self.fn = fn
|    |    |    |  31         self.args = args
|    |    |    |  32         self.kwargs = kwargs
|    |    |    |  33         watchStart()
|    |    |    | > xenstore/xswatch.py:watchStart
|    |    |    |   49     xslock.acquire()
|    |    |    |   50     try:
|    |    |    |   51         if watchThread:
|    |    |    |   52             return
|    |    |    |   58         xslock.release()
|    |    |    | < xenstore/xswatch.py:watchStart
|    |    |    |  34         xs.watch(path, self)
|    |    |    |< xenstore/xstransact.py:_read
|    |    |     185             if val is None:
|    |    |     188                 val = fn(val)
|    |    |     189             ret.append(val)
|    |    |     172         for tup in args:
|    |    |     173             if len(tup) == 2:
|    |    |     174                 (key, fn) = tup
|    |    |     175                 defval = None
|    |    |     179             val = self._read(key)
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xswatch.py:__init__
|    |    |     119             self._init_domains()
|    |    |    |> XendDomain.py:_init_domains
|    |    |    | 148         self.domains_lock.acquire()
|    |    |    | 149         try:
|    |    |    | 150             running = self._running_domains()
|    |    |    | > XendDomain.py:_running_domains
|    |    |    |  343         try:
|    |    |    |  344             return xc.domain_getinfo()
|    |    |    | < XendDomain.py:_running_domains
|    |    |    | 151             managed = self._managed_domains()
|    |    |    | > XendDomain.py:_managed_domains
|    |    |    |  301         dom_path = self._managed_path()
| |      |    |    |  < xenstore/xstransact.py:_read
 | |      | |        ||     > XendDomain.py:_managed_path
 | |    185             if val is None:
 |    |    |  |    |    |  188                 val = fn(val)
 |    |    |    |  189             ret.append(val)
 | |    205         dom_path = xroot.get_xend_domains_path()
 | |     |    |    |  > XendRoot.py:get_xend_domains_path
 |    |    |     ||     255         return 
self.get_config_value("xend-domains-path", self.xend_domains_path_default)
 |    |    |    |   > XendRoot.py:get_config_value
 |  172         for tup in args:
|    |    |    |  |   175         return sxp.child_value(self.config, name, 
val=val)
 |    |    |      |   < XendRoot.py:get_config_value
||    |    |    |    < XendRoot.py:get_xend_domains_path
  |    |    173             if len(tup) == 2:
| |    |    |    |  206         if domuuid:
 |    |    |      |  208         return dom_path
||     |    |      | < XendDomain.py:_managed_path
 | |       ||   174                 (key, fn) = tup
 |    |    |    | 175                 defval = None
 |    |    |    | 179             val = self._read(key)
 |    | 302         dom_uuids = os.listdir(dom_path)
|    |    |  |   | > xenstore/xstransact.py:_read
 |    |    |      |   44         path = self.prependPath(key)
||    |    |    |    > xenstore/xstransact.py:prependPath
 |  |      |  303         doms = []
 |    |    |    | |     304         for dom_uuid in dom_uuids:
 | |    |    |    |    |    283         if self.path:
 317         return doms
|    |   |  |    |   284             return self.path + '/' + key
 |    |    |    |  < xenstore/xstransact.py:prependPath
 | |      |    |    |   45         try:
 |  |   |    |    |   46             return xshandle().read(self.transaction, 
path)
 |    |    |    |  > xenstore/xsutil.py:xshandle
 |    |    < XendDomain.py:_managed_domains
||    |    |    |  154             for dom in running:
 |      |   |     |  |   15     if not xs_handle:
 |    |    |    |   20     return xs_handle
 |      |    |    | < xenstore/xsutil.py:xshandle
|  155                 if dom['dying'] == 1:
|    |    |    | 160                 if dom['domid'] != DOM0_ID:
| |    |    |     |     |< xenstore/xstransact.py:_read
 |    |    |     185             if val is None:
||       | |    154             for dom in running:
 |   |  |    |        188                 val = fn(val)
 169             for dom in managed:
|    |    |     189             ret.append(val)
| |    |    |      |    |     188             self.domains_lock.release()
 |    |    |     172         for tup in args:
< XendDomain.py:_init_domains
| |      |    |    121             self.domains_lock.release()
 |    |    | |   < XendDomain.py:init
 |   |       173             if len(tup) == 2:
 |    |    |   174                 (key, fn) = tup
||    |    |   175                 defval = None
 |    |    |   179             val = self._read(key)
  |  |   |    |   > xenstore/xstransact.py:_read
 |    |    |     44         path = self.prependPath(key)
 1338     return inst
| |    |    |       |    |    > xenstore/xstransact.py:prependPath
< XendDomain.py:instance
| |    |    |     283         if self.path:
 |    |    |    284             return self.path + '/' + key
  | |      |   < server/SrvDomainDir.py:__init__
 | |      |   < xenstore/xstransact.py:prependPath
 ||      |    39         for (name, klass) in self.subdirs:
 |    |    |   40             self.get(name)
 |    |  |   |     |> server/SrvVnetDir.py:?
   45         try:
|    |    |    46             return xshandle().read(self.transaction, path)
|    ||    |    |       |   18 from xen.xend import sxp
 |    |    |     19 from xen.xend.Args import FormFn
 |    |    |     20 from xen.xend import PrettyPrint
> xenstore/xsutil.py:xshandle
| |    |    |     15     if not xs_handle:
 |    |    |     20     return xs_handle
 |  |     |    |   < xenstore/xsutil.py:xshandle
  |     21 from xen.xend import XendVnet
|  |    |      | |    < xenstore/xstransact.py:_read
 |  |   |    |   185             if val is None:
 |    |    |   188                 val = fn(val)
 |    |    |   189             ret.append(val)
 | > XendVnet.py:?
   |    |   172         for tup in args:
|   |    |    |   |  20 """
 |    |   190         if len(ret) == 1:
 |   |      | |    22 from xen.util import Brctl
 |      |   |   192         return ret
 |  |   |    |  < xenstore/xstransact.py:gather
 |    |    | < xenstore/xstransact.py:<lambda>
   23 from xen.xend import sxp
| |      |   |  |  24 from xen.xend.XendError import XendError
 |       ||  354             if t.commit():
 |     |  25 from xen.xend.XendLogging import log
 | |    |      | > xenstore/xstransact.py:commit
 | |     26 from xen.xend.xenstore.xstransact import xstransact
 |  |   |      | |   29 def vnet_cmd(cmd):
 |    |   28         if not self.in_transaction:
 |    |    |   30         self.in_transaction = False
 |    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
 ||    40 class XendVnetInfo:
 |      |   |    |  > xenstore/xsutil.py:xshandle
 |    |    |     15     if not xs_handle:
|  |  > XendVnet.py:XendVnetInfo
 |    |      | |     40 class XendVnetInfo:
 |      | |     20     return xs_handle
 |     | |    |   < xenstore/xsutil.py:xshandle
     42     vifctl_ops = {'up': 'vif.add', 'down': 'vif.del'}
|    |    |    44     def __init__(self, dbpath, config=None):
|    |    |    62     def exportToDB(self, save=False, sync=False):
|    |    |    71     def importFromDB(self):
| |      |    |    79     def sxpr(self):
 |    |   |  |     |  82     def configure(self):
 |    |   32         self.transaction = "0"
 |    |    |    33         return rc
 |     |    89     def delete(self):
 | |    |    |    97     def vifctl(self, op, vif, vmac):
 |    |      | |  < xenstore/xstransact.py:commit
 | < XendVnet.py:XendVnetInfo
 |      | |      |   355                 return result
||    |  104 class XendVnet:
 |      |   |< xenstore/xstransact.py:complete
 |    |    | > xenstore/xstransact.py:__del__
| |    |    |   24         if self.in_transaction:
> XendVnet.py:XendVnet
| |    |    |  104 class XendVnet:
 |    |    |  108     dbpath = "/vnet"
 |    |    |  110     def __init__(self):
 |    | < xenstore/xstransact.py:__del__
| |    |    |< xenstore/xstransact.py:Gather
 |     |  |    < XendDomainInfo.py:_gatherVm
 |     |  125     def vnet_of_bridge(self, bridge):
 | |   < XendDomainInfo.py:_readVMDetails
 |     | |      137     def vnet_ls(self):
 |    |    142     def vnets(self):
> XendDomainInfo.py:f
|    | |    |    739             if y is not None and self.info[x[0]] != y:
 |    |   < XendDomainInfo.py:f
 |    |   > XendDomainInfo.py:f
 147     def vnet_get(self, id):
|    |    739             if y is not None and self.info[x[0]] != y:
|    | |    |   < XendDomainInfo.py:f
 |    |   > XendDomainInfo.py:f
 |    |    155     def vnet_create(self, config):
 739             if y is not None and self.info[x[0]] != y:
|    | |    |   < XendDomainInfo.py:f
 |      165     def vnet_delete(self, id):
||   > XendDomainInfo.py:f
 |      | |     < XendVnet.py:XendVnet
 |    |   175 def instance():
 739             if y is not None and self.info[x[0]] != y:
|    |  < XendVnet.py:?
| |    |   22 from xen.xend.XendError import XendError
 |    |   24 from xen.web.SrvDir import SrvDir
 |    |   26 class SrvVnet(SrvDir):
 |    |  > server/SrvVnetDir.py:SrvVnet
||    |    26 class SrvVnet(SrvDir):
 |    |    28     def __init__(self, vnetinfo):
 |    |    33     def op_delete(self, op, req):
< XendDomainInfo.py:f
| |    |  745         im = self._readVm('image')
 |     |     37     def render_POST(self, req):
||     > XendDomainInfo.py:_readVm
 | |      40     def render_GET(self, req):
 |    |    55     def form(self, req):
||    |    < server/SrvVnetDir.py:SrvVnet
 644         return xstransact.Read(self.vmpath, *args)
|    |   61 class SrvVnetDir(SrvDir):
|    |  > xenstore/xstransact.py:Read
| |      |   > server/SrvVnetDir.py:SrvVnetDir
 |    |     61 class SrvVnetDir(SrvDir):
||     |     65     def __init__(self):
 |    |     69     def vnet(self, x):
 |    |  297         return complete(path, lambda t: t.read(*args))
 |   77     def get(self, x):
 |      |    > xenstore/xstransact.py:complete
 |    |     350     while True:
||        84     def op_create(self, op, req):
 |     |     351         t = xstransact(path)
||    |    |> xenstore/xstransact.py:__init__
      90     def render_POST(self, req):
|    |    |  14         assert path is not None
| |     |    |     |  93     def render_GET(self, req):
 |    |    | 105     def ls_vnet(self, req, use_sxp=0):
|  16         self.in_transaction = False # Set this temporarily -- if this
| |      |    | 121     def form(self, req):
 |    |    || < server/SrvVnetDir.py:SrvVnetDir
|    |  19         self.path = path.rstrip("/")
 |    |      20         self.transaction = xshandle().transaction_start()
 |  |      < server/SrvVnetDir.py:?
 |    |  |     | |> server/SrvVnetDir.py:__init__
> xenstore/xsutil.py:xshandle
| |    |    |  15     if not xs_handle:
 |    |    |  20     return xs_handle
 |  |    |  66         SrvDir.__init__(self)
 |      ||    |< xenstore/xsutil.py:xshandle
    |  67         self.xvnet = XendVnet.instance()
|    |    |> XendVnet.py:instance
|    |    | 177     try:
|    |    | 178         inst
|    |    |! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendVnet.py", line 178, in instance
    inst
NameError: global name 'inst' is not defined
|    |    | 179     except:
| |    |    | 180         inst = XendVnet()
 |    |      | > XendVnet.py:__init__
||      |    |  112         self.vnet = {}
 |    |    |  113         listing = xstransact.List(self.dbpath)
 ||    |    |  > xenstore/xstransact.py:List
  21         self.in_transaction = True
| |    |    |  < xenstore/xstransact.py:__init__
  |  |      |   319         return complete(path, lambda t: t.list(*args))
 |    |    |  > xenstore/xstransact.py:complete
||    |    |   350     while True:
|     |   |  352         try:
 |    |      |   351         t = xstransact(path)
 |    |    |   > xenstore/xstransact.py:__init__
||    353             result = f(t)
 |     |  |    |     14         assert path is not None
 |      |   |  |   > xenstore/xstransact.py:<lambda>
 |    |    |       297         return complete(path, lambda t: t.read(*args))
 |    |    |    |> xenstore/xstransact.py:read
  16         self.in_transaction = False # Set this temporarily -- if this
| |       |    |    |  19         self.path = path.rstrip("/")
||    |        |   |  |    20         self.transaction = 
xshandle().transaction_start()
 |    |    |    | > xenstore/xsutil.py:xshandle
|  59         if len(args) == 0:
|    | |      |    |    |   61         if len(args) == 1:
 | |      | |    |    |   62             return self._read(args[0])
 |    |    |    |  > xenstore/xstransact.py:_read
  15     if not xs_handle:
| |    |    |      |    20     return xs_handle
 |  |     |  |     |      | |  < xenstore/xsutil.py:xshandle
   44         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   45         try:
|    |    |    |   46             return xshandle().read(self.transaction, path)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|  |    |    |      | < xenstore/xstransact.py:_read
||       |    | < xenstore/xstransact.py:__init__
 |    |    | |    |    |< xenstore/xstransact.py:read
 |    |    |   < xenstore/xstransact.py:<lambda>
  |  352         try:
 |    |    |   353             result = f(t)
  |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:<lambda>
| |    |    |     319         return complete(path, lambda t: t.list(*args))
 |    |      |  |   |> xenstore/xstransact.py:list
 |    |      | |    > xenstore/xstransact.py:commit
 |    | 129         if len(args) == 0:
 |    |  |    |    |  28         if not self.in_transaction:
 |    |    |    |  30         self.in_transaction = False
 |  |      | 130             ret = xshandle().ls(self.transaction, self.path)
 | |    |    |  31         rc = xshandle().transaction_end(self.transaction, 
False)
 |    |    |    |  > xenstore/xsutil.py:xshandle
 |  |    |    | > xenstore/xsutil.py:xshandle
 |    |    |    |    15     if not xs_handle:
 |  |   |    |    |    20     return xs_handle
 |    |    |    |  < xenstore/xsutil.py:xshandle
   |    |    15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    | 131             if ret is None:
|    |    |    | 132                 return []
|    |    |   |    |    |  |   |  32         self.transaction = "0"
< xenstore/xstransact.py:list
| |    |    |      < xenstore/xstransact.py:<lambda>
 |   |  |    |    354             if t.commit():
 |     |  |    |    > xenstore/xstransact.py:commit
 |    |    |      |  33         return rc
  28         if not self.in_transaction:
| |      |    |      30         self.in_transaction = False
 | |      | |    < xenstore/xstransact.py:commit
 |    |    |    355                 return result
 |    |    |   < xenstore/xstransact.py:complete
  |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |   > xenstore/xstransact.py:__del__
|    |    |    > xenstore/xsutil.py:xshandle
| |    |    |      15     if not xs_handle:
 |     |    |  |   |      20     return xs_handle
 |        24         if self.in_transaction:
 |    |    |    | < xenstore/xstransact.py:__del__
 |      |    |   < xenstore/xstransact.py:Read
||       < xenstore/xsutil.py:xshandle
 |    |  < XendDomainInfo.py:_readVm
|    |    | 746         current_im = self.info['image']
|    |    | 747         if (im is not None and
|    |    | 752         if changed:
|    |    | 757         return 1
|    |    |< XendDomainInfo.py:_storeChanged
|    |      67             if not res:
|    |      62     while True:
|    |      63         try:
|    |      64             we = xs.read_watch()
|    |      65             watch = we[1]
|    |      66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    |    |> XendDomainInfo.py:_handleShutdownWatch
|    |    | 760         log.debug('XendDomainInfo.handleShutdownWatch')
|    |    | 762         reason = self._readDom('control/shutdown')
|    |    | > XendDomainInfo.py:_readDom
|    |    |  663         return xstransact.Read(self.dompath, *args)
|    |    |  > xenstore/xstransact.py:Read
|    |    |   297         return complete(path, lambda t: t.read(*args))
|    |    |   > xenstore/xstransact.py:complete
|    |    |    350     while True:
|    |    |    351         t = xstransact(path)
|    |    |    > xenstore/xstransact.py:__init__
|    |    |      14         assert path is not None
|    |    |      16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |      19         self.path = path.rstrip("/")
|    |    |      20         self.transaction = xshandle().transaction_start()
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |      32         self.transaction = "0"
|    |    |      33         return rc
|    |    |    < xenstore/xstransact.py:commit
|    |    |    350     while True:
|    |    |    351         t = xstransact(path)
| |    |       |  |    > xenstore/xstransact.py:__init__
 |    |  |     |    21         self.in_transaction = True
 |    |    |      < xenstore/xstransact.py:__init__
   14         assert path is not None
|   |    | |    |     16         self.in_transaction = False # Set this 
temporarily -- if this
 |    |    |     19         self.path = path.rstrip("/")
 |    |    |       20         self.transaction = xshandle().transaction_start()
||    |    |    > xenstore/xsutil.py:xshandle
 |      | 352         try:
 |      |  |        15     if not xs_handle:
 | |     353             result = f(t)
 |      | |      | |      |> xenstore/xstransact.py:<lambda>
 |    20     return xs_handle
 |    |      |    || < xenstore/xsutil.py:xshandle
   |    | 297         return complete(path, lambda t: t.read(*args))
|    |    |    |> xenstore/xstransact.py:read
|    |    |    |  59         if len(args) == 0:
|    |    |    |  61         if len(args) == 1:
|    |    |    |  62             return self._read(args[0])
|    |    |    | > xenstore/xstransact.py:_read
|    |    |    |   44         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   45         try:
|    |    |    |   46             return xshandle().read(self.transaction, path)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|    |    |    |  |     |  |< xenstore/xstransact.py:_read
 |    |    |      |< xenstore/xstransact.py:read
 | |    |    |    < xenstore/xstransact.py:<lambda>
< xenstore/xstransact.py:__init__
| |      |    | |       |  354             if t.commit():
 |  352         try:
 |    |    |    353             result = f(t)
 |   |    |     |  |    > xenstore/xstransact.py:<lambda>
 |  > xenstore/xstransact.py:commit
 |    |    |        28         if not self.in_transaction:
||     |     319         return complete(path, lambda t: t.list(*args))
 |    |    |     |    |      30         self.in_transaction = False
 |    |    |    |  31         rc = xshandle().transaction_end(self.transaction, 
False)
|| > xenstore/xstransact.py:list
 |     |  |   |    | > xenstore/xsutil.py:xshandle
 |      |    |    |   15     if not xs_handle:
 | |    |   |    |    |   20     return xs_handle
 |    |    |    | < xenstore/xsutil.py:xshandle
 129         if len(args) == 0:
|    |    |    | 130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    | > xenstore/xsutil.py:xshandle
| |    |    |      |   32         self.transaction = "0"
 |    |    |    |   33         return rc
||       |    |    | < xenstore/xstransact.py:commit
 |    |    |    | 355                 return result
|  |     |   15     if not xs_handle:
 | |      |   |     |  |  < xenstore/xstransact.py:complete
 |    |    |    |> xenstore/xstransact.py:__del__
|  20     return xs_handle
| |      | |    |    |< xenstore/xsutil.py:xshandle
    |    |  24         if self.in_transaction:
|    |    |    < xenstore/xstransact.py:__del__
|    |    |   < xenstore/xstransact.py:Read
|    |    |  < XendDomainInfo.py:_readDom
|    |    |  764         if reason and reason != 'suspend':
|    |    |  780         return True
|    |    | < XendDomainInfo.py:_handleShutdownWatch
|    |    |  67             if not res:
|    |    |  62     while True:
|    |    |  63         try:
|    |    |  64             we = xs.read_watch()
|    |    |  65             watch = we[1]
|    |    |  66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    |    | > XendDomain.py:_on_domains_changed
|    |    |  133         self.domains_lock.acquire()
|    |    |  134         try:
|    |    |  135             self._refresh()
|    |    |  > XendDomain.py:_refresh
|    |    |   379         running = self._running_domains()
|    |    |   > XendDomain.py:_running_domains
|    |    |    343         try:
|    |    |    344             return xc.domain_getinfo()
|    |    |   < XendDomain.py:_running_domains
|    |    |   380         for dom in running:
|    |    |   381             domid = dom['domid']
|    |    |   382             if domid in self.domains and dom['dying'] != 1:
|    |    |   383                 self.domains[domid].update(dom)
|    |    |   > XendDomainInfo.py:update
|    |    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", 
info,
|    |    |   1631                   str(self.domid))
|    |    |    > XendLogging.py:trace
|    |    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    |    < XendLogging.py:trace
|    |    |   1633         if not info:
|    |    |   1639         if security.on() and info.has_key('ssidref'):
|    |    |   1647         if 'ssidref' in info:
|    |    |   1648             info.pop('ssidref')
|    |    |   1653         self.info.update(info)
|    |    |   1654         self.info.validate()
|    |    |    > XendConfig.py:validate
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     762                 self[key] = default_func(self)
|    |    |    |> XendConfig.py:<lambda>
|    |    |    | 202     ('bootloader',   lambda info: None),
|    |    |    |< XendConfig.py:<lambda>
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     762                 self[key] = default_func(self)
|    |    |    |> XendConfig.py:<lambda>
|    |    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |    |< XendConfig.py:<lambda>
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     762                 self[key] = default_func(self)
|    |    |    |> XendConfig.py:<lambda>
|    |    |    | 206     ('image',        lambda info: None),
|    |    |    |< XendConfig.py:<lambda>
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     765         if 'image' in self and isinstance(self['image'], 
str):
|    |    |     767         if 'security' in self and 
isinstance(self['security'], str):
|    |    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |    |     771         if self['memory'] <= 0:
|    |    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |    |     778         if 'mem_kb' in self:
|    |    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |    |     782         for d_uuid, (d_type, d_info) in 
self['device'].items():
|    |    |     787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |    |     787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |    |     787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |    |     787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |     793         if 'vif_refs' not in self:
|    |    |     795         if 'vbd_refs' not in self:
|    |    |     797         if 'vtpm_refs' not in self:
|    |    |    < XendConfig.py:validate
|    |    |   1656         if refresh:
|    |    |   1657             self.refreshShutdown(info)
|    |    |    > XendDomainInfo.py:refreshShutdown
|    |    |     856         restart_reason = None
|    |    |     858         self.refresh_shutdown_lock.acquire()
|    |    |     859         try:
|    |    |     860             if xeninfo is None:
|    |    |     874             if xeninfo['dying']:
|    |    |     886             elif xeninfo['crashed']:
|    |    |     901             elif xeninfo['shutdown']:
|    |    |     928             elif self.dompath is None:
|    |    |     936                 if xeninfo['paused']:
|    |    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |    |> XendDomainInfo.py:_stateSet
|    |    |    |1595         self.state_updated.acquire()
|    |    |    |1596         try:
|    |    |    |1597             if self.state != state:
|    |    |    |1601             self.state_updated.release()
|    |    |    |< XendDomainInfo.py:_stateSet
|    |    |     941                 if self.shutdownStartTime:
|    |    |     950             self.refresh_shutdown_lock.release()
|    |    |     952         if restart_reason:
|    |    |    < XendDomainInfo.py:refreshShutdown
|    |    |   1659         log.trace("XendDomainInfo.update done on domain %s: 
%s",
|    |    |   1660                   str(self.domid), self.info)
|    |    |    > XendLogging.py:trace
|    |    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    |    < XendLogging.py:trace
|    |    |   < XendDomainInfo.py:update
|    |    |   380         for dom in running:
|    |    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |    |   390         for domid, dom in self.domains.items():
|    |    |   391             if domid not in running_domids and domid != 
DOM0_ID:
|    |    |   390         for domid, dom in self.domains.items():
|    |    |  < XendDomain.py:_refresh
|    |    |  137             self.domains_lock.release()
|    |    |  138         return 1
|    |    | < XendDomain.py:_on_domains_changed
|    |    |  67             if not res:
|    |    |  62     while True:
|    |    |  63         try:
|    |    |  64             we = xs.read_watch()
|    |    |  65             watch = we[1]
|    |    |  66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    |    | > XendDomain.py:_on_domains_changed
|    |    |  133         self.domains_lock.acquire()
|    |    |  134         try:
|    |    |  135             self._refresh()
|    |    |  > XendDomain.py:_refresh
|    |    |   379         running = self._running_domains()
|    |    |   > XendDomain.py:_running_domains
|    |    |    343         try:
|    |    |    344             return xc.domain_getinfo()
|    |    |   < XendDomain.py:_running_domains
|    |    |   380         for dom in running:
|    |    |   381             domid = dom['domid']
|    |    |   382             if domid in self.domains and dom['dying'] != 1:
|    |    |   383                 self.domains[domid].update(dom)
|    |    |   > XendDomainInfo.py:update
|    |    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", 
info,
|    |    |   1631                   str(self.domid))
|    |    |    > XendLogging.py:trace
|    |    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    |    < XendLogging.py:trace
|    |    |   1633         if not info:
|    |    |   1639         if security.on() and info.has_key('ssidref'):
|    |    |   1647         if 'ssidref' in info:
|    |    |   1648             info.pop('ssidref')
|    |    |   1653         self.info.update(info)
|    |    |   1654         self.info.validate()
|    |    |    > XendConfig.py:validate
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     762                 self[key] = default_func(self)
|    |    |    |> XendConfig.py:<lambda>
|    |    |    | 202     ('bootloader',   lambda info: None),
|    |    |    |< XendConfig.py:<lambda>
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     762                 self[key] = default_func(self)
|    |    |    |> XendConfig.py:<lambda>
|    |    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |    |< XendConfig.py:<lambda>
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     762                 self[key] = default_func(self)
|    |    |    |> XendConfig.py:<lambda>
|    |    |    | 206     ('image',        lambda info: None),
|    |    |    |< XendConfig.py:<lambda>
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     765         if 'image' in self and isinstance(self['image'], 
str):
|    |    |     767         if 'security' in self and 
isinstance(self['security'], str):
|    |    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |    |     771         if self['memory'] <= 0:
|    |    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |    |     778         if 'mem_kb' in self:
|    |    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |    |     782         for d_uuid, (d_type, d_info) in 
self['device'].items():
|    |    |     787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |    |     787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |    |     787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |    |     787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |     793         if 'vif_refs' not in self:
|    |    |     795         if 'vbd_refs' not in self:
| |     |    |     131             if ret is None:
 |    |  |      |     797         if 'vtpm_refs' not in self:
 |    |    |    < XendConfig.py:validate
||    |    |     1656         if refresh:
 |   132                 return []
 |    |    |   < xenstore/xstransact.py:list
  |    |   1657             self.refreshShutdown(info)
|    |    |  < xenstore/xstransact.py:<lambda>
| |    |       ||     354             if t.commit():
 |   |    |  > XendDomainInfo.py:refreshShutdown
 |    |    |    856         restart_reason = None
  | |     > xenstore/xstransact.py:commit
 |    |   |  |   |    858         self.refresh_shutdown_lock.acquire()
 |    |    |    859         try:
 |    |    |    860             if xeninfo is None:
   28         if not self.in_transaction:
| |       ||        |    874             if xeninfo['dying']:
||    |      |    886             elif xeninfo['crashed']:
 |    |    |    901             elif xeninfo['shutdown']:
  30         self.in_transaction = False
| |      |    |     31         rc = 
xshandle().transaction_end(self.transaction, False)
 |    |    | |      > xenstore/xsutil.py:xshandle
 |    |    |      15     if not xs_handle:
||       928             elif self.dompath is None:
 |    |    |     936                 if xeninfo['paused']:
||        |    |     939                     self._stateSet(DOM_STATE_RUNNING)
||    |    |    |> XendDomainInfo.py:_stateSet
 |      |    |    |1595         self.state_updated.acquire()
 |    |    |      20     return xs_handle
||    | 1596         try:
 |     |  |   |< xenstore/xsutil.py:xshandle
    |    |1597             if self.state != state:
|    |    |    1601             self.state_updated.release()
|    |    |    < XendDomainInfo.py:_stateSet
|    |    |    941                 if self.shutdownStartTime:
|    |    |    950             self.refresh_shutdown_lock.release()
|    |    |    952         if restart_reason:
|    |    |   < XendDomainInfo.py:refreshShutdown
|    |    |  1659         log.trace("XendDomainInfo.update done on domain %s: 
%s",
|    |    |  1660                   str(self.domid), self.info)
|    |    |   > XendLogging.py:trace
|    |    |     36         self.log(logging.TRACE, *args, **kwargs)
|    |    |   < XendLogging.py:trace
|    |    |  < XendDomainInfo.py:update
|    |    |  380         for dom in running:
|    |    |  389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |    |  389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |    |  390         for domid, dom in self.domains.items():
|    |    |  391             if domid not in running_domids and domid != 
DOM0_ID:
|    |    |  390         for domid, dom in self.domains.items():
| |    |    |    |    32         self.transaction = "0"
 |    |    |   33         return rc
 |    |    | < xenstore/xstransact.py:commit
||    |    | 350     while True:
 |    |    | 351         t = xstransact(path)
| < XendDomain.py:_refresh
 |    |     |  | 137             self.domains_lock.release()
 |      |    | | 138         return 1
> xenstore/xstransact.py:__init__
| |    |    |  14         assert path is not None
 |     |  |      |  16         self.in_transaction = False # Set this 
temporarily -- if this
 | |< XendDomain.py:_on_domains_changed
 |    |      67             if not res:
  | |      |      62     while True:
 |    |      63         try:
||   19         self.path = path.rstrip("/")
 |     |  |     64             we = xs.read_watch()
      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     319         return complete(path, lambda t: t.list(*args))
|    |    |> xenstore/xstransact.py:list
|    |    | 129         if len(args) == 0:
|    |    | 130             ret = xshandle().ls(self.transaction, self.path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 131             if ret is None:
|    |    | 132                 return []
|    |    |< xenstore/xstransact.py:list
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:List
|    |  114         for entry in listing:
|    | < XendVnet.py:__init__
|    | 181     return inst
|    |< XendVnet.py:instance
|    < server/SrvVnetDir.py:__init__
|     39         for (name, klass) in self.subdirs:
|   < server/SrvRoot.py:__init__
|   133     servers = XendServers()
|   > server/SrvServer.py:__init__
|     64         self.servers = []
|   < server/SrvServer.py:__init__
|   134     if xroot.get_xend_http_server():
|   > XendRoot.py:get_xend_http_server
|    195         return self.get_config_bool("xend-http-server", 
self.xend_http_server_default)
|    > XendRoot.py:get_config_bool
|     178         v = string.lower(str(self.get_config_value(name, val)))
|    |> XendRoot.py:get_config_value
|    | 175         return sxp.child_value(self.config, name, val=val)
|    |< XendRoot.py:get_config_value
|     179         if v in ['yes', 'y', '1', 'on',  'true',  't']:
|     181         if v in ['no',  'n', '0', 'off', 'false', 'f']:
|     182             return False
|    < XendRoot.py:get_config_bool
|   < XendRoot.py:get_xend_http_server
|   138     if xroot.get_xend_unix_server():
|   > XendRoot.py:get_xend_unix_server
|    245         return self.get_config_bool("xend-unix-server", 
self.xend_unix_server_default)
|    > XendRoot.py:get_config_bool
|     178         v = string.lower(str(self.get_config_value(name, val)))
|    |> XendRoot.py:get_config_value
|    | 175         return sxp.child_value(self.config, name, val=val)
|    |< XendRoot.py:get_config_value
|     179         if v in ['yes', 'y', '1', 'on',  'true',  't']:
|     181         if v in ['no',  'n', '0', 'off', 'false', 'f']:
|     182             return False
|    < XendRoot.py:get_config_bool
|   < XendRoot.py:get_xend_unix_server
|   143     if xroot.get_xend_tcp_xmlrpc_server():
|   > XendRoot.py:get_xend_tcp_xmlrpc_server
|    198         return self.get_config_bool("xend-tcp-xmlrpc-server",
|    199                                     
self.xend_tcp_xmlrpc_server_default)
|    > XendRoot.py:get_config_bool
|     178         v = string.lower(str(self.get_config_value(name, val)))
|    |> XendRoot.py:get_config_value
|    | 175         return sxp.child_value(self.config, name, val=val)
|    |< XendRoot.py:get_config_value
|     179         if v in ['yes', 'y', '1', 'on',  'true',  't']:
|     181         if v in ['no',  'n', '0', 'off', 'false', 'f']:
|     182             return False
|    < XendRoot.py:get_config_bool
|   < XendRoot.py:get_xend_tcp_xmlrpc_server
|   146     if xroot.get_xend_unix_xmlrpc_server():
|   > XendRoot.py:get_xend_unix_xmlrpc_server
|    202         return self.get_config_bool("xend-unix-xmlrpc-server",
|    203                                     
self.xend_unix_xmlrpc_server_default)
|    > XendRoot.py:get_config_bool
|     178         v = string.lower(str(self.get_config_value(name, val)))
|    |> XendRoot.py:get_config_value
|    | 175         return sxp.child_value(self.config, name, val=val)
|    |< XendRoot.py:get_config_value
|     179         if v in ['yes', 'y', '1', 'on',  'true',  't']:
|     180             return True
|    < XendRoot.py:get_config_bool
|   < XendRoot.py:get_xend_unix_xmlrpc_server
|   147         servers.add(XMLRPCServer())
|   > server/XMLRPCServer.py:__init__
|     89         self.use_tcp = use_tcp
|     90         self.port = port
|     91         self.host = host
|     92         self.path = path
|     94         self.ready = False        
|     95         self.running = True
|     96         self.xenapi = XendAPI()
|    > XendAPI.py:__init__
|     284         classes = {
|     301         for cls in classes.keys():
|     302             get_by_uuid = '%s_get_by_uuid' % cls.lower()
|     303             get_uuid = '%s_get_uuid' % cls.lower()            
|     304             setattr(XendAPI, get_by_uuid,
|     305                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     306             setattr(XendAPI, get_uuid,
|     307                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     301         for cls in classes.keys():
|     302             get_by_uuid = '%s_get_by_uuid' % cls.lower()
|     303             get_uuid = '%s_get_uuid' % cls.lower()            
|     304             setattr(XendAPI, get_by_uuid,
|     305                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     306             setattr(XendAPI, get_uuid,
|     307                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     301         for cls in classes.keys():
|     302             get_by_uuid = '%s_get_by_uuid' % cls.lower()
|     303             get_uuid = '%s_get_uuid' % cls.lower()            
|     304             setattr(XendAPI, get_by_uuid,
|     305                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     306             setattr(XendAPI, get_uuid,
|     307                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     301         for cls in classes.keys():
|     302             get_by_uuid = '%s_get_by_uuid' % cls.lower()
|     303             get_uuid = '%s_get_uuid' % cls.lower()            
|     304             setattr(XendAPI, get_by_uuid,
|     305                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     306             setattr(XendAPI, get_uuid,
|     307                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     301         for cls in classes.keys():
|     302             get_by_uuid = '%s_get_by_uuid' % cls.lower()
|     303             get_uuid = '%s_get_uuid' % cls.lower()            
|     304             setattr(XendAPI, get_by_uuid,
|     305                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     306             setattr(XendAPI, get_uuid,
|     307                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     301         for cls in classes.keys():
|     302             get_by_uuid = '%s_get_by_uuid' % cls.lower()
|     303             get_uuid = '%s_get_uuid' % cls.lower()            
|     304             setattr(XendAPI, get_by_uuid,
|     305                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     306             setattr(XendAPI, get_uuid,
|     307                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     301         for cls in classes.keys():
|     302             get_by_uuid = '%s_get_by_uuid' % cls.lower()
|     303             get_uuid = '%s_get_uuid' % cls.lower()            
|     304             setattr(XendAPI, get_by_uuid,
|     305                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     306             setattr(XendAPI, get_uuid,
|     307                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     301         for cls in classes.keys():
|     302             get_by_uuid = '%s_get_by_uuid' % cls.lower()
|     303             get_uuid = '%s_get_uuid' % cls.lower()            
|     304             setattr(XendAPI, get_by_uuid,
|     305                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     306             setattr(XendAPI, get_uuid,
|     307                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     301         for cls in classes.keys():
|     302             get_by_uuid = '%s_get_by_uuid' % cls.lower()
|     303             get_uuid = '%s_get_uuid' % cls.lower()            
|     304             setattr(XendAPI, get_by_uuid,
|     305                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     306             setattr(XendAPI, get_uuid,
|     307                     lambda s, sess, obj_ref: xen_api_success(obj_ref))
|     301         for cls in classes.keys():
|     318         for cls, validators in classes.items():
|     319             ro_attrs = getattr(self, '%s_attr_ro' % cls, [])
|     320             rw_attrs = getattr(self, '%s_attr_rw' % cls, [])
|     321             methods  = getattr(self, '%s_methods' % cls, [])
|     322             funcs    = getattr(self, '%s_funcs' % cls, [])
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vif_get_network_read_kbs'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vif_get_network_write_kbs'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 
'vif_get_io_bandwidth_incoming_kbs'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 
'vif_get_io_bandwidth_outgoing_kbs'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vif_get_name'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vif_get_type'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vif_get_device'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vif_get_network'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vif_get_vm'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vif_get_mac'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vif_get_mtu'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vif
|    | 162     def check_vif_ref(self, session, vif_ref, *args, **kwargs):
|    | 172     if hasattr(func, 'api'):
|    | 175     return check_vif_ref
|    |< XendAPI.py:valid_vif
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vif_set_name'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vif_set_type'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vif_set_device'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vif_set_network'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vif_set_vm'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vif_set_mac'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vif_set_mtu'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 354, in __init__
    method = getattr(XendAPI, method_full_name)
AttributeError: class XendAPI has no attribute 'vif_destroy'
|     359                 except AttributeError:
|     360                     pass
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 354, in __init__
    method = getattr(XendAPI, method_full_name)
AttributeError: class XendAPI has no attribute 'vif_to_xml'
|     359                 except AttributeError:
|     360                     pass
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vif
|    | 162     def check_vif_ref(self, session, vif_ref, *args, **kwargs):
|    | 172     if hasattr(func, 'api'):
|    | 175     return check_vif_ref
|    |< XendAPI.py:valid_vif
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 367, in __init__
    method = getattr(XendAPI, func_full_name)
AttributeError: class XendAPI has no attribute 'vif_get_all'
|     371                 except AttributeError:
|     372                     pass
|     364             for func_name in funcs + self.Base_funcs:
|     318         for cls, validators in classes.items():
|     319             ro_attrs = getattr(self, '%s_attr_ro' % cls, [])
|     320             rw_attrs = getattr(self, '%s_attr_rw' % cls, [])
|     321             methods  = getattr(self, '%s_methods' % cls, [])
|     322             funcs    = getattr(self, '%s_funcs' % cls, [])
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vbd_get_image'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 
'vbd_get_io_bandwidth_incoming_kbs'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 
'vbd_get_io_bandwidth_outgoing_kbs'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vbd
|    | 140     def check_vbd_ref(self, session, vbd_ref, *args, **kwargs):
|    | 150     if hasattr(func, 'api'):
|    | 153     return check_vbd_ref
|    |< XendAPI.py:valid_vbd
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vbd
|    | 140     def check_vbd_ref(self, session, vbd_ref, *args, **kwargs):
|    | 150     if hasattr(func, 'api'):
|    | 153     return check_vbd_ref
|    |< XendAPI.py:valid_vbd
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vbd
|    | 140     def check_vbd_ref(self, session, vbd_ref, *args, **kwargs):
|    | 150     if hasattr(func, 'api'):
|    | 153     return check_vbd_ref
|    |< XendAPI.py:valid_vbd
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vbd
|    | 140     def check_vbd_ref(self, session, vbd_ref, *args, **kwargs):
|    | 150     if hasattr(func, 'api'):
|    | 153     return check_vbd_ref
|    |< XendAPI.py:valid_vbd
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vbd
|    | 140     def check_vbd_ref(self, session, vbd_ref, *args, **kwargs):
|    | 150     if hasattr(func, 'api'):
|    | 153     return check_vbd_ref
|    |< XendAPI.py:valid_vbd
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vbd
|    | 140     def check_vbd_ref(self, session, vbd_ref, *args, **kwargs):
|    | 150     if hasattr(func, 'api'):
|    | 153     return check_vbd_ref
|    |< XendAPI.py:valid_vbd
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vbd_set_vm'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vbd_set_vdi'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vbd_set_device'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vbd_set_mode'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vbd_set_driver'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 354, in __init__
    method = getattr(XendAPI, method_full_name)
AttributeError: class XendAPI has no attribute 'vbd_destroy'
|     359                 except AttributeError:
|     360                     pass
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 354, in __init__
    method = getattr(XendAPI, method_full_name)
AttributeError: class XendAPI has no attribute 'vbd_to_xml'
|     359                 except AttributeError:
|     360                     pass
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vbd
|    | 140     def check_vbd_ref(self, session, vbd_ref, *args, **kwargs):
|    | 150     if hasattr(func, 'api'):
|    | 153     return check_vbd_ref
|    |< XendAPI.py:valid_vbd
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 367, in __init__
    method = getattr(XendAPI, func_full_name)
AttributeError: class XendAPI has no attribute 'vbd_get_all'
|     371                 except AttributeError:
|     372                     pass
|     364             for func_name in funcs + self.Base_funcs:
|     318         for cls, validators in classes.items():
|     319             ro_attrs = getattr(self, '%s_attr_ro' % cls, [])
|     320             rw_attrs = getattr(self, '%s_attr_rw' % cls, [])
|     321             methods  = getattr(self, '%s_methods' % cls, [])
|     322             funcs    = getattr(self, '%s_funcs' % cls, [])
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_sr
|    | 229     def check_sr_ref(self, session, sr_ref, *args, **kwargs):
|    | 239     if hasattr(func, 'api'):
|    | 242     return check_sr_ref
|    |< XendAPI.py:valid_sr
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     318         for cls, validators in classes.items():
|     319             ro_attrs = getattr(self, '%s_attr_ro' % cls, [])
|     320             rw_attrs = getattr(self, '%s_attr_rw' % cls, [])
|     321             methods  = getattr(self, '%s_methods' % cls, [])
|     322             funcs    = getattr(self, '%s_funcs' % cls, [])
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_vcpus_number'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_vcpus_utilisation'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_vcpus_features_required'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_vcpus_can_use'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_vifs'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_vbds'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_vtpms'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_pci_bus'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_vcpus_policy'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_vcpus_params'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_vcpus_features_force_on'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_vcpus_features_force_off'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_platform_std_vga'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vm_get_otherconfig'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vm_set_platform_std_vga'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vm_set_platform_keymap'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 341, in __init__
    setter = getattr(XendAPI, setter_name)
AttributeError: class XendAPI has no attribute 'vm_set_otherconfig'
|     346                 except AttributeError:
|     347                     pass
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vm
|    | 118     def check_vm_ref(self, session, vm_ref, *args, **kwargs):
|    | 128     if hasattr(func, 'api'):
|    | 131     return check_vm_ref
|    |< XendAPI.py:valid_vm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     318         for cls, validators in classes.items():
|     319             ro_attrs = getattr(self, '%s_attr_ro' % cls, [])
|     320             rw_attrs = getattr(self, '%s_attr_rw' % cls, [])
|     321             methods  = getattr(self, '%s_methods' % cls, [])
|     322             funcs    = getattr(self, '%s_funcs' % cls, [])
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_host
|    |  75     def check_host_ref(self, session, host_ref, *args, **kwargs):
|    |  84     if hasattr(func, 'api'):
|    |  87     return check_host_ref
|    |< XendAPI.py:valid_host
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'host_get_resident_vms'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'host_get_host_cpus'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_host
|    |  75     def check_host_ref(self, session, host_ref, *args, **kwargs):
|    |  84     if hasattr(func, 'api'):
|    |  87     return check_host_ref
|    |< XendAPI.py:valid_host
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_host
|    |  75     def check_host_ref(self, session, host_ref, *args, **kwargs):
|    |  84     if hasattr(func, 'api'):
|    |  87     return check_host_ref
|    |< XendAPI.py:valid_host
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_host
|    |  75     def check_host_ref(self, session, host_ref, *args, **kwargs):
|    |  84     if hasattr(func, 'api'):
|    |  87     return check_host_ref
|    |< XendAPI.py:valid_host
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_host
|    |  75     def check_host_ref(self, session, host_ref, *args, **kwargs):
|    |  84     if hasattr(func, 'api'):
|    |  87     return check_host_ref
|    |< XendAPI.py:valid_host
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_host
|    |  75     def check_host_ref(self, session, host_ref, *args, **kwargs):
|    |  84     if hasattr(func, 'api'):
|    |  87     return check_host_ref
|    |< XendAPI.py:valid_host
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_host
|    |  75     def check_host_ref(self, session, host_ref, *args, **kwargs):
|    |  84     if hasattr(func, 'api'):
|    |  87     return check_host_ref
|    |< XendAPI.py:valid_host
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_host
|    |  75     def check_host_ref(self, session, host_ref, *args, **kwargs):
|    |  84     if hasattr(func, 'api'):
|    |  87     return check_host_ref
|    |< XendAPI.py:valid_host
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_host
|    |  75     def check_host_ref(self, session, host_ref, *args, **kwargs):
|    |  84     if hasattr(func, 'api'):
|    |  87     return check_host_ref
|    |< XendAPI.py:valid_host
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_host
|    |  75     def check_host_ref(self, session, host_ref, *args, **kwargs):
|    |  84     if hasattr(func, 'api'):
|    |  87     return check_host_ref
|    |< XendAPI.py:valid_host
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_host
|    |  75     def check_host_ref(self, session, host_ref, *args, **kwargs):
|    |  84     if hasattr(func, 'api'):
|    |  87     return check_host_ref
|    |< XendAPI.py:valid_host
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 354, in __init__
    method = getattr(XendAPI, method_full_name)
AttributeError: class XendAPI has no attribute 'host_to_xml'
|     359                 except AttributeError:
|     360                     pass
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_host
|    |  75     def check_host_ref(self, session, host_ref, *args, **kwargs):
|    |  84     if hasattr(func, 'api'):
|    |  87     return check_host_ref
|    |< XendAPI.py:valid_host
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 367, in __init__
    method = getattr(XendAPI, func_full_name)
AttributeError: class XendAPI has no attribute 'host_get_by_name_label'
|     371                 except AttributeError:
|     372                     pass
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     318         for cls, validators in classes.items():
|     319             ro_attrs = getattr(self, '%s_attr_ro' % cls, [])
|     320             rw_attrs = getattr(self, '%s_attr_rw' % cls, [])
|     321             methods  = getattr(self, '%s_methods' % cls, [])
|     322             funcs    = getattr(self, '%s_funcs' % cls, [])
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 367, in __init__
    method = getattr(XendAPI, func_full_name)
AttributeError: class XendAPI has no attribute 'session_create'
|     371                 except AttributeError:
|     372                     pass
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 367, in __init__
    method = getattr(XendAPI, func_full_name)
AttributeError: class XendAPI has no attribute 'session_get_all'
|     371                 except AttributeError:
|     372                     pass
|     364             for func_name in funcs + self.Base_funcs:
|     318         for cls, validators in classes.items():
|     319             ro_attrs = getattr(self, '%s_attr_ro' % cls, [])
|     320             rw_attrs = getattr(self, '%s_attr_rw' % cls, [])
|     321             methods  = getattr(self, '%s_methods' % cls, [])
|     322             funcs    = getattr(self, '%s_funcs' % cls, [])
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vdi_get_vbds'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     339                 setter_name = '%s_set_%s' % (cls.lower(), 
attr_name.lower())
|     340                 try:
|     341                     setter = getattr(XendAPI, setter_name)
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     342                     for validator in validators:
|     343                         setter = validator(setter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     342                     for validator in validators:
|     344                     setter.api = '%s.set_%s' % (cls, attr_name)
|     345                     setattr(XendAPI, setter_name, setter)
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vdi
|    | 185     def check_vdi_ref(self, session, vdi_ref, *args, **kwargs):
|    | 195     if hasattr(func, 'api'):
|    | 198     return check_vdi_ref
|    |< XendAPI.py:valid_vdi
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     318         for cls, validators in classes.items():
|     319             ro_attrs = getattr(self, '%s_attr_ro' % cls, [])
|     320             rw_attrs = getattr(self, '%s_attr_rw' % cls, [])
|     321             methods  = getattr(self, '%s_methods' % cls, [])
|     322             funcs    = getattr(self, '%s_funcs' % cls, [])
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_host_cpu
|    |  96     def check_host_cpu_ref(self, session, host_cpu_ref, *args, 
**kwargs):
|    | 106     if hasattr(func, 'api'):
|    | 109     return check_host_cpu_ref
|    |< XendAPI.py:valid_host_cpu
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_host_cpu
|    |  96     def check_host_cpu_ref(self, session, host_cpu_ref, *args, 
**kwargs):
|    | 106     if hasattr(func, 'api'):
|    | 109     return check_host_cpu_ref
|    |< XendAPI.py:valid_host_cpu
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_host_cpu
|    |  96     def check_host_cpu_ref(self, session, host_cpu_ref, *args, 
**kwargs):
|    | 106     if hasattr(func, 'api'):
|    | 109     return check_host_cpu_ref
|    |< XendAPI.py:valid_host_cpu
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_host_cpu
|    |  96     def check_host_cpu_ref(self, session, host_cpu_ref, *args, 
**kwargs):
|    | 106     if hasattr(func, 'api'):
|    | 109     return check_host_cpu_ref
|    |< XendAPI.py:valid_host_cpu
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_host_cpu
|    |  96     def check_host_cpu_ref(self, session, host_cpu_ref, *args, 
**kwargs):
|    | 106     if hasattr(func, 'api'):
|    | 109     return check_host_cpu_ref
|    |< XendAPI.py:valid_host_cpu
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_host_cpu
|    |  96     def check_host_cpu_ref(self, session, host_cpu_ref, *args, 
**kwargs):
|    | 106     if hasattr(func, 'api'):
|    | 109     return check_host_cpu_ref
|    |< XendAPI.py:valid_host_cpu
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_host_cpu
|    |  96     def check_host_cpu_ref(self, session, host_cpu_ref, *args, 
**kwargs):
|    | 106     if hasattr(func, 'api'):
|    | 109     return check_host_cpu_ref
|    |< XendAPI.py:valid_host_cpu
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_host_cpu
|    |  96     def check_host_cpu_ref(self, session, host_cpu_ref, *args, 
**kwargs):
|    | 106     if hasattr(func, 'api'):
|    | 109     return check_host_cpu_ref
|    |< XendAPI.py:valid_host_cpu
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     318         for cls, validators in classes.items():
|     319             ro_attrs = getattr(self, '%s_attr_ro' % cls, [])
|     320             rw_attrs = getattr(self, '%s_attr_rw' % cls, [])
|     321             methods  = getattr(self, '%s_methods' % cls, [])
|     322             funcs    = getattr(self, '%s_funcs' % cls, [])
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 328, in __init__
    getter = getattr(XendAPI, getter_name)
AttributeError: class XendAPI has no attribute 'vtpm_get_vm'
|     333                 except AttributeError:
|     334                     pass
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vtpm
|    | 207     def check_vtpm_ref(self, session, vtpm_ref, *args, **kwargs):
|    | 217     if hasattr(func, 'api'):
|    | 220     return check_vtpm_ref
|    |< XendAPI.py:valid_vtpm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vtpm
|    | 207     def check_vtpm_ref(self, session, vtpm_ref, *args, **kwargs):
|    | 217     if hasattr(func, 'api'):
|    | 220     return check_vtpm_ref
|    |< XendAPI.py:valid_vtpm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vtpm
|    | 207     def check_vtpm_ref(self, session, vtpm_ref, *args, **kwargs):
|    | 217     if hasattr(func, 'api'):
|    | 220     return check_vtpm_ref
|    |< XendAPI.py:valid_vtpm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     326                 getter_name = '%s_get_%s' % (cls.lower(), 
attr_name.lower())
|     327                 try:
|     328                     getter = getattr(XendAPI, getter_name)
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAPI.py:valid_vtpm
|    | 207     def check_vtpm_ref(self, session, vtpm_ref, *args, **kwargs):
|    | 217     if hasattr(func, 'api'):
|    | 220     return check_vtpm_ref
|    |< XendAPI.py:valid_vtpm
|     329                     for validator in validators:
|     330                         getter = validator(getter)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     329                     for validator in validators:
|     331                     getter.api = '%s.get_%s' % (cls, attr_name)
|     332                     setattr(XendAPI, getter_name, getter)
|     325             for attr_name in ro_attrs + rw_attrs + self.Base_attr_ro:
|     338             for attr_name in rw_attrs + self.Base_attr_rw:
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 354, in __init__
    method = getattr(XendAPI, method_full_name)
AttributeError: class XendAPI has no attribute 'vtpm_destroy'
|     359                 except AttributeError:
|     360                     pass
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 354, in __init__
    method = getattr(XendAPI, method_full_name)
AttributeError: class XendAPI has no attribute 'vtpm_to_xml'
|     359                 except AttributeError:
|     360                     pass
|     351             for method_name in methods + self.Base_methods:
|     352                 method_full_name = '%s_%s' % 
(cls.lower(),method_name.lower())
|     353                 try:
|     354                     method = getattr(XendAPI, method_full_name)
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAPI.py:valid_vtpm
|    | 207     def check_vtpm_ref(self, session, vtpm_ref, *args, **kwargs):
|    | 217     if hasattr(func, 'api'):
|    | 220     return check_vtpm_ref
|    |< XendAPI.py:valid_vtpm
|     355                     for validator in validators:
|     356                         method = validator(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     355                     for validator in validators:
|     357                     method.api = '%s.%s' % (cls, method_name)
|     358                     setattr(XendAPI, method_full_name, method)
|     351             for method_name in methods + self.Base_methods:
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|     368                     method = session_required(method)
|    |> XendAuthSessions.py:session_required
|    | 129     def check_session(self, session, *args, **kwargs):
|    | 135     return check_session
|    |< XendAuthSessions.py:session_required
|     369                     method.api = '%s.%s' % (cls, func_name)
|     370                     setattr(XendAPI, func_full_name, method)
|     364             for func_name in funcs + self.Base_funcs:
|     365                 func_full_name = '%s_%s' % (cls.lower(), 
func_name.lower())
|     366                 try:
|     367                     method = getattr(XendAPI, func_full_name)
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendAPI.py", line 367, in __init__
    method = getattr(XendAPI, func_full_name)
AttributeError: class XendAPI has no attribute 'vtpm_get_all'
|     371                 except AttributeError:
|     372                     pass
|     364             for func_name in funcs + self.Base_funcs:
|     318         for cls, validators in classes.items():
|    < XendAPI.py:__init__
|   < server/XMLRPCServer.py:__init__
|   > server/SrvServer.py:add
|     67         self.servers.append(server)
|   < server/SrvServer.py:add
|   148     return servers
|  < server/SrvServer.py:create
|  310             servers.start(status)
|  > server/SrvServer.py:start
|    81         if status:
|    82             fcntl.fcntl(status, fcntl.F_SETFD, fcntl.FD_CLOEXEC)
|    84         Vifctl.network('start')
|   > Vifctl.py:network
|     31     if op not in ['start', 'stop']:
|     33     script = XendRoot.instance().get_network_script()
|    > XendRoot.py:instance
|     301     try:
|     302         inst
|     305     return inst
|    < XendRoot.py:instance
|    > XendRoot.py:get_network_script
|     261         s = self.get_config_value('network-script')
|    |> XendRoot.py:get_config_value
|    | 175         return sxp.child_value(self.config, name, val=val)
|    |< XendRoot.py:get_config_value
|     263         if s:
|     264             result = s.split(" ")
|     265             result[0] = os.path.join(self.network_script_dir, 
result[0])
|     266             return result
|    < XendRoot.py:get_network_script
|     34     if script:
|     35         script.insert(1, op)
|     36         os.spawnv(os.P_WAIT, script[0], script)
|   < Vifctl.py:network
|    85         threads = []
|    86         for server in self.servers:
|    87             thread = Thread(target=server.run)
|    88             thread.start()
|    89             threads.append(thread)
|    86         for server in self.servers:
|    95         threads_left = True
|    96         while threads_left:
|    97             threads_left = False
|    99             for server in self.servers:
|   100                 if not server.ready:
|   101                     threads_left = True
|   102                     break
|   104             if threads_left:
|   105                 time.sleep(.5)
|   > server/XMLRPCServer.py:run
|     99         if self.use_tcp:
|    103             self.server = UnixXMLRPCServer(self.path, logRequests = 
False)
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    111             meth = getattr(self.xenapi, meth_name)
|    112             if meth_name[0] != '_' and callable(meth) and 
hasattr(meth, 'api'):
|    113                 self.server.register_function(meth, getattr(meth, 
'api'))
|    110         for meth_name in dir(self.xenapi):
|    119         for name in methods:
|    120             fn = eval("lambda domid, *args: dispatch(domid, '%s', 
args)"%name)
|    121             self.server.register_function(fn, "xend.domain.%s" % name)
|    119         for name in methods:
|    120             fn = eval("lambda domid, *args: dispatch(domid, '%s', 
args)"%name)
|    121             self.server.register_function(fn, "xend.domain.%s" % name)
|    119         for name in methods:
|    120             fn = eval("lambda domid, *args: dispatch(domid, '%s', 
args)"%name)
|    121             self.server.register_function(fn, "xend.domain.%s" % name)
|    119         for name in methods:
|    120             fn = eval("lambda domid, *args: dispatch(domid, '%s', 
args)"%name)
|    121             self.server.register_function(fn, "xend.domain.%s" % name)
|    119         for name in methods:
|    120             fn = eval("lambda domid, *args: dispatch(domid, '%s', 
args)"%name)
|    121             self.server.register_function(fn, "xend.domain.%s" % name)
|    119         for name in methods:
|    120             fn = eval("lambda domid, *args: dispatch(domid, '%s', 
args)"%name)
|    121             self.server.register_function(fn, "xend.domain.%s" % name)
|    119         for name in methods:
|    120             fn = eval("lambda domid, *args: dispatch(domid, '%s', 
args)"%name)
|    121             self.server.register_function(fn, "xend.domain.%s" % name)
|    119         for name in methods:
|    120             fn = eval("lambda domid, *args: dispatch(domid, '%s', 
args)"%name)
|    121             self.server.register_function(fn, "xend.domain.%s" % name)
|    119         for name in methods:
|    120             fn = eval("lambda domid, *args: dispatch(domid, '%s', 
args)"%name)
|    121             self.server.register_function(fn, "xend.domain.%s" % name)
|    119         for name in methods:
|    120             fn = eval("lambda domid, *args: dispatch(domid, '%s', 
args)"%name)
|    121             self.server.register_function(fn, "xend.domain.%s" % name)
|    119         for name in methods:
|    120             fn = eval("lambda domid, *args: dispatch(domid, '%s', 
args)"%name)
|    121             self.server.register_function(fn, "xend.domain.%s" % name)
|    119         for name in methods:
|    120             fn = eval("lambda domid, *args: dispatch(domid, '%s', 
args)"%name)
|    121             self.server.register_function(fn, "xend.domain.%s" % name)
|    119         for name in methods:
|    123         inst = XendDomain.instance()
|    > XendDomain.py:instance
|    1333     try:
|    1334         inst
|    1338     return inst
|    < XendDomain.py:instance
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    128                 if name not in exclude:
|    129                     self.server.register_function(fn, "xend.domain.%s" 
% name[7:])
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    126             fn = getattr(inst, name)
|    127             if name.startswith("domain_") and callable(fn):
|    125         for name in dir(inst):
|    132         for type, lst, n in [(XendNode, ['info'], 'node'),
|    134             inst = type.instance()
|    > XendNode.py:instance
|     217     try:
|     218         inst
|     221     return inst
|    < XendNode.py:instance
|    135             for name in lst:
|    136                 self.server.register_function(getattr(inst, name),
|    137                                               "xend.%s.%s" % (n, name))
|    135             for name in lst:
|    132         for type, lst, n in [(XendNode, ['info'], 'node'),
|    134             inst = type.instance()
|    > XendDmesg.py:instance
|      35     try:
|      36         inst
|    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendDmesg.py", line 36, in instance
    inst
NameError: global name 'inst' is not defined
|      37     except:
|      38         inst = XendDmesg()
|    |> XendDmesg.py:__init__
|    |  25         self.xc = xen.lowlevel.xc.xc()
|    |< XendDmesg.py:__init__
|      39     return inst
|    < XendDmesg.py:instance
|    135             for name in lst:
|    136                 self.server.register_function(getattr(inst, name),
|    137                                               "xend.%s.%s" % (n, name))
|    135             for name in lst:
|    136                 self.server.register_function(getattr(inst, name),
|    137                                               "xend.%s.%s" % (n, name))
|    135             for name in lst:
|    132         for type, lst, n in [(XendNode, ['info'], 'node'),
|    140         self.server.register_function(domain, 'xend.domain')
|    141         self.server.register_function(domains, 'xend.domains')
|    142         self.server.register_function(get_log, 'xend.node.log')
|    143         self.server.register_function(domain_create, 
'xend.domain.create')
|    144         self.server.register_function(domain_restore, 
'xend.domain.restore')
|    146         self.server.register_introspection_functions()
|    147         self.ready = True
|    151         try:
|    152             self.server.socket.settimeout(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|     96         while threads_left:
|     97             threads_left = False
|     99             for server in self.servers:
|    100                 if not server.ready:
|     99             for server in self.servers:
|    104             if threads_left:
|     96         while threads_left:
|    107         if status:
|    108             status.write('0')
|    109             status.close()
|    113         signal.signal(signal.SIGTERM, self.cleanup)
|    120         runningThreads = len([t for t in threads if t.isAlive()])
|    120         runningThreads = len([t for t in threads if t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    > server/XMLRPCServer.py:domain_create
|      64     info = XendDomain.instance().domain_create(config)
|    |> XendDomain.py:instance
|    |1333     try:
|    |1334         inst
|    |1338     return inst
|    |< XendDomain.py:instance
|    |> XendDomain.py:domain_create
|    | 798         self.domains_lock.acquire()
|    | 799         try:
|    | 800             self._refresh()
|    | > XendDomain.py:_refresh
|    |  379         running = self._running_domains()
|    |  > XendDomain.py:_running_domains
|    |   343         try:
|    |   344             return xc.domain_getinfo()
|    |  < XendDomain.py:_running_domains
|    |  380         for dom in running:
|    |  381             domid = dom['domid']
|    |  382             if domid in self.domains and dom['dying'] != 1:
|    |  383                 self.domains[domid].update(dom)
|    |  > XendDomainInfo.py:update
|    |  1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |  1631                   str(self.domid))
|    |   > XendLogging.py:trace
|    |     36         self.log(logging.TRACE, *args, **kwargs)
|    |   < XendLogging.py:trace
|    |  1633         if not info:
|    |  1639         if security.on() and info.has_key('ssidref'):
|    |  1647         if 'ssidref' in info:
|    |  1648             info.pop('ssidref')
|    |  1653         self.info.update(info)
|    |  1654         self.info.validate()
|    |   > XendConfig.py:validate
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     202     ('bootloader',   lambda info: None),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     203     ('bootloader_args', lambda info: None),            
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     206     ('image',        lambda info: None),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    765         if 'image' in self and isinstance(self['image'], str):
|    |    767         if 'security' in self and isinstance(self['security'], 
str):
|    |    769         if self['memory'] == 0 and 'mem_kb' in self:
|    |    771         if self['memory'] <= 0:
|    |    775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |    778         if 'mem_kb' in self:
|    |    779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |    782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |    787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |    793         if 'vif_refs' not in self:
|    |    795         if 'vbd_refs' not in self:
|    |    797         if 'vtpm_refs' not in self:
|    |   < XendConfig.py:validate
|    |  1656         if refresh:
|    |  1657             self.refreshShutdown(info)
|    |   > XendDomainInfo.py:refreshShutdown
|    |    856         restart_reason = None
|    |    858         self.refresh_shutdown_lock.acquire()
|    |    859         try:
|    |    860             if xeninfo is None:
|    |    874             if xeninfo['dying']:
|    |    886             elif xeninfo['crashed']:
|    |    901             elif xeninfo['shutdown']:
|    |    928             elif self.dompath is None:
|    |    936                 if xeninfo['paused']:
|    |    939                     self._stateSet(DOM_STATE_RUNNING)
|    |    > XendDomainInfo.py:_stateSet
|    |    1595         self.state_updated.acquire()
|    |    1596         try:
|    |    1597             if self.state != state:
|    |    1601             self.state_updated.release()
|    |    < XendDomainInfo.py:_stateSet
|    |    941                 if self.shutdownStartTime:
|    |    950             self.refresh_shutdown_lock.release()
|    |    952         if restart_reason:
|    |   < XendDomainInfo.py:refreshShutdown
|    |  1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |  1660                   str(self.domid), self.info)
|    |   > XendLogging.py:trace
|    |     36         self.log(logging.TRACE, *args, **kwargs)
|    |   < XendLogging.py:trace
|    |  < XendDomainInfo.py:update
|    |  380         for dom in running:
|    |  389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    |  389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    |  390         for domid, dom in self.domains.items():
|    |  391             if domid not in running_domids and domid != DOM0_ID:
|    |  390         for domid, dom in self.domains.items():
|    | < XendDomain.py:_refresh
|    | 802             dominfo = XendDomainInfo.create(config)
|    | > XendDomainInfo.py:create
|    |  147     log.debug("XendDomainInfo.create(%s)", config)
|    |  148     vm = XendDomainInfo(XendConfig(sxp = config))
|    |  > XendConfig.py:__init__
|    |   265         format = 'unknown'
|    |   267         self.xenapi = {}
|    |   > XendConfig.py:__setattr__
|    |    322         try:
|    |    323             return dict.__setattr__(self, name, value)
|    |   < XendConfig.py:__setattr__
|    |   269         if filename and not fd:
|    |   272         if fd:
|    |   275         if fd:
|    |   288         if sxp:
|    |   289             cfg = self._populate_from_sxp(sxp)
|    |   > XendConfig.py:_populate_from_sxp
|    |    414         cfg = {}
|    |    419         restart = sxp.child_value(parsed, 'restart')
|    |    420         if restart:
|    |    436         all_params = VM_CONFIG_ENTRIES + 
ROUNDTRIPPING_CONFIG_ENTRIES + \
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    442                 try:
|    |    443                     cfg[key] = typeconv(val)
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    442                 try:
|    |    443                     cfg[key] = typeconv(val)
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    442                 try:
|    |    443                     cfg[key] = typeconv(val)
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    442                 try:
|    |    443                     cfg[key] = typeconv(val)
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    442                 try:
|    |    443                     cfg[key] = typeconv(val)
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    442                 try:
|    |    443                     cfg[key] = typeconv(val)
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    442                 try:
|    |    443                     cfg[key] = typeconv(val)
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    442                 try:
|    |    443                     cfg[key] = typeconv(val)
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    442                 try:
|    |    443                     cfg[key] = typeconv(val)
|    |    439         for key, typeconv in all_params:
|    |    440             val = sxp.child_value(parsed, key)
|    |    441             if val:
|    |    439         for key, typeconv in all_params:
|    |    450         cfg['backend'] = []
|    |    451         for c in sxp.children(parsed, 'backend'):
|    |    475         cfg['device'] = {}
|    |    476         for dev in sxp.children(parsed, 'device'):
|    |    477             config = sxp.child0(dev)
|    |    478             dev_type = sxp.name(config)
|    |    479             dev_info = {}
|    |    481             if dev_type == 'pci':
|    |    484             for opt, val in config[1:]:
|    |    485                 dev_info[opt] = val
|    |    484             for opt, val in config[1:]:
|    |    485                 dev_info[opt] = val
|    |    484             for opt, val in config[1:]:
|    |    485                 dev_info[opt] = val
|    |    484             for opt, val in config[1:]:
|    |    486             log.debug("XendConfig: reading device: %s" % dev_info)
|    |    488             dev_uuid = dev_info.get('uuid', uuid.createString())
|    |    > uuid.py:createString
|    |      69     return toString(create())
|    |    |> uuid.py:create
|    |    |  66     return uuidFactory()
|    |    | > uuid.py:getUuidRandom
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    | < uuid.py:getUuidRandom
|    |    |< uuid.py:create
|    |    |> uuid.py:toString
|    |    |  58     return "-".join(["%02x" * 4, "%02x" * 2, "%02x" * 2, "%02x" 
* 2,
|    |    |< uuid.py:toString
|    |    < uuid.py:createString
|    |    489             dev_info['uuid'] = dev_uuid
|    |    490             cfg['device'][dev_uuid] = (dev_type, dev_info)
|    |    476         for dev in sxp.children(parsed, 'device'):
|    |    493         for dev in sxp.children(parsed, 'device'):
|    |    494             config = sxp.child0(dev)
|    |    495             dev_type = sxp.name(config)
|    |    497             if dev_type != 'pci':
|    |    498                 continue
|    |    493         for dev in sxp.children(parsed, 'device'):
|    |    521         if 'image' in cfg:
|    |    522             image_vcpus = sxp.child_value(cfg['image'], 'vcpus')
|    |    523             if image_vcpus is not None:
|    |    536         if 'cpu' in cfg:
|    |    548         try:
|    |    549             if 'cpus' in cfg:
|    |    569         if 'image' in cfg:
|    |    570             cfg['kernel_kernel'] = sxp.child_value(cfg['image'], 
'kernel','')
|    |    571             cfg['kernel_initrd'] = sxp.child_value(cfg['image'], 
'ramdisk','')
|    |    572             kernel_args = sxp.child_value(cfg['image'], 'args', 
'')
|    |    575             arg_ip = sxp.child_value(cfg['image'], 'ip')
|    |    576             if arg_ip: kernel_args += ' ip=%s' % arg_ip
|    |    577             arg_root = sxp.child_value(cfg['image'], 'root')
|    |    578             if arg_root: kernel_args += ' root=%s' % arg_root
|    |    580             cfg['kernel_args'] = kernel_args
|    |    583         old_state = sxp.child_value(parsed, 'state')
|    |    584         if old_state:
|    |    590         cfg['vif_refs'] = []
|    |    591         cfg['vbd_refs'] = []
|    |    592         cfg['vtpm_refs'] = []
|    |    593         for dev_uuid, (dev_type, dev_info) in 
cfg['device'].items():
|    |    594             if dev_type == 'vif':
|    |    596             elif dev_type in ('vbd','tap'):
|    |    597                 cfg['vbd_refs'].append(dev_uuid)
|    |    593         for dev_uuid, (dev_type, dev_info) in 
cfg['device'].items():
|    |    601         return cfg
|    |   < XendConfig.py:_populate_from_sxp
|    |   290         if xml:
|    |   292         if pycfg:
|    |   294         if xenapi_vm:
|    |   297         if cfg:
|    |   298             self.update(cfg)
|    |   300         if xenapi_vm:
|    |   303         log.debug('XendConfig: %s' % str(self))
|    |   304         self.validate()
|    |   > XendConfig.py:validate
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     190     ('uuid',         lambda info: uuid.createString()),
|    |    |> uuid.py:createString
|    |    |  69     return toString(create())
|    |    | > uuid.py:create
|    |    |   66     return uuidFactory()
|    |    |  > uuid.py:getUuidRandom
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |    50     return [ random.randint(0, 255) for _ in range(0, 16) ]
|    |    |  < uuid.py:getUuidRandom
|    |    | < uuid.py:create
|    |    | > uuid.py:toString
|    |    |   58     return "-".join(["%02x" * 4, "%02x" * 2, "%02x" * 2, 
"%02x" * 2,
|    |    | < uuid.py:toString
|    |    |< uuid.py:createString
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     193     ('on_poweroff',  lambda info: 'destroy'),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     194     ('on_reboot',    lambda info: 'restart'),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     195     ('on_crash',     lambda info: 'restart'),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     196     ('features',     lambda info: ''),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     200     ('shadow_memory',lambda info: 0),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     201     ('maxmem',       lambda info: 0),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     202     ('bootloader',   lambda info: None),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     203     ('bootloader_args', lambda info: None),            
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     207     ('security',     lambda info: []),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     211     ('cpus',         lambda info: []),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     212     ('cpu_cap',      lambda info: 0),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     213     ('cpu_weight',   lambda info: 256),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     215     ('online_vcpus', lambda info: info['vcpus']),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     216     ('max_vcpu_id',  lambda info: info['vcpus']-1),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    762                 self[key] = default_func(self)
|    |    > XendConfig.py:<lambda>
|    |     217     ('vcpu_avail',   lambda info: (1<<info['vcpus'])-1),
|    |    < XendConfig.py:<lambda>
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    761             if key not in self or self[key] == None:
|    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    765         if 'image' in self and isinstance(self['image'], str):
|    |    767         if 'security' in self and isinstance(self['security'], 
str):
|    |    769         if self['memory'] == 0 and 'mem_kb' in self:
|    |    771         if self['memory'] <= 0:
|    |    775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |    778         if 'mem_kb' in self:
|    |    782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |    783             if d_type not in XendDevices.valid_devices():
|    |    > XendDevices.py:valid_devices
|    |      48         return cls.controllers.keys()
|    |    < XendDevices.py:valid_devices
|    |    782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |    787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |    793         if 'vif_refs' not in self:
|    |    795         if 'vbd_refs' not in self:
|    |    797         if 'vtpm_refs' not in self:
|    |   < XendConfig.py:validate
|    |  < XendConfig.py:__init__
|    |  > XendDomainInfo.py:__init__
|    |   376         self.info = info
|    |   377         if domid == None:
|    |   378             self.domid =  self.info.get('domid')
|    |   394         self.vmpath  = XS_VMROOT + self.info['uuid']
|    |   395         self.dompath = dompath
|    |   397         self.image = None
|    |   398         self.store_port = None
|    |   399         self.store_mfn = None
|    |   400         self.console_port = None
|    |   401         self.console_mfn = None
|    |   403         self.vmWatch = None
|    |   404         self.shutdownWatch = None
|    |   405         self.shutdownStartTime = None
|    |   407         self.state = DOM_STATE_HALTED
|    |   408         self.state_updated = threading.Condition()
|    |   409         self.refresh_shutdown_lock = threading.Condition()
|    |   411         self._deviceControllers = {}
|    |   413         for state in DOM_STATES_OLD:
|    |   414             self.info[state] = 0
|    |   413         for state in DOM_STATES_OLD:
|    |   414             self.info[state] = 0
|    |   413         for state in DOM_STATES_OLD:
|    |   414             self.info[state] = 0
|    |   413         for state in DOM_STATES_OLD:
|    |   414             self.info[state] = 0
|    |   413         for state in DOM_STATES_OLD:
|    |   414             self.info[state] = 0
|    |   413         for state in DOM_STATES_OLD:
|    |   414             self.info[state] = 0
|    |   413         for state in DOM_STATES_OLD:
|    |   416         if augment:
|    |   419         self._checkName(self.info['name'])
|    |   > XendDomainInfo.py:_checkName
|    |   1614         from xen.xend import XendDomain
|    |   1616         if name is None or name == '':
|    |   1619         if not re.search(r'^[A-Za-z0-9_\-\.\:\/\+]+$', name):
|    |   1622         dom =  XendDomain.instance().domain_lookup_nr(name)
|    |    > XendDomain.py:instance
|    |    1333     try:
|    |    1334         inst
|    |    1338     return inst
|    |    < XendDomain.py:instance
|    |    > XendDomain.py:domain_lookup_nr
|    |     485         self.domains_lock.acquire()
|    |     486         try:
|    |     488             match = [dom for dom in self.domains.values() \
|    |    |> XendDomainInfo.py:getName
|    |    | 797         return self.info['name']
|    |    |< XendDomainInfo.py:getName
|    |     488             match = [dom for dom in self.domains.values() \
|    |     490             if match:
|    |     493             match = [dom for dom in 
self.managed_domains.values() \
|    |     495             if match:
|    |     499             try:
|    |     500                 if int(domid) in self.domains:
|    |    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendDomain.py", line 500, in domain_lookup_nr
    if int(domid) in self.domains:
ValueError: invalid literal for int(): fc5-1
|    |     502             except ValueError:
|    |     503                 pass
|    |     506             match = [dom for dom in self.domains.values() \
|    |    |> XendDomainInfo.py:get_uuid
|    |    |1678         dom_uuid = self.info.get('uuid')
|    |    |1679         if not dom_uuid: # if it doesn't exist, make one up
|    |    |1682         return dom_uuid
|    |    |< XendDomainInfo.py:get_uuid
|    |     506             match = [dom for dom in self.domains.values() \
|    |     508             if match:
|    |     512             if domid in self.managed_domains:
|    |     515             return None
|    |     517             self.domains_lock.release()
|    |    < XendDomain.py:domain_lookup_nr
|    |   1623         if dom and dom != self and not dom.info['dying']:
|    |   < XendDomainInfo.py:_checkName
|    |   420         self.setResume(resume)
|    |   > XendDomainInfo.py:setResume
|    |    842         self.info['resume'] = state
|    |   < XendDomainInfo.py:setResume
|    |  < XendDomainInfo.py:__init__
|    |  149     try:
|    |  150         vm.start()
|    |  > XendDomainInfo.py:start
|    |   432         from xen.xend import XendDomain
|    |   434         if self.state == DOM_STATE_HALTED:
|    |   435             try:
|    |   436                 self._constructDomain()
|    |   > XendDomainInfo.py:_constructDomain
|    |   1210         log.debug('XendDomainInfo.constructDomain')
|    |   1212         hvm = (self._infoIsSet('image') and
|    |    > XendDomainInfo.py:_infoIsSet
|    |    1604         return name in self.info and self.info[name] is not None
|    |    < XendDomainInfo.py:_infoIsSet
|    |   1214         if hvm:
|    |   1221         self.domid = xc.domain_create(
|    |   1223             ssidref = security.get_security_info(self.info, 
'ssidref'),
|    |   1224             handle = uuid.fromString(self.info['uuid']),
|    |    > uuid.py:fromString
|    |      62     s = s.replace('-', '')
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) ]
|    |    < uuid.py:fromString
|    |   1225             hvm = int(hvm))
|    |   1227         if self.domid < 0:
|    |   1231         self.dompath = GetDomainPath(self.domid)
|    |    > xenstore/xsutil.py:GetDomainPath
|    |      26     return xshandle().get_domain_path(domid)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |    < xenstore/xsutil.py:GetDomainPath
|    |   1233         self._recreateDom()
|    |    > XendDomainInfo.py:_recreateDom
|    |     675         complete(self.dompath, lambda t: 
self._recreateDomFunc(t))
|    |    |> xenstore/xstransact.py:complete
|    |    | 350     while True:
|    |    | 351         t = xstransact(path)
|    |    | > xenstore/xstransact.py:__init__
|    |    |   14         assert path is not None
|    |    |   16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |   19         self.path = path.rstrip("/")
|    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |   21         self.in_transaction = True
|    |    | < xenstore/xstransact.py:__init__
|    |    | 352         try:
|    |    | 353             result = f(t)
|    |    | > XendDomainInfo.py:<lambda>
|    |    |  675         complete(self.dompath, lambda t: 
self._recreateDomFunc(t))
|    |    |  > XendDomainInfo.py:_recreateDomFunc
|    |    |   678         t.remove()
|    |    |   > xenstore/xstransact.py:remove
|    |    |    110         if len(args) == 0:
|    |    |    111             xshandle().rm(self.transaction, self.path)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |   < xenstore/xstransact.py:remove
|    |    |   679         t.mkdir()
|    |    |   > xenstore/xstransact.py:mkdir
|    |    |    217         if len(args) == 0:
|    |    |    218             xshandle().mkdir(self.transaction, self.path)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |   < xenstore/xstransact.py:mkdir
|    |    |   680         t.set_permissions({ 'dom' : self.domid })
|    |    |   > xenstore/xstransact.py:set_permissions
|    |    |    253         if len(args) == 0:
|    |    |    255         elif isinstance(args[0], str):
|    |    |    258             if not self.path:
|    |    |    261             xshandle().set_permissions(self.transaction, 
self.path,
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |    262                                        list(args))
|    |    |   < xenstore/xstransact.py:set_permissions
|    |    |   681         t.write('vm', self.vmpath)
|    |    |   > xenstore/xstransact.py:write
|    |    |     78         if len(args) == 0:
|    |    |     80         if isinstance(args[0], dict):
|    |    |     90         elif isinstance(args[0], list):
|    |    |     95         elif len(args) % 2 == 0:
|    |    |     96             for i in range(len(args) / 2):
|    |    |     97                 self._write(args[i * 2], args[i * 2 + 1])
|    |    |    > xenstore/xstransact.py:_write
|    |    |      69         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 284             return self.path + '/' + key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |      70         try:
|    |    |      71             xshandle().write(self.transaction, path, data)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    < xenstore/xstransact.py:_write
|    |    |     96             for i in range(len(args) / 2):
|    |    |   < xenstore/xstransact.py:write
|    |    |  < XendDomainInfo.py:_recreateDomFunc
|    |    | < XendDomainInfo.py:<lambda>
|    |    | 354             if t.commit():
|    |    | > xenstore/xstransact.py:commit
|    |    |   28         if not self.in_transaction:
|    |    |   30         self.in_transaction = False
|    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |   32         self.transaction = "0"
|    |    |   33         return rc
|    |    | < xenstore/xstransact.py:commit
|    |    | 355                 return result
|    |    |< xenstore/xstransact.py:complete
|    |    |> xenstore/xstransact.py:__del__
|    |    |  24         if self.in_transaction:
|    |    |< xenstore/xstransact.py:__del__
|    |    < XendDomainInfo.py:_recreateDom
|    |   1236         xc.domain_max_vcpus(self.domid, int(self.info['vcpus']))
|    |   < XendDomainInfo.py:_constructDomain
|    |   437                 self._initDomain()
|    |   > XendDomainInfo.py:_initDomain
|    |   1251         log.debug('XendDomainInfo.initDomain: %s %s',
|    |   1252                   self.domid,
|    |   1253                   self.info['cpu_weight'])
|    |   1257         if self._infoIsSet('bootloader') and not 
self._infoIsSet('image'):
|    |    > XendDomainInfo.py:_infoIsSet
|    |    1604         return name in self.info and self.info[name] is not None
|    |    < XendDomainInfo.py:_infoIsSet
|    |   1260         if not self._infoIsSet('image'):
|    |    > XendDomainInfo.py:_infoIsSet
|    |    1604         return name in self.info and self.info[name] is not None
|    |    < XendDomainInfo.py:_infoIsSet
|    |   1263         try:
|    |   1264             self.image = image.create(self,
|    |   1265                                       self.info['image'],
|    |   1266                                       
self.info.all_devices_sxpr())
|    |    > XendConfig.py:all_devices_sxpr
|    |     914         sxprs = []
|    |     915         pci_devs = []
|    |     916         for dev_type, dev_info in self['device'].values():
|    |     917             if dev_type == 'pci': # special case for pci devices
|    |     920                 sxpr =  self.device_sxpr(dev_type = dev_type,
|    |     921                                          dev_info = dev_info)
|    |    |> XendConfig.py:device_sxpr
|    |    | 898         sxpr = []
|    |    | 899         if dev_uuid != None and dev_uuid in self['device']:
|    |    | 902         if dev_type == None or dev_info == None:
|    |    | 906         sxpr.append(dev_type)
|    |    | 907         config = [(opt, val) for opt, val in dev_info.items()]
|    |    | 907         config = [(opt, val) for opt, val in dev_info.items()]
|    |    | 907         config = [(opt, val) for opt, val in dev_info.items()]
|    |    | 907         config = [(opt, val) for opt, val in dev_info.items()]
|    |    | 907         config = [(opt, val) for opt, val in dev_info.items()]
|    |    | 908         sxpr += config
|    |    | 910         return sxpr
|    |    |< XendConfig.py:device_sxpr
|    |     922                 sxprs.append((dev_type, sxpr))
|    |     916         for dev_type, dev_info in self['device'].values():
|    |     926         if pci_devs:
|    |     934         return sxprs
|    |    < XendConfig.py:all_devices_sxpr
|    |    > image.py:create
|    |      46     return findImageHandlerClass(imageConfig)(vm, imageConfig, 
deviceConfig)
|    |    |> image.py:findImageHandlerClass
|    |    | 531     type = sxp.name(image)
|    |    | 532     if type is None:
|    |    | 534     try:
|    |    | 535         return _handlers[arch.type][type]
|    |    |< image.py:findImageHandlerClass
|    |    |> image.py:__init__
|    |    |  70         self.vm = vm
|    |    |  72         self.kernel = None
|    |    |  73         self.ramdisk = None
|    |    |  74         self.cmdline = None
|    |    |  76         self.configure(imageConfig, deviceConfig)
|    |    | > image.py:configure
|    |    |   81         def get_cfg(name, default = None):
|    |    |   84         self.kernel = get_cfg("kernel")
|    |    |  > image.py:get_cfg
|    |    |    82             return sxp.child_value(imageConfig, name, default)
|    |    |  < image.py:get_cfg
|    |    |   85         self.cmdline = ""
|    |    |   86         ip = get_cfg("ip")
|    |    |  > image.py:get_cfg
|    |    |    82             return sxp.child_value(imageConfig, name, default)
|    |    |  < image.py:get_cfg
|    |    |   87         if ip:
|    |    |   89         root = get_cfg("root")
|    |    |  > image.py:get_cfg
|    |    |    82             return sxp.child_value(imageConfig, name, default)
|    |    |  < image.py:get_cfg
|    |    |   90         if root:
|    |    |   91             self.cmdline += " root=" + root
|    |    |   92         args = get_cfg("args")
|    |    |  > image.py:get_cfg
|    |    |    82             return sxp.child_value(imageConfig, name, default)
|    |    |  < image.py:get_cfg
|    |    |   93         if args:
|    |    |   95         self.ramdisk = get_cfg("ramdisk", '')
|    |    |  > image.py:get_cfg
|    |    |    82             return sxp.child_value(imageConfig, name, default)
|    |    |  < image.py:get_cfg
|    |    |   97         self.vm.storeVm(("image/ostype", self.ostype),
|    |    |   98                         ("image/kernel", self.kernel),
|    |    |   99                         ("image/cmdline", self.cmdline),
|    |    |  100                         ("image/ramdisk", self.ramdisk))
|    |    |  > XendDomainInfo.py:storeVm
|    |    |   656         return xstransact.Store(self.vmpath, *args)
|    |    |   > xenstore/xstransact.py:Store
|    |    |    337         complete(path, lambda t: t.store(*args))
|    |    |    > xenstore/xstransact.py:complete
|    |    |     350     while True:
|    |    |     351         t = xstransact(path)
|    |    |    |> xenstore/xstransact.py:__init__
|    |    |    |  14         assert path is not None
|    |    |    |  16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |    |  19         self.path = path.rstrip("/")
|    |    |    |  20         self.transaction = xshandle().transaction_start()
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |  21         self.in_transaction = True
|    |    |    |< xenstore/xstransact.py:__init__
|    |    |     352         try:
|    |    |     353             result = f(t)
|    |    |    |> xenstore/xstransact.py:<lambda>
|    |    |    | 337         complete(path, lambda t: t.store(*args))
|    |    |    | > xenstore/xstransact.py:store
|    |    |    |  195         if len(args) and type(args[0]) != tuple:
|    |    |    |  197         for tup in args:
|    |    |    |  198             if len(tup) == 2:
|    |    |    |  199                 (key, val) = tup
|    |    |    |  200                 try:
|    |    |    |  201                     fmt = { str        : "%s",
|    |    |    |  210             if val is None:
|    |    |    |  213                 self._write(key, fmt % val)
|    |    |    |  > xenstore/xstransact.py:_write
|    |    |    |    69         path = self.prependPath(key)
|    |    |    |   > xenstore/xstransact.py:prependPath
|    |    |    |    283         if self.path:
|    |    |    |    284             return self.path + '/' + key
|    |    |    |   < xenstore/xstransact.py:prependPath
|    |    |    |    70         try:
|    |    |    |    71             xshandle().write(self.transaction, path, 
data)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |  < xenstore/xstransact.py:_write
|    |    |    |  197         for tup in args:
|    |    |    |  198             if len(tup) == 2:
|    |    |    |  199                 (key, val) = tup
|    |    |    |  200                 try:
|    |    |    |  201                     fmt = { str        : "%s",
|    |    |    |  210             if val is None:
|    |    |    |  213                 self._write(key, fmt % val)
|    |    |    |  > xenstore/xstransact.py:_write
|    |    |    |    69         path = self.prependPath(key)
|    |    |    |   > xenstore/xstransact.py:prependPath
|    |    |    |    283         if self.path:
|    |    |    |    284             return self.path + '/' + key
|    |    |    |   < xenstore/xstransact.py:prependPath
|    |    |    |    70         try:
|    |    |    |    71             xshandle().write(self.transaction, path, 
data)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |  < xenstore/xstransact.py:_write
|    |    |    |  197         for tup in args:
|    |    |    |  198             if len(tup) == 2:
|    |    |    |  199                 (key, val) = tup
|    |    |    |  200                 try:
|    |    |    |  201                     fmt = { str        : "%s",
|    |    |    |  210             if val is None:
|    |    |    |  213                 self._write(key, fmt % val)
|    |    |    |  > xenstore/xstransact.py:_write
|    |    |    |    69         path = self.prependPath(key)
|    |    |    |   > xenstore/xstransact.py:prependPath
|    |    |    |    283         if self.path:
|    |    |    |    284             return self.path + '/' + key
|    |    |    |   < xenstore/xstransact.py:prependPath
|    |    |    |    70         try:
|    |    |    |    71             xshandle().write(self.transaction, path, 
data)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |  < xenstore/xstransact.py:_write
|    |    |    |  197         for tup in args:
|    |    |    |  198             if len(tup) == 2:
|    |    |    |  199                 (key, val) = tup
|    |    |    |  200                 try:
|    |    |    |  201                     fmt = { str        : "%s",
|    |    |    |  210             if val is None:
|    |    |    |  213                 self._write(key, fmt % val)
|    |    |    |  > xenstore/xstransact.py:_write
|    |    |    |    69         path = self.prependPath(key)
|    |    |    |   > xenstore/xstransact.py:prependPath
|    |    |    |    283         if self.path:
|    |    |    |    284             return self.path + '/' + key
|    |    |    |   < xenstore/xstransact.py:prependPath
|    |    |    |    70         try:
|    |    |    |    71             xshandle().write(self.transaction, path, 
data)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |  < xenstore/xstransact.py:_write
|    |    |    |  197         for tup in args:
|    |    |    | < xenstore/xstransact.py:store
|    |    |    |< xenstore/xstransact.py:<lambda>
|    |    |     354             if t.commit():
|    |    |    |> xenstore/xstransact.py:commit
|    |    |    |  28         if not self.in_transaction:
|    |    |    |  30         self.in_transaction = False
|    |    |    |  31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |  32         self.transaction = "0"
|    |    |    |  33         return rc
|    |    |    |< xenstore/xstransact.py:commit
|    |    |     355                 return result
|    |    |    < xenstore/xstransact.py:complete
|    |    |    > xenstore/xstransact.py:__del__
|    |    |      24         if self.in_transaction:
|    |    |    < xenstore/xstransact.py:__del__
|    |    |   < xenstore/xstransact.py:Store
|    |    |  < XendDomainInfo.py:storeVm
|    |    | < image.py:configure
|    |    |< image.py:__init__
|    |    < image.py:create
|    |   1268             localtime = self.info.get('localtime', 0)
|    |   1269             if localtime is not None and localtime == 1:
|    |   1272             xc.domain_setcpuweight(self.domid, 
self.info['cpu_weight'])
|    |   1277             if self.info['cpus'] is not None and 
len(self.info['cpus']) > 0:
|    |   1284             maxmem = self.image.getRequiredAvailableMemory(
|    |    > image.py:getRequiredAvailableMemory
|    |     153         return mem_kb
|    |    < image.py:getRequiredAvailableMemory
|    |   1286             memory = self.image.getRequiredAvailableMemory(
|    |    > image.py:getRequiredAvailableMemory
|    |     153         return mem_kb
|    |    < image.py:getRequiredAvailableMemory
|    |   1288             shadow = self.image.getRequiredShadowMemory(
|    |   1290                 self.info['maxmem'] * 1024)
|    |    > image.py:getRequiredShadowMemory
|    |     169         return 0
|    |    < image.py:getRequiredShadowMemory
|    |   1294             shadow = ((shadow + 1023) / 1024) * 1024
|    |   1297             xc.domain_setmaxmem(self.domid, maxmem)
|    |   1300             balloon.free(memory + shadow)
|    |    > balloon.py:free
|    |     110     xroot = XendRoot.instance()
|    |    |> XendRoot.py:instance
|    |    | 301     try:
|    |    | 302         inst
|    |    | 305     return inst
|    |    |< XendRoot.py:instance
|    |     111     xc = xen.lowlevel.xc.xc()
|    |     113     try:
|    |     114         dom0_min_mem = xroot.get_dom0_min_mem() * 1024
|    |    |> XendRoot.py:get_dom0_min_mem
|    |    | 281         return self.get_config_int('dom0-min-mem', 
self.dom0_min_mem_default)
|    |    | > XendRoot.py:get_config_int
|    |    |  186         v = self.get_config_value(name, val)
|    |    |  > XendRoot.py:get_config_value
|    |    |   175         return sxp.child_value(self.config, name, val=val)
|    |    |  < XendRoot.py:get_config_value
|    |    |  187         try:
|    |    |  188             return int(v)
|    |    | < XendRoot.py:get_config_int
|    |    |< XendRoot.py:get_dom0_min_mem
|    |     116         retries = 0
|    |     117         sleep_time = SLEEP_TIME_GROWTH
|    |     118         last_new_alloc = None
|    |     119         rlimit = RETRY_LIMIT
|    |     120         while retries < rlimit:
|    |     121             physinfo = xc.physinfo()
|    |     122             free_mem = physinfo['free_memory']
|    |     123             scrub_mem = physinfo['scrub_memory']
|    |     125             if free_mem >= need_mem:
|    |     126                 log.debug("Balloon: %d KiB free; need %d; done.",
|    |     127                           free_mem, need_mem)
|    |     128                 return
|    |     175         del xc
|    |    < balloon.py:free
|    |   1303             shadow_cur = xc.shadow_mem_control(self.domid, shadow 
/ 1024)
|    |   1304             self.info['shadow_memory'] = shadow_cur
|    |   1306             self._createChannels()
|    |    > XendDomainInfo.py:_createChannels
|    |    1438         self.store_port = self._createChannel()
|    |    |> XendDomainInfo.py:_createChannel
|    |    |1445         try:
|    |    |1446             return xc.evtchn_alloc_unbound(domid=self.domid, 
remote_dom=0)
|    |    |< XendDomainInfo.py:_createChannel
|    |    1439         self.console_port = self._createChannel()
|    |    |> XendDomainInfo.py:_createChannel
|    |    |1445         try:
|    |    |1446             return xc.evtchn_alloc_unbound(domid=self.domid, 
remote_dom=0)
|    |    |< XendDomainInfo.py:_createChannel
|    |    < XendDomainInfo.py:_createChannels
|    |   1308             channel_details = self.image.createImage()
|    |    > image.py:createImage
|    |     120         return self.createDomain()
|    |    |> image.py:createDomain
|    |    | 128         if not os.path.isfile(self.kernel):
|    |    | 130         if self.ramdisk and not os.path.isfile(self.ramdisk):
|    |    | 132         if len(self.cmdline) >= MAX_GUEST_CMDLINE:
|    |    | 136         log.info("buildDomain os=%s dom=%d vcpus=%d", 
self.ostype,
|    |    | 137                  self.vm.getDomid(), self.vm.getVCpuCount())
|    |    | > XendDomainInfo.py:getDomid
|    |    |  789         return self.domid
|    |    | < XendDomainInfo.py:getDomid
|    |    | > XendDomainInfo.py:getVCpuCount
|    |    |  818         return self.info['vcpus']
|    |    | < XendDomainInfo.py:getVCpuCount
|    |    | 139         result = self.buildDomain()
|    |    | > image.py:buildDomain
|    |    |  189         store_evtchn = self.vm.getStorePort()
|    |    |  > XendDomainInfo.py:getStorePort
|    |    |   807         return self.store_port
|    |    |  < XendDomainInfo.py:getStorePort
|    |    |  190         console_evtchn = self.vm.getConsolePort()
|    |    |  > XendDomainInfo.py:getConsolePort
|    |    |   811         return self.console_port
|    |    |  < XendDomainInfo.py:getConsolePort
|    |    |  192         mem_mb = self.getRequiredInitialReservation() / 1024
|    |    |  > image.py:getRequiredInitialReservation
|    |    |   161         return 
self.getRequiredAvailableMemory(self.vm.getMemoryTarget())
|    |    |   > XendDomainInfo.py:getMemoryTarget
|    |    |    830         return self.info['memory'] * 1024
|    |    |   < XendDomainInfo.py:getMemoryTarget
|    |    |   > image.py:getRequiredAvailableMemory
|    |    |    153         return mem_kb
|    |    |   < image.py:getRequiredAvailableMemory
|    |    |  < image.py:getRequiredInitialReservation
|    |    |  194         log.debug("domid          = %d", self.vm.getDomid())
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    |  195         log.debug("memsize        = %d", mem_mb)
|    |    |  196         log.debug("image          = %s", self.kernel)
|    |    |  197         log.debug("store_evtchn   = %d", store_evtchn)
|    |    |  198         log.debug("console_evtchn = %d", console_evtchn)
|    |    |  199         log.debug("cmdline        = %s", self.cmdline)
|    |    |  200         log.debug("ramdisk        = %s", self.ramdisk)
|    |    |  201         log.debug("vcpus          = %d", 
self.vm.getVCpuCount())
|    |    |  > XendDomainInfo.py:getVCpuCount
|    |    |   818         return self.info['vcpus']
|    |    |  < XendDomainInfo.py:getVCpuCount
|    |    |  202         log.debug("features       = %s", self.vm.getFeatures())
|    |    |  > XendDomainInfo.py:getFeatures
|    |    |   815         return self.info['features']
|    |    |  < XendDomainInfo.py:getFeatures
|    |    |  204         return xc.linux_build(domid          = 
self.vm.getDomid(),
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    |  205                               memsize        = mem_mb,
|    |    |  206                               image          = self.kernel,
|    |    |  207                               store_evtchn   = store_evtchn,
|    |    |  208                               console_evtchn = console_evtchn,
|    |    |  209                               cmdline        = self.cmdline,
|    |    |  210                               ramdisk        = self.ramdisk,
|    |    |  211                               features       = 
self.vm.getFeatures())
|    |    |  > XendDomainInfo.py:getFeatures
|    |    |   815         return self.info['features']
|    |    |  < XendDomainInfo.py:getFeatures
|    |    | < image.py:buildDomain
|    |    | 141         if isinstance(result, dict):
|    |    | 142             return result
|    |    |< image.py:createDomain
|    |    < image.py:createImage
|    |   1310             self.store_mfn = channel_details['store_mfn']
|    |   1311             if 'console_mfn' in channel_details:
|    |   1312                 self.console_mfn = channel_details['console_mfn']
|    |   1314             self._introduceDomain()
|    |    > XendDomainInfo.py:_introduceDomain
|    |    1240         assert self.domid is not None
|    |    1241         assert self.store_mfn is not None
|    |    1242         assert self.store_port is not None
|    |    1244         try:
|    |    1245             IntroduceDomain(self.domid, self.store_mfn, 
self.store_port)
|    |    |> xenstore/xsutil.py:IntroduceDomain
|    |    |  23     return xshandle().introduce_domain(domid, page, port)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xsutil.py:IntroduceDomain
|    |    < XendDomainInfo.py:_introduceDomain
| |    |   1316             self._createDevices()
|    |    > XendDomainInfo.py:_createDevices
|    |    1119         for (devclass, config) in self.info.all_devices_sxpr():
|    |    |> XendConfig.py:all_devices_sxpr
|    |    | 914         sxprs = []
  | |    |    | 915         pci_devs = []
|    |    | 916         for dev_type, dev_info in self['device'].values():
|    |    | 917             if dev_type == 'pci': # special case for pci devices
|    |    | 920                 sxpr =  self.device_sxpr(dev_type = dev_type,
|          65             watch = we[1]
||        | 921                                          dev_info = dev_info)
||        ||   66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
 |    |  |   > XendConfig.py:device_sxpr
 |  |    |    > XendDomain.py:_on_domains_changed
 |  |   898         sxpr = []
 |  |       ||     133         self.domains_lock.acquire()
  |   899         if dev_uuid != None and dev_uuid in self['device']:
|    |    |   902         if dev_type == None or dev_info == None:
|    |    |   906         sxpr.append(dev_type)
|    |    |   907         config = [(opt, val) for opt, val in dev_info.items()]
|    |    |   907         config = [(opt, val) for opt, val in dev_info.items()]
|    |    |   907         config = [(opt, val) for opt, val in dev_info.items()]
|    |    |   907         config = [(opt, val) for opt, val in dev_info.items()]
|    |    |   907         config = [(opt, val) for opt, val in dev_info.items()]
|    |    |   908         sxpr += config
|    |    |   910         return sxpr
|    |    |  < XendConfig.py:device_sxpr
|    |    |  922                 sxprs.append((dev_type, sxpr))
|    |    |  916         for dev_type, dev_info in self['device'].values():
|    |    |  926         if pci_devs:
|    |    |  934         return sxprs
|    |    | < XendConfig.py:all_devices_sxpr
|    |    |1120             log.info("createDevice: %s : %s" % (devclass, 
config))
|    |    |1121             self._createDevice(devclass, config)
|    |    | > XendDomainInfo.py:_createDevice
|    |    | 1105         return 
self.getDeviceController(deviceClass).createDevice(devConfig)
|    |    |  > XendDomainInfo.py:getDeviceController
|    |    |  1152         if name not in self._deviceControllers:
|    |    |  1153             devController = XendDevices.make_controller(name, 
self)
|    |    |   > XendDevices.py:make_controller
|    |    |     62         if name in cls.controllers.keys():
|    |    |     63             cls.controllers[name].deviceClass = name
|    |    |     64             return cls.controllers[name](domain)
|    |    |    > server/blkif.py:__init__
|    |    |      36         DevController.__init__(self, vm)
|    |    |    |> server/DevController.py:__init__
|    |    |    |  72         self.vm = vm
|    |    |    |< server/DevController.py:__init__
|    |    |    < server/blkif.py:__init__
|    |    |   < XendDevices.py:make_controller
|    |    |  1154             if not devController:
|    |    |  1156             self._deviceControllers[name] = devController
|    |    |  1158         return self._deviceControllers[name]
|    |    |  < XendDomainInfo.py:getDeviceController
|    |    |  > server/DevController.py:createDevice
|    |    |    80         (devid, back, front) = self.getDeviceDetails(config)
|    |    |   > server/blkif.py:getDeviceDetails
|    |    |     40         uname = sxp.child_value(config, 'uname', '')
|    |    |     41         dev = sxp.child_value(config, 'dev', '')
|    |    |     43         if 'ioemu:' in dev:
|    |    |     45         try:
|    |    |     46             (dev, dev_type) = string.split(dev, ':', 1)
|    |    |   ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/server/blkif.py", line 46, in getDeviceDetails
    (dev, dev_type) = string.split(dev, ':', 1)
ValueError: need more than 1 value to unpack
|    |    |     47         except ValueError:
|    |    |     48             dev_type = "disk"
|    |    |     50         if uname is None:
|    |    |     57             try:
|    |    |     58                 (typ, params) = string.split(uname, ':', 1)
|    |    |     62         mode = sxp.child_value(config, 'mode', 'r')
|    |    |     63         if mode not in ('r', 'w', 'w!'):
|    |    |     66         back = { 'dev'    : dev,
|    |    |     72         uuid = sxp.child_value(config, 'uuid')
|    |    |     73         if uuid:
|    |    |     74             back['uuid'] = uuid
|    |    |     76         if security.on():
|    |    |     82         devid = blkif.blkdev_name_to_number(dev)
|    |    |     83         if devid is None:
|    |    |     86         front = { 'virtual-device' : "%i" % devid,
|    |    |     90         return (devid, back, front)
|    |    |   < server/blkif.py:getDeviceDetails
|    |    |    81         if devid is None:
|    |    |    84         (backpath, frontpath) = self.addStoreEntries(config, 
devid, back,
|    |    |    85                                                      front)
|    |    |   > server/DevController.py:addStoreEntries
|    |    |    405         import xen.xend.XendDomain
|    |    |    406         xd = xen.xend.XendDomain.instance()
|    |    |    > XendDomain.py:instance
|    |    |    1333     try:
|    |    |    1334         inst
|    |    |    1338     return inst
|    |    |    < XendDomain.py:instance
|    |    |    408         backdom_name = sxp.child_value(config, 'backend')
|    |    |    409         if backdom_name:
|    |    |    412             backdom = xd.privilegedDomain()
|    |    |    > XendDomain.py:privilegedDomain
|    |    |     524         self.domains_lock.acquire()
|    |    |     525         try:
|    |    |     526             return self.domains[DOM0_ID]
|    |    |     528             self.domains_lock.release()
|    |    |    < XendDomain.py:privilegedDomain
|    |    |    414         if not backdom:
|    |    |    418         frontpath = self.frontendPath(devid)
|    |    |    > server/DevController.py:frontendPath
|    |    |     468         return "%s/%d" % (self.frontendRoot(), devid)
|    |    |    |> server/DevController.py:frontendRoot
|    |    |    | 472         return "%s/device/%s" % (self.vm.getDomainPath(), 
self.deviceClass)
|    |    |    | > XendDomainInfo.py:getDomainPath
|    |    |    |  800         return self.dompath
|    |    |    | < XendDomainInfo.py:getDomainPath
|    |    |    |< server/DevController.py:frontendRoot
|    |    |    < server/DevController.py:frontendPath
|    |    |    419         backpath  = self.backendPath(backdom, devid)
|    |    |    > server/DevController.py:backendPath
|    |    |     462         return "%s/backend/%s/%s/%d" % 
(backdom.getDomainPath(),
|    |    |    |> XendDomainInfo.py:getDomainPath
|    |    |    | 800         return self.dompath
|    |    |    |< XendDomainInfo.py:getDomainPath
|    |    |    |> XendDomainInfo.py:getDomid
|    |    |    | 789         return self.domid
|    |    |    |< XendDomainInfo.py:getDomid
|    |    |    < server/DevController.py:backendPath
|    |    |    421         frontDetails.update({
|    |    |    > XendDomainInfo.py:getDomid
|    |    |     789         return self.domid
|    |    |    < XendDomainInfo.py:getDomid
|    |    |    428         backDetails.update({
|    |    |    > XendDomainInfo.py:getName
|    |    |     797         return self.info['name']
|    |    |    < XendDomainInfo.py:getName
|    |    |    > XendDomainInfo.py:getDomid
|    |    |     789         return self.domid
|    |    |    < XendDomainInfo.py:getDomid
|    |    |    436         return (backpath, frontpath)
|    |    |   < server/DevController.py:addStoreEntries
|    |    |    87         import xen.xend.XendDomain
|    |    |    88         xd = xen.xend.XendDomain.instance()
|    |    |   > XendDomain.py:instance
|    |    |   1333     try:
|    |    |   1334         inst
|    |    |   1338     return inst
|    |    |   < XendDomain.py:instance
|    |    |    89         backdom_name = sxp.child_value(config, 'backend')
|    |    |    90         if backdom_name is None:
|    |    |    91             backdom = xen.xend.XendDomain.DOM0_ID
|    |    |    95         count = 0
|    |    |    96         while True:
|    |    |    97             t = xstransact()
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |    98             try:
|    |    |    99                 if devid in self.deviceIDs(t):
|    |    |   > server/DevController.py:deviceIDs
|    |    |    368         fe = self.backendRoot()
|    |    |    > server/DevController.py:backendRoot
|    |    |     476         from xen.xend.XendDomain import DOM0_ID
|    |    |     477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |     478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |    |> xenstore/xsutil.py:GetDomainPath
|    |    |    |  26     return xshandle().get_domain_path(domid)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xsutil.py:GetDomainPath
|    |    |    |> XendDomainInfo.py:getDomid
|    |    |    | 789         return self.domid
|    |    |    |< XendDomainInfo.py:getDomid
|    |    |    < server/DevController.py:backendRoot
|    |    |    369         if transaction:
|    |    |    370             return map(lambda x: int(x.split('/')[-1]), 
transaction.list(fe))
|    |    |    > xenstore/xstransact.py:list
|    |    |     129         if len(args) == 0:
|    |    |     136             ret = []
|    |    |     137             for key in args:
|    |    |     138                 ret.extend(self._list(key))
|    |    |    |> xenstore/xstransact.py:_list
|    |    |    | 117         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  286             return key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    | 119         if l:
|    |    |    | 121         return []
|    |    |    |< xenstore/xstransact.py:_list
|    |    |     137             for key in args:
|    |    |     139             return ret
|    |    |    < xenstore/xstransact.py:list
|    |    |   < server/DevController.py:deviceIDs
|    |    |   108                 if count == 0:
|    |    |   109                     log.debug('DevController: writing %s to 
%s.', str(front),
|    |    |   110                               frontpath)
|    |    |   111                     log.debug('DevController: writing %s to 
%s.', str(back),
|    |    |   112                               backpath)
|    |    |   117                 t.remove(frontpath)
|    |    |   > xenstore/xstransact.py:remove
|    |    |    110         if len(args) == 0:
|    |    |    113             for key in args:
|    |    |    114                 self._remove(key)
|    |    |    > xenstore/xstransact.py:_remove
|    |    |     102         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 286             return key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     103         return xshandle().rm(self.transaction, path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    < xenstore/xstransact.py:_remove
|    |    |    113             for key in args:
|    |    |   < xenstore/xstransact.py:remove
|    |    |   118                 t.remove(backpath)
|    |    |   > xenstore/xstransact.py:remove
|    |    |    110         if len(args) == 0:
|    |    |    113             for key in args:
|    |    |    114                 self._remove(key)
|    |    |    > xenstore/xstransact.py:_remove
|    |    |     102         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 286             return key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     103         return xshandle().rm(self.transaction, path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    < xenstore/xstransact.py:_remove
|    |    |    113             for key in args:
|    |    |   < xenstore/xstransact.py:remove
|    |    |   120                 t.mkdir(backpath)
|    |    |   > xenstore/xstransact.py:mkdir
|    |    |    217         if len(args) == 0:
|    |    |    220             for key in args:
|    |    |    221                 xshandle().mkdir(self.transaction, 
self.prependPath(key))
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |    > xenstore/xstransact.py:prependPath
|    |    |     283         if self.path:
|    |    |     286             return key
|    |    |    < xenstore/xstransact.py:prependPath
|    |    |    220             for key in args:
|    |    |   < xenstore/xstransact.py:mkdir
|    |    |   121                 t.set_permissions(backpath,
|    |    |   122                                   {'dom': backdom },
|    |    |   123                                   {'dom'  : 
self.vm.getDomid(),
|    |    |   > XendDomainInfo.py:getDomid
|    |    |    789         return self.domid
|    |    |   < XendDomainInfo.py:getDomid
|    |    |   > xenstore/xstransact.py:set_permissions
|    |    |    253         if len(args) == 0:
|    |    |    255         elif isinstance(args[0], str):
|    |    |    256             self.callRebased(args[0], self.set_permissions, 
*args[1:])
|    |    |    > xenstore/xstransact.py:callRebased
|    |    |     274         oldpath = self.path
|    |    |     275         self.path = self.prependPath(middlePath)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 286             return key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     276         try:
|    |    |     277             func(*args)
|    |    |    |> xenstore/xstransact.py:set_permissions
|    |    |    | 253         if len(args) == 0:
|    |    |    | 255         elif isinstance(args[0], str):
|    |    |    | 258             if not self.path:
|    |    |    | 261             xshandle().set_permissions(self.transaction, 
self.path,
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    | 262                                        list(args))
|    |    |    |< xenstore/xstransact.py:set_permissions
|    |    |     279             self.path = oldpath
|    |    |    < xenstore/xstransact.py:callRebased
|    |    |   < xenstore/xstransact.py:set_permissions
|    |    |   125                 t.mkdir(frontpath)
|    |    |   > xenstore/xstransact.py:mkdir
|    |    |    217         if len(args) == 0:
|    |    |    220             for key in args:
|    |    |    221                 xshandle().mkdir(self.transaction, 
self.prependPath(key))
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |    > xenstore/xstransact.py:prependPath
|    |    |     283         if self.path:
|    |    |     286             return key
|    |    |    < xenstore/xstransact.py:prependPath
|    |    |    220             for key in args:
|    |    |   < xenstore/xstransact.py:mkdir
|    |    |   126                 t.set_permissions(frontpath,
|    |    |   127                                   {'dom': self.vm.getDomid()},
|    |    |   > XendDomainInfo.py:getDomid
|    |    |    789         return self.domid
|    |    |   < XendDomainInfo.py:getDomid
|    |    |   128                                   {'dom': backdom, 'read': 
True})
|    |    |   > xenstore/xstransact.py:set_permissions
|    |    |    253         if len(args) == 0:
|    |    |    255         elif isinstance(args[0], str):
|    |    |    256             self.callRebased(args[0], self.set_permissions, 
*args[1:])
|    |    |    > xenstore/xstransact.py:callRebased
|    |    |     274         oldpath = self.path
|    |    |     275         self.path = self.prependPath(middlePath)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 286             return key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     276         try:
|    |    |     277             func(*args)
|    |    |    |> xenstore/xstransact.py:set_permissions
|    |    |    | 253         if len(args) == 0:
|    |    |    | 255         elif isinstance(args[0], str):
|    |    |    | 258             if not self.path:
|    |    |    | 261             xshandle().set_permissions(self.transaction, 
self.path,
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    | 262                                        list(args))
|    |    |    |< xenstore/xstransact.py:set_permissions
|    |    |     279             self.path = oldpath
|    |    |    < xenstore/xstransact.py:callRebased
|    |    |   < xenstore/xstransact.py:set_permissions
|    |    |   130                 t.write2(frontpath, front)
|    |    |   > xenstore/xstransact.py:write2
|    |    |    270         self.callRebased(middlePath, self.write, *args)
|    |    |    > xenstore/xstransact.py:callRebased
|    |    |     274         oldpath = self.path
|    |    |     275         self.path = self.prependPath(middlePath)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 286             return key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     276         try:
|    |    |     277             func(*args)
|    |    |    |> xenstore/xstransact.py:write
|    |    |    |  78         if len(args) == 0:
|    |    |    |  80         if isinstance(args[0], dict):
|    |    |    |  81             for d in args:
|    |    |    |  82                 if not isinstance(d, dict):
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  81             for d in args:
|    |    |    |< xenstore/xstransact.py:write
|    |    |     279             self.path = oldpath
|    |    |    < xenstore/xstransact.py:callRebased
|    |    |   < xenstore/xstransact.py:write2
|    |    |   131                 t.write2(backpath,  back)
|    |    |   > xenstore/xstransact.py:write2
|    |    |    270         self.callRebased(middlePath, self.write, *args)
|    |    |    > xenstore/xstransact.py:callRebased
|    |    |     274         oldpath = self.path
|    |    |     275         self.path = self.prependPath(middlePath)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 286             return key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     276         try:
|    |    |     277             func(*args)
|    |    |    |> xenstore/xstransact.py:write
|    |    |    |  78         if len(args) == 0:
|    |    |    |  80         if isinstance(args[0], dict):
|    |    |    |  81             for d in args:
|    |    |    |  82                 if not isinstance(d, dict):
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  85                     try:
|    |    |    |  86                         self._write(key, d[key])
|    |    |    | > xenstore/xstransact.py:_write
|    |    |    |   69         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   70         try:
|    |    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_write
|    |    |    |  84                 for key in d.keys():
|    |    |    |  81             for d in args:
|    |    |    |< xenstore/xstransact.py:write
|    |    |     279             self.path = oldpath
|    |    |    < xenstore/xstransact.py:callRebased
|    |    |   < xenstore/xstransact.py:write2
|    |    |   133                 if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   134                     return devid
|    |    |  < server/DevController.py:createDevice
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < XendDomainInfo.py:_createDevice
|    |    |1119         for (devclass, config) in self.info.all_devices_sxpr():
|    |    |1123         if self.image:
|    |    |1124             self.image.createDeviceModel()
|    |    | > image.py:createDeviceModel
|    |    |  176         """Create device model for the domain (define in 
subclass if needed)."""
|    |    | < image.py:createDeviceModel
|    |    |< XendDomainInfo.py:_createDevices
|    |    1318             if self.info['bootloader']:
|    |    1321             self.info['start_time'] = time.time()
|    |    1323             self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1598                 self.state = state
|    |    |1599                 self.state_updated.notifyAll()
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |    < XendDomainInfo.py:_initDomain
|    |    438                 self._storeVmDetails()
|    |    > XendDomainInfo.py:_storeVmDetails
|    |    1546         to_store = {}
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1549             if self._infoIsSet(k[0]):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    1548         for k in VM_STORE_ENTRIES:
|    |    1552         if self._infoIsSet('image'):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1553             to_store['image'] = sxp.to_string(self.info['image'])
|    |    1555         if self._infoIsSet('security'):
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |    1556             secinfo = self.info['security']
|    |    1557             to_store['security'] = sxp.to_string(secinfo)
|    |    1558             for idx in range(0, len(secinfo)):
|    |    1573         if not self._readVm('xend/restart_count'):
|    |    |> XendDomainInfo.py:_readVm
|    |    | 644         return xstransact.Read(self.vmpath, *args)
|    |    | > xenstore/xstransact.py:Read
|    |    |  297         return complete(path, lambda t: t.read(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    297         return complete(path, lambda t: t.read(*args))
|    |    |    > xenstore/xstransact.py:read
|    |    |      59         if len(args) == 0:
|    |    |      61         if len(args) == 1:
|    |    |      62             return self._read(args[0])
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |    < xenstore/xstransact.py:read
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:Read
|    |    |< XendDomainInfo.py:_readVm
|    |    1574             to_store['xend/restart_count'] = str(0)
|    |    1576         log.debug("Storing VM details: %s", to_store)
|    |    1578         self._writeVm(to_store)
|    |    |> XendDomainInfo.py:_writeVm
|    |    | 647         return xstransact.Write(self.vmpath, *args)
|    |    | > xenstore/xstransact.py:Write
|    |    |  301         complete(path, lambda t: t.write(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    301         complete(path, lambda t: t.write(*args))
|    |    |    > xenstore/xstransact.py:write
|    |    |      78         if len(args) == 0:
|    |    |      80         if isinstance(args[0], dict):
|    |    |      81             for d in args:
|    |    |      82                 if not isinstance(d, dict):
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      81             for d in args:
|    |    |    < xenstore/xstransact.py:write
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:Write
|    |    |< XendDomainInfo.py:_writeVm
|    |    1579         self._setVmPermissions()
|    |    |> XendDomainInfo.py:_setVmPermissions
|    |    |1585         xstransact.SetPermissions('%s/uuid' % self.vmpath,
|    |    |1586                                   { 'dom' : self.domid,
|    |    | > xenstore/xstransact.py:SetPermissions
|    |    |  341         complete(path, lambda t: t.set_permissions(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    341         complete(path, lambda t: t.set_permissions(*args))
|    |    |    > xenstore/xstransact.py:set_permissions
|    |    |     253         if len(args) == 0:
|    |    |     255         elif isinstance(args[0], str):
|    |    |     258             if not self.path:
|    |    |     261             xshandle().set_permissions(self.transaction, 
self.path,
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     262                                        list(args))
|    |    |    < xenstore/xstransact.py:set_permissions
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:SetPermissions
|    |    |< XendDomainInfo.py:_setVmPermissions
|    |    < XendDomainInfo.py:_storeVmDetails
|    |    439                 self._storeDomDetails()
|    |    > XendDomainInfo.py:_storeDomDetails
|    |     684         to_store = {
|    |    |> XendRoot.py:get_console_limit
|    |    | 287         return self.get_config_int('console-limit', 1024)
|    |    | > XendRoot.py:get_config_int
|    |    |  186         v = self.get_config_value(name, val)
|    |    |  > XendRoot.py:get_config_value
|    |    |   175         return sxp.child_value(self.config, name, val=val)
|    |    |  < XendRoot.py:get_config_value
|    |    |  187         try:
|    |    |  188             return int(v)
|    |    | < XendRoot.py:get_config_int
|    |    |< XendRoot.py:get_console_limit
|    |     692         def f(n, v):
|    |     696         f('console/port',     self.console_port)
|    |    |> XendDomainInfo.py:f
|    |    | 693             if v is not None:
|    |    | 694                 to_store[n] = str(v)
|    |    |< XendDomainInfo.py:f
|    |     697         f('console/ring-ref', self.console_mfn)
|    |    |> XendDomainInfo.py:f
|    |    | 693             if v is not None:
|    |    | 694                 to_store[n] = str(v)
|    |    |< XendDomainInfo.py:f
|    |     698         f('store/port',       self.store_port)
|    |    |> XendDomainInfo.py:f
|    |    | 693             if v is not None:
|    |    | 694                 to_store[n] = str(v)
|    |    |< XendDomainInfo.py:f
|    |     699         f('store/ring-ref',   self.store_mfn)
|    |    |> XendDomainInfo.py:f
|    |    | 693             if v is not None:
|    |    | 694                 to_store[n] = str(v)
|    |    |< XendDomainInfo.py:f
|    |     701         to_store.update(self._vcpuDomDetails())
|    |    |> XendDomainInfo.py:_vcpuDomDetails
|    |    | 708         def availability(n):
|    |    | 714         result = {}
|    |    | 715         for v in range(0, self.info['vcpus']):
|    |    | 716             result["cpu/%d/availability" % v] = availability(v)
|    |    | > XendDomainInfo.py:availability
|    |    |  709             if self.info['vcpu_avail'] & (1 << n):
|    |    |  710                 return 'online'
|    |    | < XendDomainInfo.py:availability
|    |    | 715         for v in range(0, self.info['vcpus']):
|    |    | 717         return result
|    |    |< XendDomainInfo.py:_vcpuDomDetails
|    |     703         log.debug("Storing domain details: %s", to_store)
|    |     705         self._writeDom(to_store)
|    |    |> XendDomainInfo.py:_writeDom
|    |    | 666         return xstransact.Write(self.dompath, *args)
|    |    | > xenstore/xstransact.py:Write
|    |    |  301         complete(path, lambda t: t.write(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    301         complete(path, lambda t: t.write(*args))
|    |    |    > xenstore/xstransact.py:write
|    |    |      78         if len(args) == 0:
|    |    |      80         if isinstance(args[0], dict):
|    |    |      81             for d in args:
|    |    |      82                 if not isinstance(d, dict):
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      85                     try:
|    |    |      86                         self._write(key, d[key])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      84                 for key in d.keys():
|    |    |      81             for d in args:
|    |    |    < xenstore/xstransact.py:write
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:Write
|    |    |< XendDomainInfo.py:_writeDom
|    |    < XendDomainInfo.py:_storeDomDetails
|    |    440                 self._registerWatches()
|    |    > XendDomainInfo.py:_registerWatches
|    |     729         self.vmWatch = xswatch(self.vmpath, self._storeChanged)
|    |    |> xenstore/xswatch.py:__init__
|    |    |  29         self.path = path
|    |    |  30         self.fn = fn
|    |    |  31         self.args = args
|    |    |  32         self.kwargs = kwargs
|    |    |  33         watchStart()
|    |    | > xenstore/xswatch.py:watchStart
|    |    |   49     xslock.acquire()
|    |    |   50     try:
|    |    |   51         if watchThread:
|    |    |   52             return
|    |    |   58         xslock.release()
|    |    | < xenstore/xswatch.py:watchStart
|    |    |  34         xs.watch(path, self)
|    |    |< xenstore/xswatch.py:__init__
|    |     730         self.shutdownWatch = xswatch(self.dompath + 
'/control/shutdown',
|    |     731                                      self._handleShutdownWatch)
|    |    |> xenstore/xswatch.py:__init__
|    |    |  29         self.path = path
|    |    |  30         self.fn = fn
|    |    |  31         self.args = args
|    |    |  32         self.kwargs = kwargs
|    |    |  33         watchStart()
|    |    | > xenstore/xswatch.py:watchStart
|    |    |   49     xslock.acquire()
|    |    |   50     try:
|    |    |   51         if watchThread:
|    |    |   52             return
|    |    |   58         xslock.release()
|    |    | < xenstore/xswatch.py:watchStart
|    |    |  34         xs.watch(path, self)
|    |    |< xenstore/xswatch.py:__init__
|    |    < XendDomainInfo.py:_registerWatches
|    |    441                 self.refreshShutdown()
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     861                 xeninfo = dom_get(self.domid)
|    |    |> XendDomainInfo.py:dom_get
|    |    | 306     try:
|    |    | 307         domlist = xc.domain_getinfo(dom, 1)
|    |    | 308         if domlist and dom == domlist[0]['domid']:
|    |    | 309             return domlist[0]
|    |    |< XendDomainInfo.py:dom_get
|    |     862                 if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     937                     self._stateSet(DOM_STATE_PAUSED)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1598                 self.state = state
|    |    |1599                 self.state_updated.notifyAll()
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |    442                 self.unpause()
|    |    > XendDomainInfo.py:unpause
|    |     499         try:
|    |     500             xc.domain_unpause(self.domid)
|    |     501             self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1598                 self.state = state
|    |    |1599                 self.state_updated.notifyAll()
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |    < XendDomainInfo.py:unpause
|    |    447                 if is_managed:
|    |   < XendDomainInfo.py:start
|    |   156     return vm
|    |  < XendDomainInfo.py:create
|    |  803             self._add_domain(dominfo)
|    |  > XendDomain.py:_add_domain
|    |   402         log.debug("Adding Domain: %s" % info.getDomid())
|    |   > XendDomainInfo.py:getDomid
|    |    789         return self.domid
|    |   < XendDomainInfo.py:getDomid
|    |   403         self.domains[info.getDomid()] = info
|    |   > XendDomainInfo.py:getDomid
|    |    789         return self.domid
|    |   < XendDomainInfo.py:getDomid
|    |  < XendDomain.py:_add_domain
|    |  804             self.domain_sched_credit_set(dominfo.getDomid(),
|    |  > XendDomainInfo.py:getDomid
|    |   789         return self.domid
|    |  < XendDomainInfo.py:getDomid
|    |  805                                          dominfo.getWeight(),
|    |  > XendDomainInfo.py:getWeight
|    |   839         return self.info['cpu_weight']
|    |  < XendDomainInfo.py:getWeight
|    |  806                                          dominfo.getCap())
|    |  > XendDomainInfo.py:getCap
|    |   836         return self.info['cpu_cap']
|    |  < XendDomainInfo.py:getCap
|    |  > XendDomain.py:domain_sched_credit_set
|    |  1247         dominfo = self.domain_lookup_nr(domid)
|    |   > XendDomain.py:domain_lookup_nr
|    |    485         self.domains_lock.acquire()
|    |    486         try:
|    |    488             match = [dom for dom in self.domains.values() \
|    |    > XendDomainInfo.py:getName
|    |     797         return self.info['name']
|    |    < XendDomainInfo.py:getName
|    |    488             match = [dom for dom in self.domains.values() \
|    |    > XendDomainInfo.py:getName
|    |     797         return self.info['name']
|    |    < XendDomainInfo.py:getName
|    |    488             match = [dom for dom in self.domains.values() \
|    |    490             if match:
|    |    493             match = [dom for dom in self.managed_domains.values() 
\
|    |    495             if match:
|    |    499             try:
|    |    500                 if int(domid) in self.domains:
|    |    501                     return self.domains[int(domid)]
|    |    517             self.domains_lock.release()
|    |   < XendDomain.py:domain_lookup_nr
|    |  1248         if not dominfo:
|    |  1250         try:
|    |  1251             if weight is None:
|    |  1253             elif weight < 1 or weight > 65535:
|    |  1256             if cap is None:
|    |  1258             elif cap < 0 or cap > dominfo.getVCpuCount() * 100:
|    |   > XendDomainInfo.py:getVCpuCount
|    |    818         return self.info['vcpus']
|    |   < XendDomainInfo.py:getVCpuCount
|    |  1261             assert type(weight) == int
|    |  1262             assert type(cap) == int
|    |  1264             return xc.sched_credit_domain_set(dominfo.getDomid(), 
weight, cap)
|    |   > XendDomainInfo.py:getDomid
|    |    789         return self.domid
|    |   < XendDomainInfo.py:getDomid
|    |  < XendDomain.py:domain_sched_credit_set
|    |  807             return dominfo
|    |  809             self.domains_lock.release()
|    |  134         try:
|    |  135             self._refresh()
|    |  > XendDomain.py:_refresh
|    |   379         running = self._running_domains()
|    |   > XendDomain.py:_running_domains
|    |    343         try:
|    |    344             return xc.domain_getinfo()
|    |   < XendDomain.py:_running_domains
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 206     ('image',        lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     783             if d_type not in XendDevices.valid_devices():
|    |    |> XendDevices.py:valid_devices
|    |    |  48         return cls.controllers.keys()
|    |    |< XendDevices.py:valid_devices
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |  < XendDomain.py:_refresh
|    |  137             self.domains_lock.release()
|    |  138         return 1
|    | < XendDomain.py:_on_domains_changed
|    |  67             if not res:
|    |  62     while True:
|    |  63         try:
|    |  64             we = xs.read_watch()
|    |  65             watch = we[1]
|    |  66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    | > XendDomainInfo.py:_storeChanged
|    |  734         log.trace("XendDomainInfo.storeChanged");
|    |  > XendLogging.py:trace
|    |    36         self.log(logging.TRACE, *args, **kwargs)
|    |  < XendLogging.py:trace
|    |  736         changed = False
|    |  738         def f(x, y):
|    |  743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |  > XendDomainInfo.py:_readVMDetails
|    |  1485         try:
|    |  1486             return self._gatherVm(*params)
|    |   > XendDomainInfo.py:_gatherVm
|    |    653         return xstransact.Gather(self.vmpath, *args)
|    |    > xenstore/xstransact.py:Gather
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:complete
|    |    | 350     while True:
|    |    | 351         t = xstransact(path)
|    |    | > xenstore/xstransact.py:__init__
|    |    |   14         assert path is not None
|    |    |   16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |   19         self.path = path.rstrip("/")
|    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < XendDomain.py:domain_create
|    |    |  65     return fixup_sxpr(info.sxpr())
|    |    | > XendDomainInfo.py:sxpr
|    |    | 1663         result = self.info.get_sxp(domain = self,
|    |    | 1664                                    ignore_devices = 
ignore_store)
|    |    |  > XendConfig.py:get_sxp
|    |    |   683         sxpr = ['domain']
|    |    |   688         if domain.getDomid() != None:
|    |    |   > XendDomainInfo.py:getDomid
|    |    |    789         return self.domid
|    |    |   < XendDomainInfo.py:getDomid
|    |    |   689             sxpr.append(['domid', domain.getDomid()])
|    |    |   > XendDomainInfo.py:getDomid
|    |    |    789         return self.domid
|    |    |   < XendDomainInfo.py:getDomid
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   696         if 'image' in self and self['image'] != None:
|    |    |   697             sxpr.append(['image', self['image']])
|    |    |   698         if 'security' in self and self['security']:
|    |    |   700         if 'shutdown_reason' in self:
|    |    |   701             sxpr.append(['shutdown_reason', 
self['shutdown_reason']])
|    |    |   702         if 'cpu_time' in self:
|    |    |   703             sxpr.append(['cpu_time', self['cpu_time']/1e9])
|    |    |   705         sxpr.append(['online_vcpus', self['online_vcpus']])
|    |    |   707         if 'start_time' in self:
|    |    |   708             uptime = time.time() - self['start_time']
|    |    |   709             sxpr.append(['up_time', str(uptime)])
|    |    |   710             sxpr.append(['start_time', 
str(self['start_time'])])
|    |    |   712         if domain:
|    |    |   713             sxpr.append(['status', str(domain.state)])
|    |    |   717         sxpr.append(['state', self._get_old_state_string()])
|    |    |   > XendConfig.py:_get_old_state_string
|    |    |    662         state_string = ''
|    |    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |    664             on_off = self.get(state_name, 0)
|    |    |    665             if on_off:
|    |    |    666                 state_string += state_name[0]
|    |    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |    664             on_off = self.get(state_name, 0)
|    |    |    665             if on_off:
|    |    |    668                 state_string += '-'
|    |    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |    664             on_off = self.get(state_name, 0)
|    |    |    665             if on_off:
|    |    |    668                 state_string += '-'
|    |    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |    664             on_off = self.get(state_name, 0)
|    |    |    665             if on_off:
|    |    |    668                 state_string += '-'
|    |    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |    664             on_off = self.get(state_name, 0)
|    |    |    665             if on_off:
|    |    |    668                 state_string += '-'
|    |    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |    664             on_off = self.get(state_name, 0)
|    |    |    665             if on_off:
|    |    |    668                 state_string += '-'
|    |    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |    670         return state_string
|    |    |   < XendConfig.py:_get_old_state_string
| |    |    |     21         self.in_transaction = True
 |   |    |   718         sxpr.append(['memory_dynamic_max', 
self.get('memory_dynamic_max',
 |    |    |   719                                                     
self['memory'])])
  ||     |  < xenstore/xstransact.py:__init__
|    |    |    |  722         if domain:
|      |  352         try:
 |    | |    |  723             if domain.store_mfn:
 |    |    |  724                 sxpr.append(['store_mfn', domain.store_mfn])
 |    |    |  725             if domain.console_mfn:
  ||    |      353             result = f(t)
||    |    |    726                 sxpr.append(['console_mfn', 
domain.console_mfn])
| > xenstore/xstransact.py:<lambda>
 |   |      |    |   333         return complete(path, lambda t: 
t.gather(*args))
 |    |    |   > xenstore/xstransact.py:gather
||    729         if not ignore_devices:
|    |    |       730             for cls in XendDevices.valid_devices():
||     |    169         if len(args) and type(args[0]) != tuple:
 |      |    |    ||    > XendDevices.py:valid_devices
 |    |    |      48         return cls.controllers.keys()
|    |      |    < XendDevices.py:valid_devices
|    |    |    731                 found = False
|    |    |    171         ret = []
 |  734                 if domain:
   |    |    172         for tup in args:
|    |    | |    |    |    173             if len(tup) == 2:
 |   735                     try:
 |    |   |    |    174                 (key, fn) = tup
 |      |    |    175                 defval = None
||     736                         controller = domain.getDeviceController(cls)
 |    |    |    |      | > XendDomainInfo.py:getDeviceController
 |      179             val = self._read(key)
||      |    |     |    1152         if name not in self._deviceControllers:
 | |> xenstore/xstransact.py:_read
 |   |     |    |    |  44         path = self.prependPath(key)
 |  |   |       |    | > xenstore/xstransact.py:prependPath
 | |1153             devController = XendDevices.make_controller(name, self)
 |   |    |    |   |   283         if self.path:
 |   |    |  > XendDevices.py:make_controller
 |   |      |   |    |   284             return self.path + '/' + key
 |    |    |    |  < xenstore/xstransact.py:prependPath
 ||       |    62         if name in cls.controllers.keys():
|    | |    |    |   45         try:
 |    |    |    |   46             return xshandle().read(self.transaction, 
path)
 |   |      |    |    |  > xenstore/xsutil.py:xshandle
 | |     63             cls.controllers[name].deviceClass = name
 |    |    |    |    64             return cls.controllers[name](domain)
| |    |    |    15     if not xs_handle:
 |   |      |    |    |     20     return xs_handle
 | |    |    |    |   < xenstore/xsutil.py:xshandle
   |   > server/netif.py:__init__
|    |    |    ||      |    |    137         DevController.__init__(self, vm)
 | |  < xenstore/xstransact.py:_read
 |    |    |      |   185             if val is None:
||        |    |    |   188                 val = fn(val)
| |      |   |  > server/DevController.py:__init__
 |     |  |     |     189             ret.append(val)
||    |    |      |   172         for tup in args:
 |    | |      |   72         self.vm = vm
 |    |      |   173             if len(tup) == 2:
||        ||  < server/DevController.py:__init__
 |      |    |   174                 (key, fn) = tup
 |   |   |      |    ||    |  175                 defval = None
 |    |    | < server/netif.py:__init__
   |  179             val = self._read(key)
|  |     | |    |       | | > xenstore/xstransact.py:_read
 |    |       ||< XendDevices.py:make_controller
 |    |    |     44         path = self.prependPath(key)
 |    |1154             if not devController:
| |    |   |        ||        | 1156             self._deviceControllers[name] 
= devController
||    > xenstore/xstransact.py:prependPath
 |    |    | |    |    283         if self.path:
 |   |    | |     1158         return self._deviceControllers[name]
||    |    |    | < XendDomainInfo.py:getDeviceController
|    |    |    | 737                         configs = 
controller.configurations()
|    |    |    | > server/DevController.py:configurations
|    |    |     |  216         return map(self.configuration, self.deviceIDs())
|    |    |    |  > server/DevController.py:deviceIDs
|    |    |    |   368         fe = self.backendRoot()
|    |    |    |   > server/DevController.py:backendRoot
|    |    |    |    476         from xen.xend.XendDomain import DOM0_ID
|    |    |    |    477         from xen.xend.xenstore.xsutil import 
GetDomainPath
|    |    |    |    478         return "%s/backend/%s/%s" % 
(GetDomainPath(DOM0_ID),
|    |    |    |    > xenstore/xsutil.py:GetDomainPath
|    |    |    |      26     return xshandle().get_domain_path(domid)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
   |  284             return self.path + '/' + key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |     45         try:
|    |    |    |     46             return xshandle().read(self.transaction, 
path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xsutil.py:GetDomainPath
|    |    |    |   > XendDomainInfo.py:getDomid
|    |    |    |    789         return self.domid
|    |    |    |   < XendDomainInfo.py:getDomid
|    |    |    |  < server/DevController.py:backendRoot
|    |    |    |  369         if transaction:
|    |    |    |  372             return map(int, xstransact.List(fe))
|    |    |    |  > xenstore/xstransact.py:List
|    |    |    |   319         return complete(path, lambda t: t.list(*args))
|    |    |    |   > xenstore/xstransact.py:complete
|    |    |    |    350     while True:
|    |    |    |    351         t = xstransact(path)
|    |    |    |    > xenstore/xstransact.py:__init__
|    |    |    |      14         assert path is not None
|    |    |    |      16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |      19         self.path = path.rstrip("/")
|    |    |    |      20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_read
|    |    |    |    185             if val is None:
|    |    |    |    188                 val = fn(val)
|    |    |    |    189             ret.append(val)
|    |    |    |    172         for tup in args:
|    |    |    |    173             if len(tup) == 2:
|    |    |    |    174                 (key, fn) = tup
|    |    |    |    175                 defval = None
|    |    |    |    179             val = self._read(key)
|    |    |    |    > xenstore/xstransact.py:_read
|    |    |    |      44         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      45         try:
|    |    |    |      46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_read
|    |    |    |    185             if val is None:
|    |    |    |    188                 val = fn(val)
|    |    |    |    189             ret.append(val)
|    | |    |    |    |     21         self.in_transaction = True
|    |    |    |   < xenstore/xstransact.py:__init__
|    |    |    |   352         try:
|    |    |    |   353             result = f(t)
|    |    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    |    319         return complete(path, lambda t: t.list(*args))
|    |    |    |    > xenstore/xstransact.py:list
|    |    |    |     129         if len(args) == 0:
|    |    |    |     130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
   |    |    172         for tup in args:
|    |    |    |     173             if len(tup) == 2:
|    |    |    |     174                 (key, fn) = tup
|    |    |    |     175                 defval = None
|    |    |    |     179             val = self._read(key)
|    |    |    |    |> xenstore/xstransact.py:_read
|    |    |    |    |  44         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  45         try:
|    |    |    |    |  46             return xshandle().read(self.transaction, 
path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    | 131             if ret is None:
|    |    |    |    | 132                 return []
|    |    |    |    |< xenstore/xstransact.py:list
|    |    |    |    < xenstore/xstransact.py:<lambda>
|    |    |    |    354             if t.commit():
|    |    |    |    > xenstore/xstransact.py:commit
|    |    |    |      28         if not self.in_transaction:
|    |    |    |      30         self.in_transaction = False
|    |    |    |      31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |      32         self.transaction = "0"
|    |    |    |      33         return rc
|    |    |    |    < xenstore/xstransact.py:commit
|    |    |    |    355                 return result
|    |    |    |   < xenstore/xstransact.py:complete
|    |    |    |   > xenstore/xstransact.py:__del__
|    |    |    |     24         if self.in_transaction:
|    |    |    |   < xenstore/xstransact.py:__del__
|    |    |    |  < xenstore/xstransact.py:List
|    |    |    | < server/DevController.py:deviceIDs
|    |    |    |< server/DevController.py:configurations
|    |    |     738                         for config in configs:
|    |    |     747                 if not found:
|    |    |     748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |    |> XendConfig.py:all_devices_sxpr
|    |    |    | 914         sxprs = []
|    |    |    | 915         pci_devs = []
|    |    |    | 916         for dev_type, dev_info in self['device'].values():
|    |    |    | 917             if dev_type == 'pci': # special case for pci 
devices
|    |    |    | 920                 sxpr =  self.device_sxpr(dev_type = 
dev_type,
|    |    |    | 921                                          dev_info = 
dev_info)
|    |    |    | > XendConfig.py:device_sxpr
|    |    |    |  898         sxpr = []
|    |    |    |  899         if dev_uuid != None and dev_uuid in 
self['device']:
|    |    |    |  902         if dev_type == None or dev_info == None:
|    |    |    |  906         sxpr.append(dev_type)
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  908         sxpr += config
|    |    |    |  910         return sxpr
|    |    |    | < XendConfig.py:device_sxpr
|    |    |    | 922                 sxprs.append((dev_type, sxpr))
|    |    |    | 916         for dev_type, dev_info in self['device'].values():
|    |    |    | 926         if pci_devs:
|    |    |    | 934         return sxprs
|    |    |    |< XendConfig.py:all_devices_sxpr
|    |    |     749                         if dev_type == cls:
|    |    |     748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |     730             for cls in XendDevices.valid_devices():
|    |    |     731                 found = False
|    |    |     734                 if domain:
|    |    |     735                     try:
|    |    |     736                         controller = 
domain.getDeviceController(cls)
|    |    |    |> XendDomainInfo.py:getDeviceController
|    |    |    |1152         if name not in self._deviceControllers:
|    |    |    |1153             devController = 
XendDevices.make_controller(name, self)
|    |    |    | > XendDevices.py:make_controller
|    |    |    |   62         if name in cls.controllers.keys():
|    |    |    |    |    | < xenstore/xstransact.py:_read
|    |    |    | 185             if val is None:
||    |   63             cls.controllers[name].deviceClass = name
 |    |    |    |   |  64             return cls.controllers[name](domain)
 |    |    | 188                 val = fn(val)
 |    |  |    |    |   > server/usbif.py:__init__
 |  |     |    |    |   36         DevController.__init__(self, vm)
 |    | |  189             ret.append(val)
 |    |      |  > server/DevController.py:__init__
 | |    |    |   |     172         for tup in args:
 |  |     |      |    72         self.vm = vm
||    |    |       |   190         if len(ret) == 1:
 | |  < server/DevController.py:__init__
 |      |    |    | < server/usbif.py:__init__
|  |     |    | |    |    |< XendDevices.py:make_controller
   192         return ret
|    |  |    |    |    < xenstore/xstransact.py:gather
 |  |      |    1154             if not devController:
 |    |    |   1156             self._deviceControllers[name] = devController
||      |     < xenstore/xstransact.py:<lambda>
||    1158         return self._deviceControllers[name]
 |    |    |  < XendDomainInfo.py:getDeviceController
 |    |  |   |  737                         configs = 
controller.configurations()
 |    |    |  > server/DevController.py:configurations
 |    |    |   216         return map(self.configuration, self.deviceIDs())
  |   354             if t.commit():
|    |    |   > server/DevController.py:deviceIDs
|    | |    |       |    > xenstore/xstransact.py:commit
||        368         fe = self.backendRoot()
 | |      | |         28         if not self.in_transaction:
 | |    |> server/DevController.py:backendRoot
 |    |    |    |     | 476         from xen.xend.XendDomain import DOM0_ID
 |    ||     |      | 477         from xen.xend.xenstore.xsutil import 
GetDomainPath
 |   |  30         self.in_transaction = False
 | |       ||        | 478         return "%s/backend/%s/%s" % 
(GetDomainPath(DOM0_ID),
||        ||  31         rc = xshandle().transaction_end(self.transaction, 
False)
 |     |    | > xenstore/xsutil.py:GetDomainPath
 |    |    |    |  |   26     return xshandle().get_domain_path(domid)
 |    |    |  > xenstore/xsutil.py:xshandle
 |   |    |    |   > xenstore/xsutil.py:xshandle
 |     |     ||        |   |    |     15     if not xs_handle:
  15     if not xs_handle:
|    |    |    ||    |        | |     20     return xs_handle
 |    |    |    |   < xenstore/xsutil.py:xshandle
   20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xsutil.py:GetDomainPath
|    |    |    | > XendDomainInfo.py:getDomid
|  |   |       |    |    |   32         self.transaction = "0"
|    |    |    |   33         return rc
|  |   |      | |   789         return self.domid
 |    |    |    | < XendDomainInfo.py:getDomid
 |  | < xenstore/xstransact.py:commit
 |   |    |    |< server/DevController.py:backendRoot
 |      |    |    369         if transaction:
||      |      | |    372             return map(int, xstransact.List(fe))
    350     while True:
|   |  |    |    > xenstore/xstransact.py:List
|    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |> xenstore/xstransact.py:complete
|    |    |    | 350     while True:
|    |    |    | 351         t = xstransact(path)
|    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |   14         assert path is not None
|    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
   |    |     351         t = xstransact(path)
|    |    |    |  > xenstore/xstransact.py:__init__
|    |    |    |    14         assert path is not None
|    |    |    |    16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    19         self.path = path.rstrip("/")
|    |    |    |    20         self.transaction = xshandle().transaction_start()
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    21         self.in_transaction = True
|    |    |    |  < xenstore/xstransact.py:__init__
|    |    |    |  352         try:
|    |    |    |  353             result = f(t)
|    |    |    |  > xenstore/xstransact.py:<lambda>
|    |    |    |   319         return complete(path, lambda t: t.list(*args))
|    |    |    |   > xenstore/xstransact.py:list
|    |    |    |    129         if len(args) == 0:
|    |    |    |    130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |    123                 for t in threads:
|    |    |    |    125                 runningThreads = len([t for t in 
threads if t.isAlive()])
|    |    |    |    125                 runningThreads = len([t for t in 
threads if t.isAlive()])
|    |    |    |    121         while runningThreads > 0:
|    |    |    |    122             try:
|    |    |    |    123                 for t in threads:
|    |    |    |    124                     t.join(1.0)
|    |    |    |    131             if ret is None:
|    |    |    |    132                 return []
|    |    |    |   < xenstore/xstransact.py:list
|    |    |    |  < xenstore/xstransact.py:<lambda>
|    |    |    |  354             if t.commit():
|    |    |    |  > xenstore/xstransact.py:commit
|    |    |    |    28         if not self.in_transaction:
|    |    |    |    30         self.in_transaction = False
|    |    |    |    31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    32         self.transaction = "0"
|    |    |    |    33         return rc
|    |    |    |  < xenstore/xstransact.py:commit
|    |    |    |  350     while True:
|    |    |    |  351         t = xstransact(path)
| |    |    |    |    21         self.in_transaction = True
|    |    |    |  < xenstore/xstransact.py:__init__
|    |       |    ||    |  > xenstore/xstransact.py:__init__
 |       ||    352         try:
|    |    |   |    |    353             result = f(t)
 |   14         assert path is not None
| |    |      |    | |    |    |    16         self.in_transaction = False # 
Set this temporarily -- if this
 | > xenstore/xstransact.py:<lambda>
|    |    |    |   333         return complete(path, lambda t: t.gather(*args))
|    |    |    |   > xenstore/xstransact.py:gather
|    |    |    |    169         if len(args) and type(args[0]) != tuple:
|    |    |    |    171         ret = []
|    |    |    |    172         for tup in args:
|    |    |    |    173             if len(tup) == 2:
|    |    |    |    174                 (key, fn) = tup
|    |    |    |    175                 defval = None
|    |    |    |    179             val = self._read(key)
|    |    |    |    > xenstore/xstransact.py:_read
|    |    |    |      44         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      45         try:
|    |    |    |      46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
    |    |    |    19         self.path = path.rstrip("/")
|    |    |    |      20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_read
|    |    |    |    185             if val is None:
|    |    |    |    188                 val = fn(val)
|    |    |    |    189             ret.append(val)
|    |    |    |    172         for tup in args:
|    |    |    |    173             if len(tup) == 2:
|    |    |    |    174                 (key, fn) = tup
|    |    |    |    175                 defval = None
|    |    |    |    179             val = self._read(key)
|    |    |    |    > xenstore/xstransact.py:_read
|    |    |    |      44         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      45         try:
|    |    |    |      46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_read
|    |    |    |    185             if val is None:
|    |    |    |    188                 val = fn(val)
|    |    |    |    189             ret.append(val)
|    |    |    |    172         for tup in args:
|    |    |    |    173             if len(tup) == 2:
|    |    |    |    174                 (key, fn) = tup
|    |    |    |    175                 defval = None
|    |    |    |    179             val = self._read(key)
|    |    |    |    > xenstore/xstransact.py:_read
|    |    |    |      44         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      45         try:
|    |    |    |      46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |      21         self.in_transaction = True
|    |    |    |    < xenstore/xstransact.py:__init__
|    |    |    |    352         try:
|    |    |    |    353             result = f(t)
|    |    |    |    > xenstore/xstransact.py:<lambda>
|    |    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |    |> xenstore/xstransact.py:list
|    |    |    |    | 129         if len(args) == 0:
|    |    |    |    | 130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    | 131             if ret is None:
|    |    |    |    | 132                 return []
|    |    |    |    |< xenstore/xstransact.py:list
|    |    |    |    < xenstore/xstransact.py:<lambda>
|    |    |    |    354             if t.commit():
|    |    |    |    > xenstore/xstransact.py:commit
|    |    |    |      28         if not self.in_transaction:
|    |    |    |      30         self.in_transaction = False
|    |    |    |      31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |      32         self.transaction = "0"
|    |    |    |      33         return rc
|    |    |    |    < xenstore/xstransact.py:commit
|    |    |    |    355                 return result
|    |    |    |   < xenstore/xstransact.py:complete
|    |    |    |   > xenstore/xstransact.py:__del__
|    |    |    |     24         if self.in_transaction:
|    |    |    |   < xenstore/xstransact.py:__del__
|    |    |    |  < xenstore/xstransact.py:List
|    |    |    | < server/DevController.py:deviceIDs
|    |    |    |< server/DevController.py:configurations
|    |    |     738                         for config in configs:
|    |    |     747                 if not found:
|    |    |     748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |    |> XendConfig.py:all_devices_sxpr
|    |    |    | 914         sxprs = []
|    |    |    | 915         pci_devs = []
|    |    |    | 916         for dev_type, dev_info in self['device'].values():
|    |    |    | 917             if dev_type == 'pci': # special case for pci 
devices
|    |    |    | 920                 sxpr =  self.device_sxpr(dev_type = 
dev_type,
|    |    |    | 921                                          dev_info = 
dev_info)
|    |    |    | > XendConfig.py:device_sxpr
|    |    |    |  898         sxpr = []
|    |    |    |  899         if dev_uuid != None and dev_uuid in 
self['device']:
|    |    |    |  902         if dev_type == None or dev_info == None:
|    |    |    |  906         sxpr.append(dev_type)
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  908         sxpr += config
|    |    |    |  910         return sxpr
|    |    |    | < XendConfig.py:device_sxpr
|    |    |    | 922                 sxprs.append((dev_type, sxpr))
|    |    |    | 916         for dev_type, dev_info in self['device'].values():
|    |    |    | 926         if pci_devs:
|    |    |    | 934         return sxprs
|    |    |    |< XendConfig.py:all_devices_sxpr
|    |    |     749                         if dev_type == cls:
|    |    |     748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |     730             for cls in XendDevices.valid_devices():
|    |    |     731                 found = False
|    |    |     734                 if domain:
|    |    |     735                     try:
|    |    |     736                         controller = 
domain.getDeviceController(cls)
|    |    |    |> XendDomainInfo.py:getDeviceController
|    |    |    |1152         if name not in self._deviceControllers:
|    |    |    |1158         return self._deviceControllers[name]
|    |    |    |< XendDomainInfo.py:getDeviceController
|    |    |     737                         configs = 
controller.configurations()
|    |    |    |> server/DevController.py:configurations
|    |    |    | 216         return map(self.configuration, self.deviceIDs())
|    |    |    | > server/DevController.py:deviceIDs
|    |    |    |  368         fe = self.backendRoot()
|    |    |    |  > server/DevController.py:backendRoot
|    |    |    |   476         from xen.xend.XendDomain import DOM0_ID
|    |    |    |   477         from xen.xend.xenstore.xsutil import 
GetDomainPath
|    |    |    |   478         return "%s/backend/%s/%s" % 
(GetDomainPath(DOM0_ID),
|    |    |    |   > xenstore/xsutil.py:GetDomainPath
|    |    |    |     26     return xshandle().get_domain_path(domid)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xstransact.py:_read
|    |    |    |   185             if val is None:
|    |    |    |   188                 val = fn(val)
|    |    |    |   189             ret.append(val)
|    |    |    |   172         for tup in args:
|    |    |    |   173             if len(tup) == 2:
|    |    |    |   174                 (key, fn) = tup
|    |    |    |   175                 defval = None
|    |    |    |   179             val = self._read(key)
|    |    |    |   > xenstore/xstransact.py:_read
|    |    |    |     44         path = self.prependPath(key)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     284             return self.path + '/' + key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |     45         try:
|    |    |    |     46             return xshandle().read(self.transaction, 
path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xstransact.py:_read
|    |    |    |   185             if val is None:
|    |    |    |   188                 val = fn(val)
|    |    |    |   189             ret.append(val)
|    |    |    |   172         for tup in args:
|    |    |    |   190         if len(ret) == 1:
|    |    |    |   192         return ret
|    |    |    |  < xenstore/xstransact.py:gather
|    |    |    | < xenstore/xstransact.py:<lambda>
|    |    |    | 354             if t.commit():
|    |    |    | > xenstore/xstransact.py:commit
|    |    |    |   28         if not self.in_transaction:
|    |    |    |   30         self.in_transaction = False
|    |    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   32         self.transaction = "0"
|    |    |    |   33         return rc
|    |    |    | < xenstore/xstransact.py:commit
|    |    |    | 350     while True:
|    |    |    | 351         t = xstransact(path)
|    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |   14         assert path is not None
|    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|    |    |    | < xenstore/xstransact.py:__init__
|    |    |    | 352         try:
|    |    |    | 353             result = f(t)
|    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    |  333         return complete(path, lambda t: t.gather(*args))
|    |    |    |  > xenstore/xstransact.py:gather
|    |    |    |   169         if len(args) and type(args[0]) != tuple:
|    |    |    |   171         ret = []
|    |    |    |   172         for tup in args:
|    |    |    |   173             if len(tup) == 2:
|    |    |    |   174                 (key, fn) = tup
|    |    |    |   175                 defval = None
|    |    |    |   179             val = self._read(key)
|    |    |    |   > xenstore/xstransact.py:_read
|    |    |    |     44         path = self.prependPath(key)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     284             return self.path + '/' + key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |     45         try:
|    |    |    |     46             return xshandle().read(self.transaction, 
path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xsutil.py:GetDomainPath
|    |    |    |   > XendDomainInfo.py:getDomid
|    |    |    |    789         return self.domid
|    |    |    |   < XendDomainInfo.py:getDomid
|    |    |    |  < server/DevController.py:backendRoot
|    |    |    |  369         if transaction:
|    |    |    |  372             return map(int, xstransact.List(fe))
|    |    |    |  > xenstore/xstransact.py:List
|    |    |    |   319         return complete(path, lambda t: t.list(*args))
|    |    |    |   > xenstore/xstransact.py:complete
|    |    |    |    350     while True:
|    |    |    |    351         t = xstransact(path)
|    |    |    |    > xenstore/xstransact.py:__init__
|    |    |    |      14         assert path is not None
|    |    |    |      16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |      19         self.path = path.rstrip("/")
|    |    |    |      20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |      21         self.in_transaction = True
|    |    |    |    < xenstore/xstransact.py:__init__
|    |    |    |    352         try:
|    |    |    |    353             result = f(t)
|    |    |    |    > xenstore/xstransact.py:<lambda>
|    |    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |    |> xenstore/xstransact.py:list
|    |    |    |    | 129         if len(args) == 0:
|    |    |    |    | 130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    | 131             if ret is None:
|    |    |    |    | 134                 return ret
|    |    |    |    |< xenstore/xstransact.py:list
|    |    |    |    < xenstore/xstransact.py:<lambda>
|    |    |    |    354             if t.commit():
|    |    |    |    > xenstore/xstransact.py:commit
|    |    |    |      28         if not self.in_transaction:
|    |    |    |      30         self.in_transaction = False
|    |    |    |      31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |      32         self.transaction = "0"
|    |    |    |      33         return rc
|    |    |    |    < xenstore/xstransact.py:commit
|    |    |    |    355                 return result
|    |    |    |   < xenstore/xstransact.py:complete
|    |    |    |   > xenstore/xstransact.py:__del__
|    |    |    |     24         if self.in_transaction:
|    |    |    |   < xenstore/xstransact.py:__del__
|    |    |    |  < xenstore/xstransact.py:List
|    |    |    | < server/DevController.py:deviceIDs
|    |    |    | > server/DevController.py:configuration
|    |    |    |  223         configDict = self.getDeviceConfiguration(devid)
|    |    |    |  > server/blkif.py:getDeviceConfiguration
|    |    |    |   116         config = 
DevController.getDeviceConfiguration(self, devid)
|    |    |    |   > server/DevController.py:getDeviceConfiguration
|    |    |    |    253         backdomid = 
xstransact.Read(self.frontendPath(devid), "backend-id")
|    |    |    |    > server/DevController.py:frontendPath
|    |    |    |     468         return "%s/%d" % (self.frontendRoot(), devid)
|    |    |    |    |> server/DevController.py:frontendRoot
|    |    |    |    | 472         return "%s/device/%s" % 
(self.vm.getDomainPath(), self.deviceClass)
|    |    |    |    | > XendDomainInfo.py:getDomainPath
|    |    |    |    |  800         return self.dompath
|    |    |    |    | < XendDomainInfo.py:getDomainPath
|    |    |    |    |< server/DevController.py:frontendRoot
|    |    |    |    < server/DevController.py:frontendPath
|    |    |    |    > xenstore/xstransact.py:Read
|    |    |    |     297         return complete(path, lambda t: t.read(*args))
|    |    |    |    |> xenstore/xstransact.py:complete
|    |    |    |    | 350     while True:
|    |    |    |    | 351         t = xstransact(path)
|    |    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |    |   14         assert path is not None
|    |    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |    |   20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |    | < xenstore/xstransact.py:_read
|    |    |    |    | 185             if val is None:
|    |    |    |    | 188                 val = fn(val)
|    |    |    |    | 189             ret.append(val)
|    |    |    |    | 172         for tup in args:
|    |    |    |    | 173             if len(tup) == 2:
|    |    |    |    | 174                 (key, fn) = tup
|    |    |    |    | 175                 defval = None
|    |    |    |    | 179             val = self._read(key)
|    |    |    |    | > xenstore/xstransact.py:_read
|    |    |    |    |   44         path = self.prependPath(key)
|    |    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |    |   283         if self.path:
|    |    |    |    |   284             return self.path + '/' + key
|    |    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |    |   45         try:
|    |    |    |    |   46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |    | < xenstore/xstransact.py:_read
|    |    |    |    | 185             if val is None:
|    |    |    |    | 188                 val = fn(val)
|    |    |    |    | 189             ret.append(val)
|    |    |    |    | 172         for tup in args:
|    |    |    |    | 173             if len(tup) == 2:
|    |    |    |    | 174                 (key, fn) = tup
|    |    |    |    | 175                 defval = None
|    |    |    |    | 179             val = self._read(key)
|    |    |    |    | > xenstore/xstransact.py:_read
|    |    |    |    |   44         path = self.prependPath(key)
|    |    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |    |   283         if self.path:
|    |    |    |    |   284             return self.path + '/' + key
|    |    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |    |   45         try:
|    |    |    |    |   46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |    |   21         self.in_transaction = True
|    |    |    |    | < xenstore/xstransact.py:__init__
|    |    |    |    | 352         try:
| |    |    |    |    | 353             result = f(t)
 |    |    |    |      | > xenstore/xstransact.py:<lambda>
||     |    |    |< xenstore/xstransact.py:_read
 |    |    |    |    | 185             if val is None:
 |    |    |    |  |   | 188                 val = fn(val)
 |      |    |    |   |    |    |  297         return complete(path, lambda t: 
t.read(*args))
 |    |    | |    |    | > xenstore/xstransact.py:read
 189             ret.append(val)
| |    |    |    |    |   59         if len(args) == 0:
 |    |      |    |  |     | |   61         if len(args) == 1:
 |      |    |    |    |   62             return self._read(args[0])
|    |    |    |    |  > xenstore/xstransact.py:_read
|  |    |  172         for tup in args:
 |     |  |    |    |      |   173             if len(tup) == 2:
 |    |    |    |    |   174                 (key, fn) = tup
||       |    |    |    |    |   175                 defval = None
 | |    |    |    |     44         path = self.prependPath(key)
 |  |   179             val = self._read(key)
 |     |    |   |      |    |    |    > xenstore/xstransact.py:_read
||    |        | |    |    |      44         path = self.prependPath(key)
 |    |    |    |   > xenstore/xstransact.py:prependPath
 |    |    |    |    | |      | 283         if self.path:
  |> xenstore/xstransact.py:prependPath
| |    |    |    |       |    |    ||    | 283         if self.path:
 |    |    |      |    |    | 284             return self.path + '/' + key
 |    |    |    |    |    |< xenstore/xstransact.py:prependPath
||    |    |    |    |      45         try:
 |    |    |    |    |      46             return 
xshandle().read(self.transaction, path)
 |    |      |    |    |    |> xenstore/xsutil.py:xshandle
||  284             return self.path + '/' + key
|      | |    |    |        |    |    |  15     if not xs_handle:
||        |  |    |< xenstore/xstransact.py:prependPath
 |    |    | |    |      |    |    |    45         try:
 |      |    |     | |  20     return xs_handle
 |    |    |    |    |        46             return 
xshandle().read(self.transaction, path)
||      |      < xenstore/xsutil.py:xshandle
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |      15     if not xs_handle:
|  |      ||      |    |     | |    |        20     return xs_handle
  |  |    |      |< xenstore/xstransact.py:_read
 |   |       |  |      < xenstore/xsutil.py:xshandle
 |    |    |    185             if val is None:
|    |    |    |    ||    |       188                 val = fn(val)
||      |  |       | |  < xenstore/xstransact.py:_read
    | |      |   |     189             ret.append(val)
||        |  |      | < xenstore/xstransact.py:read
||    |    |      |    |  172         for tup in args:
 |    |    |    |    | 190         if len(ret) == 1:
 |    |    |    |    | 192         return ret
||    |    |    |    |< xenstore/xstransact.py:gather
 |      | |    |    |    < xenstore/xstransact.py:<lambda>
< xenstore/xstransact.py:<lambda>
| |    |     |    |   |    |    354             if t.commit():
   ||     354             if t.commit():
 |  |   |      |    |    |      |> xenstore/xstransact.py:commit
 |   > xenstore/xstransact.py:commit
 |    |    |    |      28         if not self.in_transaction:
  | |    |    |    |    |      30         self.in_transaction = False
 |     |  |    |    |      31         rc = 
xshandle().transaction_end(self.transaction, False)
 |    |    |    |    |> xenstore/xsutil.py:xshandle
 |    |    |    28         if not self.in_transaction:
 |   |    |  15     if not xs_handle:
 |      ||     |    |    |    20     return xs_handle
 |    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |  30         self.in_transaction = False
|    |    |    |      31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |      32         self.transaction = "0"
|    |    |    |      33         return rc
| |    |       ||      |      ||     < xenstore/xstransact.py:commit
  |    32         self.transaction = "0"
 |      ||      |      |    350     while True:
||    |    |      |     |    351         t = xstransact(path)
  33         return rc
| |      |   |      ||        ||      > xenstore/xstransact.py:__init__
 |  < xenstore/xstransact.py:commit
 |   |    |       ||      14         assert path is not None
 |    |    |    |     16         self.in_transaction = False # Set this 
temporarily -- if this
 |      |    |    |     19         self.path = path.rstrip("/")
||        ||     |    |     20         self.transaction = 
xshandle().transaction_start()
 |   355                 return result
 |     |  |       | |    |    > xenstore/xsutil.py:xshandle
 |      |    |    |      15     if not xs_handle:
||    |    |    |        20     return xs_handle
 |  < xenstore/xstransact.py:complete
 |   |    |    |    < xenstore/xsutil.py:xshandle
   |    |    |    > xenstore/xstransact.py:__del__
|    |    |    |     24         if self.in_transaction:
|    |    |    |   < xenstore/xstransact.py:__del__
|    |    |    |  < xenstore/xstransact.py:Read
|    |    |    |  254         if backdomid is None:
|    |    |    |  257         return {'backend': int(backdomid)}
|    |    |    | < server/DevController.py:getDeviceConfiguration
|    |    |    | 117         devinfo = self.readBackend(devid, 'dev', 'type', 
'params', 'mode',
|    |    |    | 118                                    'uuid')
|    |    |    | > server/DevController.py:readBackend
|    |    |    |  354         frontpath = self.frontendPath(devid)
|    |    |    |  > server/DevController.py:frontendPath
|    |    |    |   468         return "%s/%d" % (self.frontendRoot(), devid)
|    |    |    |   > server/DevController.py:frontendRoot
|    |    |    |    472         return "%s/device/%s" % 
(self.vm.getDomainPath(), self.deviceClass)
|    |    |    |    > XendDomainInfo.py:getDomainPath
|    |    |    |     800         return self.dompath
|    |    |    |    < XendDomainInfo.py:getDomainPath
|    |    |    |   < server/DevController.py:frontendRoot
|    |    |    |  < server/DevController.py:frontendPath
|    |    |    |  355         backpath = xstransact.Read(frontpath, "backend")
|    |    |    |  > xenstore/xstransact.py:Read
|    |    |    |   297         return complete(path, lambda t: t.read(*args))
|    |    |    |   > xenstore/xstransact.py:complete
|    |    |    |    350     while True:
|    |    |    |    351         t = xstransact(path)
|    |    |    |    > xenstore/xstransact.py:__init__
|    |    |    |      14         assert path is not None
|    |    |    |      16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |      19         self.path = path.rstrip("/")
|    |    |    |      20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |      21         self.in_transaction = True
|    |    |    |    < xenstore/xstransact.py:__init__
|    |    |    |    352         try:
|    |    |    |    353             result = f(t)
|    |    | |    |    |    |      21         self.in_transaction = True
 |    |    |    |    < xenstore/xstransact.py:__init__
  | |      | > xenstore/xstransact.py:<lambda>
 |    |    |    |      333         return complete(path, lambda t: 
t.gather(*args))
 | |      | |        352         try:
||    |    |      |     353             result = f(t)
 |    |    |    |    |> xenstore/xstransact.py:<lambda>
 |    |    |    |    | 297         return complete(path, lambda t: 
t.read(*args))
||     > xenstore/xstransact.py:gather
 |      |    |    |    |    |    |    ||  169         if len(args) and 
type(args[0]) != tuple:
 | > xenstore/xstransact.py:read
 |    |    |    |    |   59         if len(args) == 0:
 |  |      | |       |  |     |    |   171         ret = []
 | |   61         if len(args) == 1:
 |    |      |    |    |    |  172         for tup in args:
||    |    |    |    |  173             if len(tup) == 2:
 |    |    |      |    |  174                 (key, fn) = tup
 |    |    |    |    |  175                 defval = None
||      |    |    |      |  179             val = self._read(key)
||   62             return self._read(args[0])
 |    |    |    |    |    |    |    |  > xenstore/xstransact.py:_read
 |    |    |    |    |     44         path = self.prependPath(key)
 |    |    |    |    |    > xenstore/xstransact.py:prependPath
 ||      > xenstore/xstransact.py:_read
 | |    |    |    |     283         if self.path:
 |    |    |    |    |     284             return self.path + '/' + key
 |    |    |     ||      |   |    |      < xenstore/xstransact.py:prependPath
 |    |    |    |    |     45         try:
||       44         path = self.prependPath(key)
 |   |    |    |    |     46             return 
xshandle().read(self.transaction, path)
 |      |    |    |    |    |> xenstore/xsutil.py:xshandle
||    |    |    |      |    |  15     if not xs_handle:
 |    |    |     ||    |    |  20     return xs_handle
 |    |    |       ||        ||    > xenstore/xstransact.py:prependPath
 |       |< xenstore/xsutil.py:xshandle
|    |    |    |    | 283         if self.path:
|    |    |    |    |     284             return self.path + '/' + key
|    |    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |    |     45         try:
|    |    |    |    |     46             return 
xshandle().read(self.transaction, path)
|    |    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |    |      15     if not xs_handle:
|    |    |    |    |      20     return xs_handle
|    |    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |    |   < xenstore/xstransact.py:_read
|    |  |   |    |    |   185             if val is None:
 |    |    |     |  |      |  |  188                 val = fn(val)
 |    |    |    |    |   189             ret.append(val)
 |    |    |    |    |   172         for tup in args:
 |    |    |    |    |   173             if len(tup) == 2:
 |    |    |    ||     |   174                 (key, fn) = tup
 |    |      ||     |    |   175                 defval = None
|    |    |    |    |   179             val = self._read(key)
|  < xenstore/xstransact.py:_read
 |   |      |     ||    |     > xenstore/xstransact.py:_read
  |    |    |   |    |  < xenstore/xstransact.py:read
 | |     |     |    | |      |  44         path = self.prependPath(key)
 |      |    |    |  |   | < xenstore/xstransact.py:<lambda>
 |    |    | > xenstore/xstransact.py:prependPath
 |       |    |  354             if t.commit():
||      |    |    |    |    |      |  > xenstore/xstransact.py:commit
||   283         if self.path:
 |      |    |   |    |     |    ||    |   284             return self.path + 
'/' + key
 |    28         if not self.in_transaction:
 |    |   |    |       ||    |    30         self.in_transaction = False
 |    |      | |    |      < xenstore/xstransact.py:prependPath
||    |      |    |    |   45         try:
  | |    31         rc = xshandle().transaction_end(self.transaction, False)
 |   |     |    |    |  |      |  > xenstore/xsutil.py:xshandle
 |    |    |    |    |    15     if not xs_handle:
 |    |    |    | |   46             return xshandle().read(self.transaction, 
path)
 |    |    |    20     return xs_handle
 |    |    |    |    |  |      < xenstore/xsutil.py:xshandle
|    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|   |    |    |     |  |      |    ||      32         self.transaction = "0"
 |    |   |    |    |    |  < xenstore/xsutil.py:xshandle
  33         return rc
|    |    |    |    | < xenstore/xstransact.py:commit
|    |    |    |    | 355                 return result
|    |    |    |    |< xenstore/xstransact.py:complete
|    |    |    |    |> xenstore/xstransact.py:__del__
|    |    |    |    |  24         if self.in_transaction:
|    |    |    |    |< xenstore/xstransact.py:__del__
|    |    |    |    < xenstore/xstransact.py:Read
|    |    |    |    356         if backpath:
|    |    |    |    357             return xstransact.Read(backpath, *args)
|    |    |    |    > xenstore/xstransact.py:Read
|    |    |    |     297         return complete(path, lambda t: t.read(*args))
|    |    |    |    |> xenstore/xstransact.py:complete
|    |    |    |    | 350     while True:
|    |    |    |    | 351         t = xstransact(path)
|    |    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |    |   14         assert path is not None
|    |    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |    |   20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |    | < xenstore/xstransact.py:_read
|    |    |    |    | 185             if val is None:
|    |    |    |    | 188                 val = fn(val)
|    |    |    |    | 189             ret.append(val)
|    |    |    |    | 172         for tup in args:
|    |    |    |    | 173             if len(tup) == 2:
| |      |    |    |    | 174                 (key, fn) = tup
 | |      |    |    |    | | 175                 defval = None
 |    |    |    |    | 179             val = self._read(key)
 |     |  |    |    |    | > xenstore/xstransact.py:_read
 |      |    |    |    |   44         path = self.prependPath(key)
||    |   21         self.in_transaction = True
 |     |  |     |    |  > xenstore/xstransact.py:prependPath
 |    |    |  |   |    |   283         if self.path:
 |    |    |    |    |   284             return self.path + '/' + key
 |    |    |    |  |       |  < xenstore/xstransact.py:prependPath
 |    |    |    |    |   45         try:
||    |    |    |      |   46             return 
xshandle().read(self.transaction, path)
< xenstore/xstransact.py:__init__
|    |    |    | |    |  > xenstore/xsutil.py:xshandle
 |     |  |    |    |    |   15     if not xs_handle:
 |    |    |    |    |   20     return xs_handle
 |    |    |    |    | < xenstore/xsutil.py:xshandle
 |    |    |  352         try:
|    |    |    |    | 353             result = f(t)
|    |    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    |    |  297         return complete(path, lambda t: 
t.read(*args))
|    |    |    |    |  > xenstore/xstransact.py:read
|    |    |    |    |    59         if len(args) == 0:
|    |    |    |    |    61         if len(args) == 1:
|    |    |    |    |    63         ret = []
|    |    |    |    |    64         for key in args:
|    |    |    |    |    65             ret.append(self._read(key))
|    |    |    |    |   > xenstore/xstransact.py:_read
|    |    |    |    |     44         path = self.prependPath(key)
|    |    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |    |     283         if self.path:
|    |    |    |    |     284             return self.path + '/' + key
|    |    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |    |     45         try:
|    |    |    |    |     46             return 
xshandle().read(self.transaction, path)
|    |    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |    |      15     if not xs_handle:
|    |    |    |    |      20     return xs_handle
|    |    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |    |   < xenstore/xstransact.py:_read
|    | |    |      |     ||     < xenstore/xstransact.py:_read
 |    |    |    | |        ||     |   185             if val is None:
  64         for key in args:
|    |    |    ||    |    |    188                 val = fn(val)
  ||      |    |    |      |  189             ret.append(val)
||      |    |    |      |  172         for tup in args:
||    |   65             ret.append(self._read(key))
 |     |    |    |    |  173             if len(tup) == 2:
 |    |  |   |    |    |     |     174                 (key, fn) = tup
 |    |    |    |    |   175                 defval = None
||    > xenstore/xstransact.py:_read
 |  |      |    |    |   179             val = self._read(key)
 | |       ||    |    |    |   > xenstore/xstransact.py:_read
 |      |    |   |    |      |     44         path = self.prependPath(key)
||       44         path = self.prependPath(key)
 |    ||      |    |    |    > xenstore/xstransact.py:prependPath
 |    |    |    |    |    | 283         if self.path:
 | |      |    |    |    |    | 284             return self.path + '/' + key
 | |      |  |   |        |    |    |< xenstore/xstransact.py:prependPath
||    |    |> xenstore/xstransact.py:prependPath
 |      |    |      45         try:
 |    |    |    |    |      46             return 
xshandle().read(self.transaction, path)
||    |    |    |    |    |> xenstore/xsutil.py:xshandle
 |    |    |    |   |    |    |  15     if not xs_handle:
 |    |    |    |    |    |  20     return xs_handle
 |    |    |    |    |    |< xenstore/xsutil.py:xshandle
  |    |     283         if self.path:
|    |    |    |    |     284             return self.path + '/' + key
|    |    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |    |     45         try:
|    |    |    |    |     46             return 
xshandle().read(self.transaction, path)
|    |    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |    |      15     if not xs_handle:
|    |    |    |    |      20     return xs_handle
|    |    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |    |   < xenstore/xstransact.py:_read
| |      |    |    |    |   185             if val is None:
 |    |  |   |    |    |     |     188                 val = fn(val)
||    |    |    |    |   189             ret.append(val)
 |    |    |    |    |   172         for tup in args:
 |    |    |    |    |   190         if len(ret) == 1:
  ||      |  < xenstore/xstransact.py:_read
 |   |    |    |   192         return ret
 |    |    |    |    | < xenstore/xstransact.py:gather
 |  |     |    |    |    |< xenstore/xstransact.py:<lambda>
 |  |   |    |    |       354             if t.commit():
 |     |    |    |    |> xenstore/xstransact.py:commit
||     |     64         for key in args:
 |    |    |    |   |  28         if not self.in_transaction:
 |    |    | |    |     |      |  30         self.in_transaction = False
||        |   |  65             ret.append(self._read(key))
 |    |    |    |    | > xenstore/xstransact.py:_read
|    |    |    |    |   44         path = self.prependPath(key)
|    |    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |    |   283         if self.path:
|    |    |    |    |   284             return self.path + '/' + key
|    |    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |    |   45         try:
|    |    |    |    |   46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |  31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |    | < xenstore/xstransact.py:_read
|    |    |    |    |  64         for key in args:
|    |    |    |    |  65             ret.append(self._read(key))
|    |    |    |    | > xenstore/xstransact.py:_read
|    |    |    |    |   44         path = self.prependPath(key)
|    |    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |    |   283         if self.path:
|    |    |    |    |   284             return self.path + '/' + key
|    |    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |    |   45         try:
|    |    |    |    |   46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |    | < xenstore/xstransact.py:_read
|    |    |    |    |  64         for key in args:
|    |    |    |    |  65             ret.append(self._read(key))
|    |    |    |    | > xenstore/xstransact.py:_read
|    |    |    |    |   44         path = self.prependPath(key)
|    |    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |    |   283         if self.path:
|    |    |    |    |   284             return self.path + '/' + key
|    |    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |    |   45         try:
|    |    |    |    |   46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |    | < xenstore/xstransact.py:_read
|    |    |    |    |  64         for key in args:
|    |    |    |    |  66         return ret
|    |    |    |    |< xenstore/xstransact.py:read
|    |    |    |    < xenstore/xstransact.py:<lambda>
|    |    |    |    354             if t.commit():
|    |    |    |    > xenstore/xstransact.py:commit
|    |    |    |      28         if not self.in_transaction:
|    |    |    |      30         self.in_transaction = False
|    |    |    |      31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |      32         self.transaction = "0"
|    |    |    |      33         return rc
|    |    |    |    < xenstore/xstransact.py:commit
|    |    |    |    350     while True:
|    |    |    |    351         t = xstransact(path)
|    |    |    |    > xenstore/xstransact.py:__init__
|    |    |    |      14         assert path is not None
|    |    |    |      16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |      19         self.path = path.rstrip("/")
|    |    |    |      20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |      21         self.in_transaction = True
|    |    |    |    < xenstore/xstransact.py:__init__
|    |    |    |    352         try:
|    |    |    |    353             result = f(t)
|    |    |    |    > xenstore/xstransact.py:<lambda>
|    |    |    |     333         return complete(path, lambda t: 
t.gather(*args))
|    |    |    |    |> xenstore/xstransact.py:gather
|    |    |    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    |    |    | 171         ret = []
|    |    |    |    | 172         for tup in args:
|    |    |    |    | 173             if len(tup) == 2:
|    |    |    |    | 174                 (key, fn) = tup
|    |    |    |    | 175                 defval = None
|    |    |    |    | 179             val = self._read(key)
|    |    |    |    | > xenstore/xstransact.py:_read
|    |    |    |    |   44         path = self.prependPath(key)
|    |    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |    |   283         if self.path:
|    |    |    |    |   284             return self.path + '/' + key
|    |    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |    |   45         try:
|    |    |    |    |   46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |    | < xenstore/xstransact.py:_read
|    |    |    |    | 185             if val is None:
|    |    |    |    | 188                 val = fn(val)
|    |    |    |    | 189             ret.append(val)
|    |    |    |    | 172         for tup in args:
|    |    |    |    | 173             if len(tup) == 2:
|    |    |    |    | 174                 (key, fn) = tup
|    |    |    |    | 175                 defval = None
|    |    |    |    | 179             val = self._read(key)
|    |    |    |    | > xenstore/xstransact.py:_read
|    |    |    |    |   44         path = self.prependPath(key)
|    |    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |    |   283         if self.path:
|    |    |    |    |   284             return self.path + '/' + key
|    |    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |    |   45         try:
|    |    |    |    |   46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |    | < xenstore/xstransact.py:_read
|    |    |    |    | 185             if val is None:
|    |    |    |    | 188                 val = fn(val)
|    |    |    |    | 189             ret.append(val)
|    |    |    |    | 172         for tup in args:
|    |    |    |    | 173             if len(tup) == 2:
|    |    |    |    | 174                 (key, fn) = tup
|    |    |    |    | 175                 defval = None
|    |    |    |    | 179             val = self._read(key)
|    |    |    |    | > xenstore/xstransact.py:_read
|    |    |    |    |   44         path = self.prependPath(key)
|    |    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |    |   283         if self.path:
|    |    |    |    |   284             return self.path + '/' + key
|    |    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |    |   45         try:
|    |    |    |    |   46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |    |   32         self.transaction = "0"
|    |    |    |    |   33         return rc
|    |    |    |    | < xenstore/xstransact.py:commit
|    |    |    |    | 355                 return result
|    |    |    |    |< xenstore/xstransact.py:complete
|    |    |    |    |> xenstore/xstransact.py:__del__
|    |    |    |    |  24         if self.in_transaction:
|    |    |    |    |< xenstore/xstransact.py:__del__
|    |    |    |    < xenstore/xstransact.py:Read
|    |    |    |   < server/DevController.py:readBackend
|    |    |    |   119         dev, typ, params, mode, uuid = devinfo
|    |    |    |   121         if dev:
|    |    |    |   122             dev_type = self.readFrontend(devid, 
'device-type')
|    |    |    |   > server/DevController.py:readFrontend
|    |    |    |    362         return 
xstransact.Read(self.frontendPath(devid), *args)
|    |    |    |    > server/DevController.py:frontendPath
|    |    |    |     468         return "%s/%d" % (self.frontendRoot(), devid)
|    |    |    |    |> server/DevController.py:frontendRoot
|    |    |    |    | 472         return "%s/device/%s" % 
(self.vm.getDomainPath(), self.deviceClass)
|    |    |    |    | > XendDomainInfo.py:getDomainPath
|    |    |    |    |  800         return self.dompath
|    |    |    |    | < XendDomainInfo.py:getDomainPath
|    |    |    |    |< server/DevController.py:frontendRoot
|    |    |    |    < server/DevController.py:frontendPath
|    |    |    |    > xenstore/xstransact.py:Read
|    |    |    |     297         return complete(path, lambda t: t.read(*args))
|    |    |    |    |> xenstore/xstransact.py:complete
|    |    |    |    | 350     while True:
|    |    |    |    | 351         t = xstransact(path)
|    |    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |    |   14         assert path is not None
|    |    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |    |   20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |    |   21         self.in_transaction = True
|    |    |    |    | < xenstore/xstransact.py:__init__
|    |    |    |    | 352         try:
|    |    |    |    | 353             result = f(t)
|    |    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    |    |  297         return complete(path, lambda t: 
t.read(*args))
|    |    |    |    |  > xenstore/xstransact.py:read
|    |    |    |    |    59         if len(args) == 0:
|    |    |    |    |    61         if len(args) == 1:
|    |    |    |    |    62             return self._read(args[0])
|    |    |    |    |   > xenstore/xstransact.py:_read
|    |    |    |    |     44         path = self.prependPath(key)
|    |    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |    |     283         if self.path:
|    |    |    |    |     284             return self.path + '/' + key
|    |    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |    |     45         try:
|    |    |    |    |     46             return 
xshandle().read(self.transaction, path)
|    |    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |    |      15     if not xs_handle:
|    |    |    |    |      20     return xs_handle
|    |    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |    |   < xenstore/xstransact.py:_read
|    |    |    |    |  < xenstore/xstransact.py:read
|    |    |    |    | < xenstore/xstransact.py:<lambda>
|    |    |    |    | 354             if t.commit():
|    |    |    |    | > xenstore/xstransact.py:commit
|    |    |    |    |   28         if not self.in_transaction:
|    |    |    |    |   30         self.in_transaction = False
|    |    |    |    |   31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    |    15     if not xs_handle:
|    |    |    |    |    20     return xs_handle
|    |    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |    |   32         self.transaction = "0"
|    |    |    |    |   33         return rc
|    |    |    |    | < xenstore/xstransact.py:commit
|    |    |    |    | 355                 return result
|    |    |    |    |< xenstore/xstransact.py:complete
|    |    |    |    |> xenstore/xstransact.py:__del__
|    |    |    |    |  24         if self.in_transaction:
|    |    |    |    |< xenstore/xstransact.py:__del__
|    |    |    |    < xenstore/xstransact.py:Read
|    |    |    |   < server/DevController.py:readFrontend
|    |    |    |   123             if dev_type:
|    |    |    |   124                 dev += ':' + dev_type
|    |    |    |   125             config['dev'] = dev
|    |    |    |   126         if typ and params:
|    |    |    |   127             config['uname'] = typ +':' + params
|    |    |    |   128         if mode:
|    |    |    |   129             config['mode'] = mode
|    |    |    |   130         if uuid:
|    |    |    |   131             config['uuid'] = uuid
|    |    |    |   133         return config
|    |    |    |  < server/blkif.py:getDeviceConfiguration
|    |    |    |  224         sxpr = [self.deviceClass]
|    |    |    |  225         for key, val in configDict.items():
|    |    |    |  226             if type(val) == type(list()):
|    |    |    |  230                 sxpr.append([key, val])
|    |    |    |  225         for key, val in configDict.items():
|    |    |    |  226             if type(val) == type(list()):
|    |    |    |  230                 sxpr.append([key, val])
|    |    |    |  225         for key, val in configDict.items():
|    |    |    |  226             if type(val) == type(list()):
|    |    |    |  230                 sxpr.append([key, val])
|    |    |    |  225         for key, val in configDict.items():
|    |    |    |  226             if type(val) == type(list()):
|    |    |    |  230                 sxpr.append([key, val])
|    |    |    |  225         for key, val in configDict.items():
|    |    |    |  226             if type(val) == type(list()):
|    |    |    |  230                 sxpr.append([key, val])
|    |    |    |  225         for key, val in configDict.items():
|    |    |    |  231         return sxpr
|    |    |    | < server/DevController.py:configuration
|    |    |    |< server/DevController.py:configurations
|    |    |     738                         for config in configs:
|    |    |     739                             sxpr.append(['device', config])
|    |    |     740                             found = True
|    |    |     738                         for config in configs:
|    |    |     747                 if not found:
|    |    |     730             for cls in XendDevices.valid_devices():
|    |    |     731                 found = False
|    |    |     734                 if domain:
|    |    |     735                     try:
|    |    |     736                         controller = 
domain.getDeviceController(cls)
|    |    |    |> XendDomainInfo.py:getDeviceController
|    |    |    |1152         if name not in self._deviceControllers:
|    |    |    |1153             devController = 
XendDevices.make_controller(name, self)
|    |    |    | > XendDevices.py:make_controller
|    |    |    |   62         if name in cls.controllers.keys():
|    |    |    |   63             cls.controllers[name].deviceClass = name
|    |    |    |   64             return cls.controllers[name](domain)
|    |    |    |  > server/irqif.py:__init__
|    |    |    |    40         DevController.__init__(self, vm)
|    |    |    |   > server/DevController.py:__init__
|    |    |    |     72         self.vm = vm
|    |    |    |   < server/DevController.py:__init__
|    |    |    |  < server/irqif.py:__init__
|    |    |    | < XendDevices.py:make_controller
|    |    |    |1154             if not devController:
|    |    |    |1156             self._deviceControllers[name] = devController
|    |    |    |1158         return self._deviceControllers[name]
|    |    |    |< XendDomainInfo.py:getDeviceController
|    |    |     737                         configs = 
controller.configurations()
|    |    |    |> server/DevController.py:configurations
|    |    |    | 216         return map(self.configuration, self.deviceIDs())
|    |    |    | > server/DevController.py:deviceIDs
|    |    |    |  368         fe = self.backendRoot()
|    |    |    |  > server/DevController.py:backendRoot
|    |    |    |   476         from xen.xend.XendDomain import DOM0_ID
|    |    |    |   477         from xen.xend.xenstore.xsutil import 
GetDomainPath
|    |    |    |   478         return "%s/backend/%s/%s" % 
(GetDomainPath(DOM0_ID),
|    |    |    |   > xenstore/xsutil.py:GetDomainPath
|    |    |    |     26     return xshandle().get_domain_path(domid)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xstransact.py:_read
|    |    |    |   185             if val is None:
|    |    |    |   188                 val = fn(val)
|    |    |    |   189             ret.append(val)
|    |    |    |   172         for tup in args:
|    |    |    |   173             if len(tup) == 2:
|    |    |    |   174                 (key, fn) = tup
|    |    |    |   175                 defval = None
|    |    |    |   179             val = self._read(key)
|    |    |    |   > xenstore/xstransact.py:_read
|    |    |    |     44         path = self.prependPath(key)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     284             return self.path + '/' + key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |     45         try:
|    |    |    |     46             return xshandle().read(self.transaction, 
path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xstransact.py:_read
|    |    |    |   185             if val is None:
|    |    |    |   188                 val = fn(val)
|    |    |    |   189             ret.append(val)
|    |    |    |   172         for tup in args:
|    |    |    |   190         if len(ret) == 1:
|    |    |    |   192         return ret
|    |    |    |  < xenstore/xstransact.py:gather
|    |    |    | < xenstore/xstransact.py:<lambda>
|    |    |    | 354             if t.commit():
|    |    |    | > xenstore/xstransact.py:commit
|    |    |    |   28         if not self.in_transaction:
|    |    |    |   30         self.in_transaction = False
|    |    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   32         self.transaction = "0"
|    |    |    |   33         return rc
|    |    |    | < xenstore/xstransact.py:commit
|    |    |    | 350     while True:
|    |    |    | 351         t = xstransact(path)
|    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |   14         assert path is not None
|    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|    |    |    | < xenstore/xstransact.py:__init__
|    |    |    | 352         try:
|    |    |    | 353             result = f(t)
|    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    |  333         return complete(path, lambda t: t.gather(*args))
|    |    |    |  > xenstore/xstransact.py:gather
|    |    |    |   169         if len(args) and type(args[0]) != tuple:
|    |    |    |   171         ret = []
|    |    |    |   172         for tup in args:
|    |    |    |   173             if len(tup) == 2:
|    |    |    |   174                 (key, fn) = tup
|    |    |    |   175                 defval = None
|    |    |    |   179             val = self._read(key)
|    |    |    |   > xenstore/xstransact.py:_read
|    |    |    |     44         path = self.prependPath(key)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     284             return self.path + '/' + key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |     45         try:
|    |    |    |     46             return xshandle().read(self.transaction, 
path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xstransact.py:_read
|    |    |    |   185             if val is None:
|    |    |    |   188                 val = fn(val)
|    |    |    |   189             ret.append(val)
|    |    |    |   172         for tup in args:
|    |    |    |   173             if len(tup) == 2:
|    |    |    |   174                 (key, fn) = tup
|    |    |    |   175                 defval = None
|    |    |    |   179             val = self._read(key)
|    |    |    |   > xenstore/xstransact.py:_read
|    |    |    |     44         path = self.prependPath(key)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     284             return self.path + '/' + key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |     45         try:
|    |    |    |     46             return xshandle().read(self.transaction, 
path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xstransact.py:_read
|    |    |    |   185             if val is None:
|    |    |    |   188                 val = fn(val)
|    |    |    |   189             ret.append(val)
|    |    |    |   172         for tup in args:
|    |    |    |   173             if len(tup) == 2:
|    |    |    |   174                 (key, fn) = tup
|    |    |    |   175                 defval = None
|    |    |    |   179             val = self._read(key)
|    |    |    |   > xenstore/xstransact.py:_read
|    |    |    |     44         path = self.prependPath(key)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     284             return self.path + '/' + key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |     45         try:
|    |    |    |     46             return xshandle().read(self.transaction, 
path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xsutil.py:GetDomainPath
|    |    |    |   > XendDomainInfo.py:getDomid
|    |    |    |    789         return self.domid
|    |    |    |   < XendDomainInfo.py:getDomid
|    |    |    |  < server/DevController.py:backendRoot
|    |    |    |  369         if transaction:
|    |    |    |  372             return map(int, xstransact.List(fe))
|    |    |    |  > xenstore/xstransact.py:List
|    |    |    |   319         return complete(path, lambda t: t.list(*args))
|    |    |    |   > xenstore/xstransact.py:complete
|    |    |    |    350     while True:
|    |    |    |    351         t = xstransact(path)
|    |    |    |    > xenstore/xstransact.py:__init__
|    |    |    |      14         assert path is not None
|    |    |    |      16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |      19         self.path = path.rstrip("/")
|    |    |    |      20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |      21         self.in_transaction = True
|    |    |    |    < xenstore/xstransact.py:__init__
|    |    |    |    352         try:
|    |    |    |    353             result = f(t)
|    |    |    |    > xenstore/xstransact.py:<lambda>
|    |    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |    |> xenstore/xstransact.py:list
|    |    |    |    | 129         if len(args) == 0:
|    |    |    |    | 130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    | 131             if ret is None:
|    |    |    |    | 132                 return []
|    |    |    |    |< xenstore/xstransact.py:list
|    |    |    |    < xenstore/xstransact.py:<lambda>
|    |    |    |    354             if t.commit():
|    |    |    |    > xenstore/xstransact.py:commit
|    |    |    |      28         if not self.in_transaction:
|    |    |    |      30         self.in_transaction = False
|    |    |    |      31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |      32         self.transaction = "0"
|    |    |    |      33         return rc
|    |    |    |    < xenstore/xstransact.py:commit
|    |    |    |    355                 return result
|    |    |    |   < xenstore/xstransact.py:complete
|    |    |    |   > xenstore/xstransact.py:__del__
|    |    |    |     24         if self.in_transaction:
|    |    |    |   < xenstore/xstransact.py:__del__
|    |    |    |  < xenstore/xstransact.py:List
|    |    |    | < server/DevController.py:deviceIDs
|    |    |    |< server/DevController.py:configurations
|    |    |     738                         for config in configs:
|    |    |     747                 if not found:
|    |    |     748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |    |> XendConfig.py:all_devices_sxpr
|    |    |    | 914         sxprs = []
|    |    |    | 915         pci_devs = []
|    |    |    | 916         for dev_type, dev_info in self['device'].values():
|    |    |    | 917             if dev_type == 'pci': # special case for pci 
devices
|    |    |    | 920                 sxpr =  self.device_sxpr(dev_type = 
dev_type,
|    |    |    | 921                                          dev_info = 
dev_info)
|    |    |    | > XendConfig.py:device_sxpr
|    |    |    |  898         sxpr = []
|    |    |    |  899         if dev_uuid != None and dev_uuid in 
self['device']:
|    |    |    |  902         if dev_type == None or dev_info == None:
|    |    |    |  906         sxpr.append(dev_type)
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  908         sxpr += config
|    |    |    |  910         return sxpr
|    |    |    | < XendConfig.py:device_sxpr
|    |    |    | 922                 sxprs.append((dev_type, sxpr))
|    |    |    | 916         for dev_type, dev_info in self['device'].values():
|    |    |    | 926         if pci_devs:
|    |    |    | 934         return sxprs
|    |    |    |< XendConfig.py:all_devices_sxpr
|    |    |     749                         if dev_type == cls:
|    |    |     748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |     730             for cls in XendDevices.valid_devices():
|    |    |     731                 found = False
|    |    |     734                 if domain:
|    |    |     735                     try:
|    |    |     736                         controller = 
domain.getDeviceController(cls)
|    |    |    |> XendDomainInfo.py:getDeviceController
|    |    |    |1152         if name not in self._deviceControllers:
|    |    |    |1153             devController = 
XendDevices.make_controller(name, self)
|    |    |    | > XendDevices.py:make_controller
|    |    |    |   62         if name in cls.controllers.keys():
|    |    |    |   63             cls.controllers[name].deviceClass = name
|    |    |    |   64             return cls.controllers[name](domain)
|    |    |    |  > server/pciif.py:__init__
|    |    |    |    51         DevController.__init__(self, vm)
|    |    |    |   > server/DevController.py:__init__
|    |    |    |     72         self.vm = vm
|    |    |    |   < server/DevController.py:__init__
|    |    |    |  < server/pciif.py:__init__
|    |    |    | < XendDevices.py:make_controller
|    |    |    |1154             if not devController:
|    |    |    |1156             self._deviceControllers[name] = devController
|    |    |    |1158         return self._deviceControllers[name]
|    |    |    |< XendDomainInfo.py:getDeviceController
|    |    |     737                         configs = 
controller.configurations()
|    |    |    |> server/DevController.py:configurations
|    |    |    | 216         return map(self.configuration, self.deviceIDs())
|    |    |    | > server/DevController.py:deviceIDs
|    |    |    |  368         fe = self.backendRoot()
|    |    |    |  > server/DevController.py:backendRoot
|    |    |    |   476         from xen.xend.XendDomain import DOM0_ID
|    |    |    |   477         from xen.xend.xenstore.xsutil import 
GetDomainPath
|    |    |    |   478         return "%s/backend/%s/%s" % 
(GetDomainPath(DOM0_ID),
|    |    |    |   > xenstore/xsutil.py:GetDomainPath
|    |    |    |     26     return xshandle().get_domain_path(domid)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xstransact.py:_read
|    |    |    |   185             if val is None:
|    |    |    |   188                 val = fn(val)
|    |    |    |   189             ret.append(val)
|    |    |    |   172         for tup in args:
|    |    |    |   173             if len(tup) == 2:
|    |    |    |   174                 (key, fn) = tup
|    |    |    |   175                 defval = None
|    |    |    |   179             val = self._read(key)
|    |    |    |   > xenstore/xstransact.py:_read
|    |    |    |     44         path = self.prependPath(key)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     284             return self.path + '/' + key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |     45         try:
|    |    |    |     46             return xshandle().read(self.transaction, 
path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xsutil.py:GetDomainPath
|    |    |    |   > XendDomainInfo.py:getDomid
|    |    |    |    789         return self.domid
|    |    |    |   < XendDomainInfo.py:getDomid
|    |    |    |  < server/DevController.py:backendRoot
|    |    |    |  369         if transaction:
|    |    |    |  372             return map(int, xstransact.List(fe))
|    |    |    |  > xenstore/xstransact.py:List
|    |    |    |   319         return complete(path, lambda t: t.list(*args))
|    |    |    |   > xenstore/xstransact.py:complete
|    |    |    |    350     while True:
|    |    |    |    351         t = xstransact(path)
|    |    |    |    > xenstore/xstransact.py:__init__
|    |    |    |      14         assert path is not None
|    |    |    |      16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |      19         self.path = path.rstrip("/")
|    |    |    |      20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_read
|    |    |    |    185             if val is None:
|    |    |    |    188                 val = fn(val)
|    |    |    |    189             ret.append(val)
|    |    |    |    172         for tup in args:
|    |    |    |    190         if len(ret) == 1:
|    |    |    |    192         return ret
|    |    |    |   < xenstore/xstransact.py:gather
|    |    |    |  < xenstore/xstransact.py:<lambda>
|    |    |    |  354             if t.commit():
|    |    |    |  > xenstore/xstransact.py:commit
|    |    |    |    28         if not self.in_transaction:
|    |    |    |    30         self.in_transaction = False
|    |    |    |    31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    32         self.transaction = "0"
|    |    |    |    33         return rc
|    |    |    |  < xenstore/xstransact.py:commit
|    |    |    |  350     while True:
|    |    |    |  351         t = xstransact(path)
|    |    |    |  > xenstore/xstransact.py:__init__
|    |    |    |    14         assert path is not None
|    |    |    |    16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    19         self.path = path.rstrip("/")
|    |    |    |    20         self.transaction = xshandle().transaction_start()
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    21         self.in_transaction = True
|    |    |    |  < xenstore/xstransact.py:__init__
|    |    |    |  352         try:
|    |    |    |  353             result = f(t)
|    |    |    |  > xenstore/xstransact.py:<lambda>
|    |    |    |   319         return complete(path, lambda t: t.list(*args))
|    |    |    |   > xenstore/xstransact.py:list
|    |    |    |    129         if len(args) == 0:
|    |    |    |    130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |     21         self.in_transaction = True
| |       ||        ||      |    131             if ret is None:
 |    |    |    |    132                 return []
 ||      | < xenstore/xstransact.py:__init__
 |      |    |   < xenstore/xstransact.py:list
 |  |     |    |   |  | < xenstore/xstransact.py:<lambda>
 |      |    |   |    | 354             if t.commit():
 352         try:
| |    |    |    | > xenstore/xstransact.py:commit
 |      |    |    |   28         if not self.in_transaction:
||        ||     |    |   30         self.in_transaction = False
 |    |    |    |   31         rc = 
xshandle().transaction_end(self.transaction, False)
 |  |   353             result = f(t)
 |  |       | |      |  > xenstore/xsutil.py:xshandle
 |    |    |    |     15     if not xs_handle:
||    |    |        |     20     return xs_handle
||      |    |     > xenstore/xstransact.py:<lambda>
||      | < xenstore/xsutil.py:xshandle
    |    |    333         return complete(path, lambda t: t.gather(*args))
|    |    |    |   > xenstore/xstransact.py:gather
|    |    |   |    |    |    |     32         self.transaction = "0"
 |    |    |    |     33         return rc
| |    |      169         if len(args) and type(args[0]) != tuple:
 | |      |   < xenstore/xstransact.py:commit
 | |    |    |      |   355                 return result
 |    |    |    |  < xenstore/xstransact.py:complete
||    |    |      |    > xenstore/xstransact.py:__del__
||    |      |    |  171         ret = []
 |      24         if self.in_transaction:
|    |     |  |    |  < xenstore/xstransact.py:__del__
 |    |    |  |   | < xenstore/xstransact.py:List
|  |      |     |    |    |< server/DevController.py:deviceIDs
   ||    |     |  |    < server/DevController.py:configurations
 |    |    |    738                         for config in configs:
 172         for tup in args:
| |       |   ||    | 153             while self.running:
 |    747                 if not found:
   |      |    ||       748                     for dev_type, dev_info in 
self.all_devices_sxpr():
||    |    |    > XendConfig.py:all_devices_sxpr
   |  |      173             if len(tup) == 2:
||    |        |     914         sxprs = []
|      |  154                 self.server.handle_request()
    174                 (key, fn) = tup
 | |    |     915         pci_devs = []
 |    |    |     916         for dev_type, dev_info in self['device'].values():
 |  |     |    |     917             if dev_type == 'pci': # special case for 
pci devices
 |  |     |    |     920                 sxpr =  self.device_sxpr(dev_type = 
dev_type,
 |    |    |     921                                          dev_info = 
dev_info)
 |    |   175                 defval = None
 |  |     |    |> XendConfig.py:device_sxpr
 |    | |    |    | 898         sxpr = []
 |    |    |    | 899         if dev_uuid != None and dev_uuid in 
self['device']:
 |     | 179             val = self._read(key)
 | |    |    | 902         if dev_type == None or dev_info == None:
 |      |    |    ||   906         sxpr.append(dev_type)
 |      |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
||    |    |        | |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
> xenstore/xstransact.py:_read
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
| |       |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
||      |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
 |    |    |    |  908         sxpr += config
 | |      |    |    |  910         return sxpr
 | |     44         path = self.prependPath(key)
 | |    |    | < XendConfig.py:device_sxpr
 |    |      ||     |  922                 sxprs.append((dev_type, sxpr))
 |    |    |    |  916         for dev_type, dev_info in 
self['device'].values():
 |  |     |    |    |  926         if pci_devs:
 |  |     |    |    |  934         return sxprs
> xenstore/xstransact.py:prependPath
|    |    |  |     | < XendConfig.py:all_devices_sxpr
 |    |   |  |       | 749                         if dev_type == cls:
||       |    |    | 748                     for dev_type, dev_info in 
self.all_devices_sxpr():
 | |    283         if self.path:
 | |    |      | 730             for cls in XendDevices.valid_devices():
 |    |    |   |  |   731                 found = False
 |    |    |  |   | 734                 if domain:
 |    |    |    | 735                     try:
 |    |    |    | 736                         controller = 
domain.getDeviceController(cls)
 | | 284             return self.path + '/' + key
 |   |    |     |    | > XendDomainInfo.py:getDeviceController
 |    |    |    | | 1152         if name not in self._deviceControllers:
 |    |    |    |    | 1153             devController = 
XendDevices.make_controller(name, self)
< xenstore/xstransact.py:prependPath
| |      |    |    |  > XendDevices.py:make_controller
 |  |   |    |      | |   62         if name in cls.controllers.keys():
 |      |  |    |    |   63             cls.controllers[name].deviceClass = name
  45         try:
| |    |    |    |   64             return cls.controllers[name](domain)
 |    |    |    |  > server/iopif.py:__init__
 |    |    |    | |    50         DevController.__init__(self, vm)
 |      |    |    | |     > server/DevController.py:__init__
 |  |     46             return xshandle().read(self.transaction, path)
 | |      | |    |       72         self.vm = vm
 |    |    |    |    < server/DevController.py:__init__
 | |      |   |    |    |   < server/iopif.py:__init__
 |  > xenstore/xsutil.py:xshandle
 |    |    |    |  < XendDevices.py:make_controller
 |  |   |    |    | 1154             if not devController:
 |    |    |    | 1156             self._deviceControllers[name] = devController
 |   |     |    |    |   1158         return self._deviceControllers[name]
||    |    |    | < XendDomainInfo.py:getDeviceController
 |    |    |    | 737                         configs = 
controller.configurations()
 |   15     if not xs_handle:
 |      ||        | |      | > server/DevController.py:configurations
 | |     20     return xs_handle
 | |      | |        |  216         return map(self.configuration, 
self.deviceIDs())
||    |    |      |  > server/DevController.py:deviceIDs
 |  |   |    |    |   368         fe = self.backendRoot()
 |    |    |    |   > server/DevController.py:backendRoot
< xenstore/xsutil.py:xshandle
|    |    |    |    476         from xen.xend.XendDomain import DOM0_ID
|    |    |    |   477         from xen.xend.xenstore.xsutil import 
GetDomainPath
| |      |    |    |   478         return "%s/backend/%s/%s" % 
(GetDomainPath(DOM0_ID),
 |    ||       |    |    |> xenstore/xsutil.py:GetDomainPath
 |    |       ||     < xenstore/xstransact.py:_read
 | |     26     return xshandle().get_domain_path(domid)
 |    |    |    |   > xenstore/xsutil.py:xshandle
 |    |    |    |     15     if not xs_handle:
 ||      |      |    |     20     return xs_handle
||    |    |      |   < xenstore/xsutil.py:xshandle
  |   185             if val is None:
|    |    |    |   188                 val = fn(val)
|    |    |    |   189             ret.append(val)
|    |    |    |   172         for tup in args:
|    |    |    |   173             if len(tup) == 2:
|    |    |    |   174                 (key, fn) = tup
|    |    |    |   175                 defval = None
|    |    |    |   179             val = self._read(key)
|    |    |    |   > xenstore/xstransact.py:_read
|    |    |    |     44         path = self.prependPath(key)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     284             return self.path + '/' + key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |     45         try:
|    |    |    |     46             return xshandle().read(self.transaction, 
path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xsutil.py:GetDomainPath
|    |    |    |   > XendDomainInfo.py:getDomid
| |      |  |    |    |      789         return self.domid
 |    |    |    |   < XendDomainInfo.py:getDomid
|  |   |   < xenstore/xstransact.py:_read
 |    |    |      |    |  < server/DevController.py:backendRoot
||        | |    |    | 369         if transaction:
 185             if val is None:
|    |    |  |     | 372             return map(int, xstransact.List(fe))
 |    |    |    | > xenstore/xstransact.py:List
||        ||        ||    |  319         return complete(path, lambda t: 
t.list(*args))
 188                 val = fn(val)
|    |    |   |  |  > xenstore/xstransact.py:complete
 |    |    |    |   350     while True:
 |  |      | |    |    |   351         t = xstransact(path)
 |     |    |  189             ret.append(val)
 |      | |    |     |    |    172         for tup in args:
 |   > xenstore/xstransact.py:__init__
 | |      |   |    |     |    |     14         assert path is not None
 173             if len(tup) == 2:
|    |    |    |     16         self.in_transaction = False # Set this 
temporarily -- if this
|   |    |    |  |    |     19         self.path = path.rstrip("/")
 |    |    |    |     20         self.transaction = 
xshandle().transaction_start()
 |  |      | |    |      |    > xenstore/xsutil.py:xshandle
 | 174                 (key, fn) = tup
 |    |       |    |    |     15     if not xs_handle:
 | |      | |     |    |        20     return xs_handle
 |  175                 defval = None
 |     |    |    |    |     179             val = self._read(key)
|    |    |    |    |> xenstore/xstransact.py:_read
|    |    |    |    |  44         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  45         try:
|    |    |    |    |  46             return xshandle().read(self.transaction, 
path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
 |    |    < xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_read
|    |    |    |    185             if val is None:
|    |    |    |    188                 val = fn(val)
|    |    |    |    189             ret.append(val)
|    |    |    |    172         for tup in args:
|    |    |    |    173             if len(tup) == 2:
|    |    |    |    174                 (key, fn) = tup
|    |    |    |    175                 defval = None
|    |    |    |    179             val = self._read(key)
|    |    |    |    > xenstore/xstransact.py:_read
|    |    |    |      44         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      45         try:
|    |    |    |      46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_read
|    |    |    |    185             if val is None:
|    |    |    |    188                 val = fn(val)
|    |    |    |    189             ret.append(val)
|    |    |    |    172         for tup in args:
|    |    |    |    190         if len(ret) == 1:
|    |    |    |    192         return ret
|    |    |    |   < xenstore/xstransact.py:gather
|    |    |    |  < xenstore/xstransact.py:<lambda>
|    |    |    |  354             if t.commit():
|    |    |    |  > xenstore/xstransact.py:commit
|    |    |    |    28         if not self.in_transaction:
|    |    |    |    30         self.in_transaction = False
|    |    |    |    31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    32         self.transaction = "0"
|    |    |    |    33         return rc
|    |    |    |  < xenstore/xstransact.py:commit
|    |    |    |  350     while True:
|    |    |    |  351         t = xstransact(path)
|    |    |    |  > xenstore/xstransact.py:__init__
|    |    |    |    14         assert path is not None
|    |    |    |    16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    19         self.path = path.rstrip("/")
|    |    |    |    20         self.transaction = xshandle().transaction_start()
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    21         self.in_transaction = True
|    |    |    |  < xenstore/xstransact.py:__init__
|    |    |    |  352         try:
|    |    |    |  353             result = f(t)
|    |    |    |  > xenstore/xstransact.py:<lambda>
|    |    |    |   319         return complete(path, lambda t: t.list(*args))
|    |    |    |   > xenstore/xstransact.py:list
|    |    |    |    129         if len(args) == 0:
|    |    |    |    130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |     21         self.in_transaction = True
|    |    |    |   < xenstore/xstransact.py:__init__
|    |    |    |   352         try:
|    |    |    |   353             result = f(t)
|    |    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    |    333         return complete(path, lambda t: t.gather(*args))
|    |    |    |    > xenstore/xstransact.py:gather
|    |    |    |     169         if len(args) and type(args[0]) != tuple:
|    |    |    |     171         ret = []
|    |    |    |     172         for tup in args:
|    |    |    |     173             if len(tup) == 2:
|    |    |    |     174                 (key, fn) = tup
|    |    |    |     175                 defval = None
|    |    |    |     179             val = self._read(key)
|    |    |    |    |> xenstore/xstransact.py:_read
|    |    |    |    |  44         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  45         try:
|    |    |    |    |  46             return xshandle().read(self.transaction, 
path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    | 131             if ret is None:
|    |    |    |    | 132                 return []
|    |    |    |    |< xenstore/xstransact.py:list
|    |    |    |    < xenstore/xstransact.py:<lambda>
|    |    |    |    354             if t.commit():
|    |    |    |    > xenstore/xstransact.py:commit
|    |    |    |      28         if not self.in_transaction:
|    |    |    |      30         self.in_transaction = False
|    |    |    |      31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_read
|    |    |    |    185             if val is None:
|    |    |    |    188                 val = fn(val)
|    |    |    |    189             ret.append(val)
|    |    |    |    172         for tup in args:
|    |    |    |    173             if len(tup) == 2:
|    |    |    |  |      |  |   |       32         self.transaction = "0"
 174                 (key, fn) = tup
| |      | |        |    |  |     33         return rc
 | |      |   175                 defval = None
 |    |    |    |    179             val = self._read(key)
|    |    |    |    > xenstore/xstransact.py:_read
|    |    |    |      44         path = self.prependPath(key)
|    |    |   |   |       |    |> xenstore/xstransact.py:prependPath
< xenstore/xstransact.py:commit
| |    |       |    |    |    | 283         if self.path:
||    |    |    |     284             return self.path + '/' + key
 |    |    |    |      < xenstore/xstransact.py:prependPath
 | |      |    |    |     45         try:
 |  355                 return result
 |     |  |       ||        | |     46             return 
xshandle().read(self.transaction, path)
 |     < xenstore/xstransact.py:complete
||        ||        |  |    > xenstore/xsutil.py:xshandle
 |    |    |     |   |  > xenstore/xstransact.py:__del__
 |      |    15     if not xs_handle:
 |  |      | |      24         if self.in_transaction:
 |      | |      |      |    20     return xs_handle
 |    |    |  |   |    < xenstore/xsutil.py:xshandle
    < xenstore/xstransact.py:__del__
|    |    |    |  < xenstore/xstransact.py:List
|    |    |    | < server/DevController.py:deviceIDs
|    |    |    |< server/DevController.py:configurations
|    |    |     738                         for config in configs:
|    |    |     747                 if not found:
|    |    |     748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |    |> XendConfig.py:all_devices_sxpr
|    |    |    | 914         sxprs = []
|    |    |    | 915         pci_devs = []
|    |    |    | 916         for dev_type, dev_info in self['device'].values():
|    |    |    | 917             if dev_type == 'pci': # special case for pci 
devices
|    |    |    | 920                 sxpr =  self.device_sxpr(dev_type = 
dev_type,
|    |    |    | 921                                          dev_info = 
dev_info)
|    |    |    | > XendConfig.py:device_sxpr
|    |    |    |  898         sxpr = []
|    |    |    |  899         if dev_uuid != None and dev_uuid in 
self['device']:
|    |    |    |  902         if dev_type == None or dev_info == None:
|    |    |    |  906         sxpr.append(dev_type)
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  908         sxpr += config
|    |    |    |  910         return sxpr
|    |    |    | < XendConfig.py:device_sxpr
|    |    |    | 922                 sxprs.append((dev_type, sxpr))
|    |    |    | 916         for dev_type, dev_info in self['device'].values():
|    |    |    | 926         if pci_devs:
|    |    |    | 934         return sxprs
|    |    |    |< XendConfig.py:all_devices_sxpr
|    |    |     749                         if dev_type == cls:
|    |    |     748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |     730             for cls in XendDevices.valid_devices():
|    |    |     731                 found = False
|    |    |     734                 if domain:
|    |    |     735                     try:
|    |    |     736                         controller = 
domain.getDeviceController(cls)
|    |    |    |> XendDomainInfo.py:getDeviceController
|    |    |    |1152         if name not in self._deviceControllers:
|    |    |    |1153             devController = 
XendDevices.make_controller(name, self)
|    |    |    | > XendDevices.py:make_controller
|    |    |    |   62         if name in cls.controllers.keys():
|    |    |    |   63             cls.controllers[name].deviceClass = name
|    |    |    |   64             return cls.controllers[name](domain)
|    |    |    |  > server/BlktapController.py:__init__
|    |    |    |     9         BlkifController.__init__(self, vm)
|    |    |    |   > server/blkif.py:__init__
|    |    |    |     36         DevController.__init__(self, vm)
|    |    |    |    > server/DevController.py:__init__
|    |    |    |      72         self.vm = vm
|    |    |    |    < server/DevController.py:__init__
|    |    |    |   < server/blkif.py:__init__
|    |    |    |  < server/BlktapController.py:__init__
|    |    |    | < XendDevices.py:make_controller
|    |    |    |1154             if not devController:
|    |    |    |1156             self._deviceControllers[name] = devController
|    |    |    |1158         return self._deviceControllers[name]
|    |    |    |< XendDomainInfo.py:getDeviceController
|    |    |     737                         configs = 
controller.configurations()
|    |    |    |> server/DevController.py:configurations
|    |    |    | 216         return map(self.configuration, self.deviceIDs())
|    |    |    | > server/DevController.py:deviceIDs
|    |    |    |  368         fe = self.backendRoot()
|    |    |    |  > server/DevController.py:backendRoot
|    |    |    |   476         from xen.xend.XendDomain import DOM0_ID
|    |    |    |   477         from xen.xend.xenstore.xsutil import 
GetDomainPath
|    |    |    |   478         return "%s/backend/%s/%s" % 
(GetDomainPath(DOM0_ID),
|    |    |    |   > xenstore/xsutil.py:GetDomainPath
|    |    |    |     26     return xshandle().get_domain_path(domid)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xstransact.py:_read
|    |    |    |   185             if val is None:
|    |    |    |   188                 val = fn(val)
|    |    |    |   189             ret.append(val)
|    |    |    |   172         for tup in args:
|    |    |    |   173             if len(tup) == 2:
|    |    |    |   174                 (key, fn) = tup
|    |    |    |   175                 defval = None
|    |    |    |   179             val = self._read(key)
|    |    |    |   > xenstore/xstransact.py:_read
|    |    |    |     44         path = self.prependPath(key)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     284             return self.path + '/' + key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |     45         try:
|    |    |    |     46             return xshandle().read(self.transaction, 
path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xsutil.py:GetDomainPath
|    |    |    |   > XendDomainInfo.py:getDomid
|    |    |    |    789         return self.domid
|    |    |    |   < XendDomainInfo.py:getDomid
|    |    |    |  < server/DevController.py:backendRoot
|    |    |    |  369         if transaction:
| |    |    |      | < xenstore/xstransact.py:_read
 | |      | |    |      | 185             if val is None:
 |  |    | 372             return map(int, xstransact.List(fe))
 |    |    |    | > xenstore/xstransact.py:List
   | |    | 188                 val = fn(val)
 |     |  |   |    |  319         return complete(path, lambda t: t.list(*args))
 |    |    |      |  > xenstore/xstransact.py:complete
 | |     |    |    189             ret.append(val)
||    |    |    |   172         for tup in args:
    |   350     while True:
|    |    | |    |   173             if len(tup) == 2:
 |      |    |   |    |    |   351         t = xstransact(path)
 | |     174                 (key, fn) = tup
 | |    |    |   > xenstore/xstransact.py:__init__
 |   |    |    |    175                 defval = None
 |   |    |    |     14         assert path is not None
 |      |   |    |   |  |    179             val = self._read(key)
 |    |    |     |     16         self.in_transaction = False # Set this 
temporarily -- if this
 |    |    |    |      19         self.path = path.rstrip("/")
 |    > xenstore/xstransact.py:_read
|    |    |    |      20         self.transaction = 
xshandle().transaction_start()
| |    |    |    |    |> xenstore/xsutil.py:xshandle
 |      |    |    |    |  15     if not xs_handle:
||        | |      | |       |    |  20     return xs_handle
 |  44         path = self.prependPath(key)
 |     |    |     |  |       | |      | | > xenstore/xstransact.py:prependPath
< xenstore/xsutil.py:xshandle
|    |    |    |    |  283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      45         try:
|    |    |    |      46             return xshandle().read(self.transaction, 
path)
| |      |   |    |      | |      | |    |> xenstore/xsutil.py:xshandle
  21         self.in_transaction = True
|    |    ||     |    |  15     if not xs_handle:
 |    |      |    |    |  20     return xs_handle
||    |    |    |    |< xenstore/xsutil.py:xshandle
    |    |    |< xenstore/xstransact.py:__init__
|    |    |    |    352         try:
|    |    |    |    353             result = f(t)
|    |    |    |    > xenstore/xstransact.py:<lambda>
|    |    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |    |> xenstore/xstransact.py:list
|    |    |    |    | 129         if len(args) == 0:
|    |    |    |    | 130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_read
|    |    |    |     185             if val is None:
|    |    |    |     188                 val = fn(val)
|    |    |    |     189             ret.append(val)
|    |    |    |     172         for tup in args:
|    |    |    |     190         if len(ret) == 1:
|    |    |    |     192         return ret
|    |    |    |    < xenstore/xstransact.py:gather
|    |    |    |   < xenstore/xstransact.py:<lambda>
|    |    |    |   354             if t.commit():
|    |    |    |   > xenstore/xstransact.py:commit
|    |    |    |     28         if not self.in_transaction:
|    |    |    |     30         self.in_transaction = False
|    |    |    |     31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |    131             if ret is None:
|    |    |    |    132                 return []
|    |    |    |   < xenstore/xstransact.py:list
|    |    |    |  < xenstore/xstransact.py:<lambda>
|    |    |    |  354             if t.commit():
|    |    |    |  > xenstore/xstransact.py:commit
|    |    |    |    28         if not self.in_transaction:
|    |    |    |    30         self.in_transaction = False
|    |    |    |    31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    32         self.transaction = "0"
|    |    |    |    33         return rc
|    |    |    |  < xenstore/xstransact.py:commit
|    |    |    |  350     while True:
|    |    |    |  351         t = xstransact(path)
|    |    |    |  > xenstore/xstransact.py:__init__
|    |    |    |    14         assert path is not None
|    |    |    |    16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    19         self.path = path.rstrip("/")
|    |    |    |    20         self.transaction = xshandle().transaction_start()
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    32         self.transaction = "0"
|    |    |    |    33         return rc
|    |    |    |  < xenstore/xstransact.py:commit
|    |    |    |  355                 return result
|    |    |    | < xenstore/xstransact.py:complete
|    |    |    | > xenstore/xstransact.py:__del__
|    |    |    |   24         if self.in_transaction:
|    |    |    | < xenstore/xstransact.py:__del__
|    |    |    |< xenstore/xstransact.py:List
|    |    |    < server/DevController.py:deviceIDs
|    |    |   < server/DevController.py:configurations
|    |    |   738                         for config in configs:
|    |    |   747                 if not found:
|    |    |   748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |   > XendConfig.py:all_devices_sxpr
|    |    |    914         sxprs = []
|    |    |    915         pci_devs = []
|    |    |    916         for dev_type, dev_info in self['device'].values():
|    |    |    917             if dev_type == 'pci': # special case for pci 
devices
|    |    |    920                 sxpr =  self.device_sxpr(dev_type = dev_type,
|    |    |    921                                          dev_info = dev_info)
|    |    |    > XendConfig.py:device_sxpr
|    |    |     898         sxpr = []
|    |    |     899         if dev_uuid != None and dev_uuid in self['device']:
|    |    |     902         if dev_type == None or dev_info == None:
|    |    |     906         sxpr.append(dev_type)
|    |    |     907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |     907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |     907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |     907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |     907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |     908         sxpr += config
|    |    |     910         return sxpr
|    |    |    < XendConfig.py:device_sxpr
|    |    |    922                 sxprs.append((dev_type, sxpr))
|    |    |    916         for dev_type, dev_info in self['device'].values():
|    |    |    926         if pci_devs:
|    |    |    934         return sxprs
|    |    |   < XendConfig.py:all_devices_sxpr
|    |    |   749                         if dev_type == cls:
|    |    |   748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |   730             for cls in XendDevices.valid_devices():
|    |    |   731                 found = False
|    |    |   734                 if domain:
|    |    |   735                     try:
|    |    |   736                         controller = 
domain.getDeviceController(cls)
|    |    |   > XendDomainInfo.py:getDeviceController
|    |    |   1152         if name not in self._deviceControllers:
|    |    |   1153             devController = 
XendDevices.make_controller(name, self)
|    |    |    > XendDevices.py:make_controller
|    |    |      62         if name in cls.controllers.keys():
|    |    |      63             cls.controllers[name].deviceClass = name
|    |    |    |   21         self.in_transaction = True
 |    |    |    < xenstore/xstransact.py:__init__
  |    |      64             return cls.controllers[name](domain)
|    |    |    352         try:
| |    |    |     353             result = f(t)
 |     |    |    > server/tpmif.py:__init__
 ||        |    |> xenstore/xstransact.py:<lambda>
||        |    |    | 333         return complete(path, lambda t: 
t.gather(*args))
||    |    |    | > xenstore/xstransact.py:gather
    |  41         DevController.__init__(self, vm)
|  |    |     |  |     |      |  > server/DevController.py:__init__
||    |    |    |   169         if len(args) and type(args[0]) != tuple:
 |   72         self.vm = vm
 |    |    |    |  < server/DevController.py:__init__
 |  |   |    |    | < server/tpmif.py:__init__
 |    |    |    |< XendDevices.py:make_controller
 |    |   |    |    1154             if not devController:
 |    |    |    1156             self._deviceControllers[name] = devController
 |    |    |    1158         return self._deviceControllers[name]
 |    |    |    < XendDomainInfo.py:getDeviceController
|   171         ret = []
| |    |    |      172         for tup in args:
 |    |    | |    173             if len(tup) == 2:
 |      |    |    174                 (key, fn) = tup
||      |    |    175                 defval = None
 |  737                         configs = controller.configurations()
 |    |    |      > server/DevController.py:configurations
||     |    |     216         return map(self.configuration, self.deviceIDs())
 |    |      |    |> server/DevController.py:deviceIDs
||    |    |    | 368         fe = self.backendRoot()
    179             val = self._read(key)
| |    |      |    |  | > xenstore/xstransact.py:_read
 |    |      | |    | > server/DevController.py:backendRoot
 |    |    |    |   476         from xen.xend.XendDomain import DOM0_ID
   |    44         path = self.prependPath(key)
| |    |      |    |   > xenstore/xstransact.py:prependPath
 |    |    |    |    283         if self.path:
|    |    |   477         from xen.xend.xenstore.xsutil import GetDomainPath
| |    |    |    |      478         return "%s/backend/%s/%s" % 
(GetDomainPath(DOM0_ID),
 |    |    | |      |    |    |    284             return self.path + '/' + key
 |    > xenstore/xsutil.py:GetDomainPath
||    |    |      < xenstore/xstransact.py:prependPath
 |  |    |    |      26     return xshandle().get_domain_path(domid)
 |    |    |    |    > xenstore/xsutil.py:xshandle
 |    |  |     |    |    |     |   45         try:
 |    |    |    |      46             return xshandle().read(self.transaction, 
path)
 |    |    |    |   15     if not xs_handle:
 |      | > xenstore/xsutil.py:xshandle
||        |    |    |    ||   15     if not xs_handle:
 |   |    |  20     return xs_handle
 |    |      |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |  20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xsutil.py:GetDomainPath
| |      | |        | |    |    |   > XendDomainInfo.py:getDomid
 |  < xenstore/xstransact.py:_read
 |    |      |    |   185             if val is None:
||    |    |    |   188                 val = fn(val)
    |    |    789         return self.domid
| |      |    |    |   189             ret.append(val)
 |    |  |    |    |  < XendDomainInfo.py:getDomid
 |    |    |    | < server/DevController.py:backendRoot
 |    |    |    | 369         if transaction:
||    |    |      | 372             return map(int, xstransact.List(fe))
 |    |    |    | > xenstore/xstransact.py:List
 |   172         for tup in args:
| |    |    |    |  173             if len(tup) == 2:
 |    |      |    |  174                 (key, fn) = tup
||    |    |    |  175                 defval = None
 |    |      |    |  179             val = self._read(key)
 |    | |      |  319         return complete(path, lambda t: t.list(*args))
 |    |    |    | |   > xenstore/xstransact.py:complete
 |    |      |    |    350     while True:
||    |    |    |    351         t = xstransact(path)
 |    |    |    > xenstore/xstransact.py:_read
 |    |    |    |      44         path = self.prependPath(key)
|    > xenstore/xstransact.py:__init__
| |    |    |    |    |  14         assert path is not None
 |      |    |    |    |  16         self.in_transaction = False # Set this 
temporarily -- if this
||       |  |    |    |    |  19         self.path = path.rstrip("/")
 |     |    |> xenstore/xstransact.py:prependPath
 |    |  |     | |    |    |  20         self.transaction = 
xshandle().transaction_start()
 |    |    |    |    | > xenstore/xsutil.py:xshandle
 |     |    |    |   |    |   15     if not xs_handle:
 |  | 283         if self.path:
 |   |    |    |    |   20     return xs_handle
 |     |   |    |    |    | < xenstore/xsutil.py:xshandle
  |    |    |  284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      45         try:
|    |    |    |      46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |  |     21         self.in_transaction = True
 |    |    |      |    < xenstore/xstransact.py:__init__
||    |    |    |    352         try:
 |    |   |    |    |    353             result = f(t)
 |    |      |    |    > xenstore/xstransact.py:<lambda>
 |    |    | |      |     319         return complete(path, lambda t: 
t.list(*args))
 |    |    < xenstore/xstransact.py:_read
||      |      ||       | | > xenstore/xstransact.py:list
 |    |    |    |     129         if len(args) == 0:
 |    |    |    |     130             ret = xshandle().ls(self.transaction, 
self.path)
 |    |    |    |    |> xenstore/xsutil.py:xshandle
 185             if val is None:
| |      | |      |      | |      | 188                 val = fn(val)
 | |    |  15     if not xs_handle:
 |    |    |    |    |  20     return xs_handle
  | |      |    | |        | 189             ret.append(val)
||      |      | |    |    |< xenstore/xsutil.py:xshandle
   | 172         for tup in args:
|    |    |    |     173             if len(tup) == 2:
|    |    |    |     174                 (key, fn) = tup
|    |    |    |     175                 defval = None
|    |    |    |     179             val = self._read(key)
|    |    |    |    |> xenstore/xstransact.py:_read
|    |    |    |    |  44         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  45         try:
|    |    |    |    |  46             return xshandle().read(self.transaction, 
path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    | 131             if ret is None:
| |    |    |    |       | 132                 return []
||      |    |    |      |< xenstore/xstransact.py:list
||       |    |    |    < xenstore/xstransact.py:<lambda>
 | |      |< xenstore/xstransact.py:_read
 |    ||    |    |    354             if t.commit():
 |    |    |    |   > xenstore/xstransact.py:commit
 |    |      | |   185             if val is None:
 |    |     |    |     28         if not self.in_transaction:
 | |     |    |    |     30         self.in_transaction = False
 |  |    188                 val = fn(val)
 |    |    |    |    189             ret.append(val)
 |    |    |     ||        172         for tup in args:
||    |    |    |    173             if len(tup) == 2:
 |     |  |        31         rc = xshandle().transaction_end(self.transaction, 
False)
 |    |    | |    |    > xenstore/xsutil.py:xshandle
 |    |    |    |      15     if not xs_handle:
 |  |       174                 (key, fn) = tup
||      |    |    |       175                 defval = None
||       | |        |   20     return xs_handle
 |    |    |    |    < xenstore/xsutil.py:xshandle
  |     179             val = self._read(key)
|    |    |    |    > xenstore/xstransact.py:_read
|    |    |    |      44         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      45         try:
|    |    |    |      46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |      32         self.transaction = "0"
| |      | |    |    |      33         return rc
 |      |  |     |     |    |    < xenstore/xstransact.py:commit
 |    |    |    |    355                 return result
< xenstore/xstransact.py:_read
| |    |      |  |    |    |   < xenstore/xstransact.py:complete
 |    |      |    |  > xenstore/xstransact.py:__del__
||    |    |    |    24         if self.in_transaction:
 |   185             if val is None:
 |    |    |     |  |     |     188                 val = fn(val)
||     < xenstore/xstransact.py:__del__
 | |       |    |    | < xenstore/xstransact.py:List
||    |    |    |< server/DevController.py:deviceIDs
 |      |   189             ret.append(val)
 |    |  |     |    |  172         for tup in args:
 |      |  < server/DevController.py:configurations
 |   |       |    |    738                         for config in configs:
 190         if len(ret) == 1:
|    |    |    747                 if not found:
| |    |     |    |    748                     for dev_type, dev_info in 
self.all_devices_sxpr():
 |  |      192         return ret
 | |    |     |    > XendConfig.py:all_devices_sxpr
 |    |    |    |  914         sxprs = []
 |    < xenstore/xstransact.py:gather
 |      |  |      | |     < xenstore/xstransact.py:<lambda>
 |    |    |   354             if t.commit():
 915         pci_devs = []
| |    |      |    |  |      916         for dev_type, dev_info in 
self['device'].values():
> xenstore/xstransact.py:commit
|    | |      | |      917             if dev_type == 'pci': # special case for 
pci devices
 |    | |        28         if not self.in_transaction:
 |    | |     |     30         self.in_transaction = False
 |    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
 920                 sxpr =  self.device_sxpr(dev_type = dev_type,
| |    |    |    > xenstore/xsutil.py:xshandle
 |   |       |    |      15     if not xs_handle:
||    |    |      20     return xs_handle
  |   921                                          dev_info = dev_info)
 |      |  |    |    < xenstore/xsutil.py:xshandle
  |    |> XendConfig.py:device_sxpr
|    |    |     898         sxpr = []
|    |    |     899         if dev_uuid != None and dev_uuid in self['device']:
|    |    |     902         if dev_type == None or dev_info == None:
|    |    |      32         self.transaction = "0"
||        |  |   |   |     906         sxpr.append(dev_type)
 |       |    |     907         config = [(opt, val) for opt, val in 
dev_info.items()]
  33         return rc
|    |    |     907         config = [(opt, val) for opt, val in 
dev_info.items()]
|   |    |    |     907         config = [(opt, val) for opt, val in 
dev_info.items()]
 | |      |    |     907         config = [(opt, val) for opt, val in 
dev_info.items()]
 |    |    |  |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
 |   < xenstore/xstransact.py:commit
 |      | |       ||      350     while True:
 |     908         sxpr += config
 |    |    |    910         return sxpr
||    |    |   < XendConfig.py:device_sxpr
 |       |    |   922                 sxprs.append((dev_type, sxpr))
||      351         t = xstransact(path)
 |   |    |     |   916         for dev_type, dev_info in 
self['device'].values():
 |    |    |    926         if pci_devs:
||       |    |    934         return sxprs
> xenstore/xstransact.py:__init__
|    |    |   < XendConfig.py:all_devices_sxpr
| |    |    |   749                         if dev_type == cls:
 |    |    |   748                     for dev_type, dev_info in 
self.all_devices_sxpr():
  | |      |  |    |   730             for cls in XendDevices.valid_devices():
 |    |    |   752         return sxpr
 |    |    |  < XendConfig.py:get_sxp
  14         assert path is not None
| |       ||      |  | 1666         if not ignore_store:
 |      16         self.in_transaction = False # Set this temporarily -- if this
||      |  | 1667             vnc_port = self._readDom('console/vnc-port')
 |    |    |  > XendDomainInfo.py:_readDom
 |    |    |   663         return xstransact.Read(self.dompath, *args)
 |  |     19         self.path = path.rstrip("/")
 | |      |  |     | > xenstore/xstransact.py:Read
 |    |    |    297         return complete(path, lambda t: t.read(*args))
  |    |    |    > xenstore/xstransact.py:complete
|   20         self.transaction = xshandle().transaction_start()
 |    |    |      | |> xenstore/xsutil.py:xshandle
 |    |      ||      |  15     if not xs_handle:
 |     350     while True:
 |    |    |  |    |    |  20     return xs_handle
 |  |   351         t = xstransact(path)
 |    |    |    | > xenstore/xstransact.py:__init__
|    |    |< xenstore/xsutil.py:xshandle
|    |    |    |   14         assert path is not None
|    |    |    |  16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |    |  19         self.path = path.rstrip("/")
|    |    |    |  20         self.transaction = xshandle().transaction_start()
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
| |      |   |    |   |    |   20     return xs_handle
 |      | |   21         self.in_transaction = True
 |     |    |    | < xenstore/xstransact.py:__init__
 | |      |    |    | 352         try:
 | |   < xenstore/xsutil.py:xshandle
 |    |    | 353             result = f(t)
|    |    |    |> xenstore/xstransact.py:<lambda>
|    |    |    | 333         return complete(path, lambda t: t.gather(*args))
|    |    |    | > xenstore/xstransact.py:gather
|    |    |    |  169         if len(args) and type(args[0]) != tuple:
|    |    |    |  171         ret = []
|    |    |    |  172         for tup in args:
|    |    |    |  173             if len(tup) == 2:
|    |    |    |  174                 (key, fn) = tup
|    |    |    |  175                 defval = None
|    |    |    |  179             val = self._read(key)
|    |    |    |  > xenstore/xstransact.py:_read
|    |    |    |    44         path = self.prependPath(key)
|    |    |    |   > xenstore/xstransact.py:prependPath
|    |    |    |    283         if self.path:
|    |    |    |    284             return self.path + '/' + key
|    |    |    |   < xenstore/xstransact.py:prependPath
|    |    |    |    45         try:
|    |    |    |    46             return xshandle().read(self.transaction, 
path)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    21         self.in_transaction = True
| |      |    |    |  < xenstore/xstransact.py:__init__
 |    |    ||     |  352         try:
 |   |      |    |    |  353             result = f(t)
 |    |    |    |  |  > xenstore/xstransact.py:<lambda>
< xenstore/xstransact.py:_read
| |     |    |    |   297         return complete(path, lambda t: t.read(*args))
 |    |    |    |  > xenstore/xstransact.py:read
 ||       |   |   |    185             if val is None:
 |  |    |    59         if len(args) == 0:
 |    |    |    |    61         if len(args) == 1:
 | |     |    |    |    62             return self._read(args[0])
 |  |      |    |    |   | > xenstore/xstransact.py:_read
 |    |    |    |     44         path = self.prependPath(key)
 |    |    |    |    > xenstore/xstransact.py:prependPath
 188                 val = fn(val)
|    |    |    |     283         if self.path:
| |    |    |    |     284             return self.path + '/' + key
 |     |  |    |    |      < xenstore/xstransact.py:prependPath
 | |      |  |     |    189             ret.append(val)
 |      ||     45         try:
 |    |    |    |     46             return xshandle().read(self.transaction, 
path)
   |    | |    |    |    > xenstore/xsutil.py:xshandle
 |    |    |    |      15     if not xs_handle:
 |    |    |    |      20     return xs_handle
 | |      172         for tup in args:
 |    |    |    |     173             if len(tup) == 2:
||    |    |    |     174                 (key, fn) = tup
    |    ||     < xenstore/xsutil.py:xshandle
   |    |    |     175                 defval = None
|    |    |    |    179             val = self._read(key)
|    |    |    |    > xenstore/xstransact.py:_read
|    |    |    |      44         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      45         try:
|    |    |    |      46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_read
| |    |    |    |   < xenstore/xstransact.py:read
 |     |  |     |     |   |     |  < xenstore/xstransact.py:_read
 |  < xenstore/xstransact.py:<lambda>
 |  |       ||        |    | 354             if t.commit():
||    |    |    | > xenstore/xstransact.py:commit
 |  185             if val is None:
 |      | |      |    |   28         if not self.in_transaction:
 ||      |    |    |    188                 val = fn(val)
||    30         self.in_transaction = False
 |    |    |      |   31         rc = 
xshandle().transaction_end(self.transaction, False)
||    |    |      |  > xenstore/xsutil.py:xshandle
 |  |       |    |    | |    15     if not xs_handle:
 189             ret.append(val)
| |      | |       |    |    20     return xs_handle
 |    |    |    |  < xenstore/xsutil.py:xshandle
|    |   172         for tup in args:
|    |    |    |  173             if len(tup) == 2:
|    |    |    |  174                 (key, fn) = tup
|    |    |    |  175                 defval = None
|    |    |    |  179             val = self._read(key)
|    |    |    |  > xenstore/xstransact.py:_read
|    |    |    |    44         path = self.prependPath(key)
|    |    |    |   > xenstore/xstransact.py:prependPath
|    |    |    |    283         if self.path:
|    |    |    |    284             return self.path + '/' + key
|    |    |    |   < xenstore/xstransact.py:prependPath
|    |    |    |    45         try:
|    |    |    |    46             return xshandle().read(self.transaction, 
path)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    32         self.transaction = "0"
| |       ||      |     |  |  < xenstore/xstransact.py:_read
 |      |  |      33         return rc
||     |    |    | < xenstore/xstransact.py:commit
 |     |  |    |    | 355                 return result
 185             if val is None:
|    |    |    | |< xenstore/xstransact.py:complete
 |    |      | |     |    |> xenstore/xstransact.py:__del__
 |    |   | 188                 val = fn(val)
 |    | |       |    | |  24         if self.in_transaction:
 189             ret.append(val)
||      |      | |    | 172         for tup in args:
 |    |    |      |< xenstore/xstransact.py:__del__
||    |    |    < xenstore/xstransact.py:Read
 |    |    |   < XendDomainInfo.py:_readDom
  |  |   173             if len(tup) == 2:
 |    | |      |  1668             if vnc_port is not None:
 |    |    |  1672         return result
||    |    |  < XendDomainInfo.py:sxpr
 |    |    |  > server/XMLRPCServer.py:fixup_sxpr
  174                 (key, fn) = tup
| |      | |    |    |    33     ret = []
 |     175                 defval = None
 | |      |    34     for k in sexpr:
 | |      |  |  179             val = self._read(key)
 |      |  |     |  35         if type(k) in (types.ListType, types.TupleType):
 |     > xenstore/xstransact.py:_read
 |  |      |     39             ret.append(k)
||    |    |     34     for k in sexpr:
 |    |    |     35         if type(k) in (types.ListType, types.TupleType):
  |  |    |    |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |    |     37                 ret.append(fixup_sxpr(k))
 |    |    |    > server/XMLRPCServer.py:fixup_sxpr
  44         path = self.prependPath(key)
| |       ||        | |     |    33     ret = []
> xenstore/xstransact.py:prependPath
| |       ||       |    |  34     for k in sexpr:
 |    |    |    |  35         if type(k) in (types.ListType, types.TupleType):
| |    |       ||    |  39             ret.append(k)
 283         if self.path:
|    |    |    ||   34     for k in sexpr:
 |    |    |    |  35         if type(k) in (types.ListType, types.TupleType):
 |    |    |    |  39             ret.append(k)
 | |    |    |    |  34     for k in sexpr:
 |    |    |    |  40     return ret
 |    | |     |    |< server/XMLRPCServer.py:fixup_sxpr
 |    |    |      34     for k in sexpr:
 |  | 284             return self.path + '/' + key
 |      | |      |  |     < xenstore/xstransact.py:prependPath
 |    35         if type(k) in (types.ListType, types.TupleType):
 |    |    |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |    |     37                 ret.append(fixup_sxpr(k))
 | |      |  |    45         try:
 |       ||       > server/XMLRPCServer.py:fixup_sxpr
 | |       |    |      33     ret = []
  46             return xshandle().read(self.transaction, path)
|    |    |   |    34     for k in sexpr:
 |      ||       |    | | > xenstore/xsutil.py:xshandle
 |    |  35         if type(k) in (types.ListType, types.TupleType):
 |    | |     |   |       |  39             ret.append(k)
 |  |  15     if not xs_handle:
 |  |   |        | |     |  20     return xs_handle
 |   |    34     for k in sexpr:
||        |  |      |< xenstore/xsutil.py:xshandle
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |    |      39             ret.append(k)
| |      |   |      |  |     34     for k in sexpr:
 |      < xenstore/xstransact.py:_read
||    |        | |    185             if val is None:
 |     40     return ret
 |      ||        | |   < server/XMLRPCServer.py:fixup_sxpr
 |      188                 val = fn(val)
||    |      |   |   189             ret.append(val)
 |   34     for k in sexpr:
 |      |   |   |   |    35         if type(k) in (types.ListType, 
types.TupleType):
 |     172         for tup in args:
||       | |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |      | |     190         if len(ret) == 1:
 |    |  |    37                 ret.append(fixup_sxpr(k))
 |   |   192         return ret
 |   |   |        | |    > server/XMLRPCServer.py:fixup_sxpr
 | < xenstore/xstransact.py:gather
 |    |   |       | |  < xenstore/xstransact.py:<lambda>
 |    33     ret = []
 |     |   |  |  354             if t.commit():
 |    |      |  |  34     for k in sexpr:
 |    | > xenstore/xstransact.py:commit
 |    |       |    35         if type(k) in (types.ListType, types.TupleType):
||     28         if not self.in_transaction:
 |   |      | |      |   39             ret.append(k)
 |    |  30         self.in_transaction = False
 |       ||       34     for k in sexpr:
 | |     |   31         rc = xshandle().transaction_end(self.transaction, False)
 |   |    35         if type(k) in (types.ListType, types.TupleType):
 |   |   |        | |    > xenstore/xsutil.py:xshandle
 |     39             ret.append(k)
 |    |  |     |  |       34     for k in sexpr:
  15     if not xs_handle:
| |    |      |   |       20     return xs_handle
||    |     40     return ret
 |      | |       < xenstore/xsutil.py:xshandle
|   < server/XMLRPCServer.py:fixup_sxpr
|    |    |   34     for k in sexpr:
|    |    |   35         if type(k) in (types.ListType, types.TupleType):
|    | |      |  |   |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
  32         self.transaction = "0"
|    |    | |   34     for k in sexpr:
 |   |      |    |   35         if type(k) in (types.ListType, types.TupleType):
 | |   33         return rc
 |      |   |    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |    |   37                 ret.append(fixup_sxpr(k))
||    |    |  > server/XMLRPCServer.py:fixup_sxpr
 |    |    |    33     ret = []
< xenstore/xstransact.py:commit
| |    |       ||     |    34     for k in sexpr:
 350     while True:
| |    |      | |    |   35         if type(k) in (types.ListType, 
types.TupleType):
 |    |    |  351         t = xstransact(path)
  39             ret.append(k)
| |      |    |  > xenstore/xstransact.py:__init__
 |    |    |    14         assert path is not None
||    |        |    34     for k in sexpr:
||    |    |    35         if type(k) in (types.ListType, types.TupleType):
 |    |    |    39             ret.append(k)
 |    |    |    34     for k in sexpr:
  16         self.in_transaction = False # Set this temporarily -- if this
| |    |    |    19         self.path = path.rstrip("/")
 |    |    |    20         self.transaction = xshandle().transaction_start()
  |    |    40     return ret
|    |    |   > xenstore/xsutil.py:xshandle
| |    |    |   < server/XMLRPCServer.py:fixup_sxpr
 |    |    |    34     for k in sexpr:
  |    |     15     if not xs_handle:
|    |    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    |    |    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
||       20     return xs_handle
 |  |    |    37                 ret.append(fixup_sxpr(k))
  ||      |    |   > server/XMLRPCServer.py:fixup_sxpr
 |    |    |     33     ret = []
 ||   < xenstore/xsutil.py:xshandle
   |    |     34     for k in sexpr:
|    |    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    |    39             ret.append(k)
|    |    |    34     for k in sexpr:
|    |    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    |    39             ret.append(k)
|    |    |    34     for k in sexpr:
|  |     |  |   |        21         self.in_transaction = True
||      |  40     return ret
 |    |    |  < server/XMLRPCServer.py:fixup_sxpr
 |    |    |   |   34     for k in sexpr:
 | < xenstore/xstransact.py:__init__
 |      ||       | 352         try:
 |  |   |   35         if type(k) in (types.ListType, types.TupleType):
 |      |    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
||    |    |  37                 ret.append(fixup_sxpr(k))
 353             result = f(t)
|    |    | > server/XMLRPCServer.py:fixup_sxpr
| |    |    |    33     ret = []
 |    |    |    34     for k in sexpr:
 |  |      |  | > xenstore/xstransact.py:<lambda>
 |    |    35         if type(k) in (types.ListType, types.TupleType):
 |    |    |    39             ret.append(k)
 | |        | |     333         return complete(path, lambda t: t.gather(*args))
 | |     34     for k in sexpr:
 |    |    |     35         if type(k) in (types.ListType, types.TupleType):
 | |     |    |    |     39             ret.append(k)
 |    |    |     34     for k in sexpr:
> xenstore/xstransact.py:gather
|    |    |     40     return ret
|   |  |   |    |   < server/XMLRPCServer.py:fixup_sxpr
 |    |    |    34     for k in sexpr:
  |  |     |     |    35         if type(k) in (types.ListType, 
types.TupleType):
 169         if len(args) and type(args[0]) != tuple:
|    |    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |    |   171         ret = []
| |      |    |    37                 ret.append(fixup_sxpr(k))
 |   |  |      |   > server/XMLRPCServer.py:fixup_sxpr
 | |     | 172         for tup in args:
 |    |    |    173             if len(tup) == 2:
 |    |    |    174                 (key, fn) = tup
  |     33     ret = []
| |    |    |     34     for k in sexpr:
 |     |  |       |    175                 defval = None
||    |    |    179             val = self._read(key)
     35         if type(k) in (types.ListType, types.TupleType):
| |    |    |      39             ret.append(k)
 |      |    |      34     for k in sexpr:
||    |    |        35         if type(k) in (types.ListType, types.TupleType):
 |  |      > xenstore/xstransact.py:_read
 | |     |    |      44         path = self.prependPath(key)
 |    |     ||    |> xenstore/xstransact.py:prependPath
|        39             ret.append(k)
 |    |    |    |  34     for k in sexpr:
 |    |    |    |  40     return ret
||       |    |    |    |< server/XMLRPCServer.py:fixup_sxpr
 | | 283         if self.path:
 |    |     |  |    |      34     for k in sexpr:
 |      |    |      35         if type(k) in (types.ListType, types.TupleType):
 284             return self.path + '/' + key
| |      | |      |     | < xenstore/xstransact.py:prependPath
 |      36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |   |       |     37                 ret.append(fixup_sxpr(k))
||    |      |    > server/XMLRPCServer.py:fixup_sxpr
 |    |    |      33     ret = []
  45         try:
|    |    | |      34     for k in sexpr:
 |    |    |      35         if type(k) in (types.ListType, types.TupleType):
  | |    |        46             return xshandle().read(self.transaction, path)
 |    |    ||       | |  > xenstore/xsutil.py:xshandle
 |    39             ret.append(k)
 |    |    |    |  34     for k in sexpr:
 |  |   |    |    |  35         if type(k) in (types.ListType, types.TupleType):
 |      |  |    |    |  39             ret.append(k)
 |    |    |    |  34     for k in sexpr:
 |  |    15     if not xs_handle:
 | |      | |    |  40     return ret
 |    |    |    |< server/XMLRPCServer.py:fixup_sxpr
 |    |    |      34     for k in sexpr:
 |  |      |  20     return xs_handle
 | |      |      35         if type(k) in (types.ListType, types.TupleType):
 |    |    |      36             if len(k) != 2 or k[0] != 'vcpu_avail':
| |      |    < xenstore/xsutil.py:xshandle
 |    |      37                 ret.append(fixup_sxpr(k))
|    |    |    > server/XMLRPCServer.py:fixup_sxpr
|   |  |      | |       |   33     ret = []
 |       |  < xenstore/xstransact.py:_read
 |  |   |     |      34     for k in sexpr:
 |   185             if val is None:
 |   |   |        |  |     35         if type(k) in (types.ListType, 
types.TupleType):
 |    | 188                 val = fn(val)
 |    |     |  |    189             ret.append(val)
 |       39             ret.append(k)
 |    | |    |        34     for k in sexpr:
||      172         for tup in args:
 |  |   |        | |    173             if len(tup) == 2:
 |    35         if type(k) in (types.ListType, types.TupleType):
 |    |  |        |     39             ret.append(k)
|  |  174                 (key, fn) = tup
 |      |   |      |     34     for k in sexpr:
||    |        175                 defval = None
||         40     return ret
||       |   |    |   179             val = self._read(key)
 |     < server/XMLRPCServer.py:fixup_sxpr
||    |        |    > xenstore/xstransact.py:_read
||      34     for k in sexpr:
 |    |  |        | |       35         if type(k) in (types.ListType, 
types.TupleType):
  44         path = self.prependPath(key)
| |      |  |    |      |  > xenstore/xstransact.py:prependPath
 |    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |     |     | 283         if self.path:
 |      |   |    37                 ret.append(fixup_sxpr(k))
 |     |    |      |   284             return self.path + '/' + key
 |  |   |   > server/XMLRPCServer.py:fixup_sxpr
 |   |   |   |< xenstore/xstransact.py:prependPath
 |      |   |  |  33     ret = []
 |    |     |  |        45         try:
 |   34     for k in sexpr:
 |   |       |    |   46             return xshandle().read(self.transaction, 
path)
 |   |     |    35         if type(k) in (types.ListType, types.TupleType):
 |    |       ||> xenstore/xsutil.py:xshandle
 |    |      |  |      |  15     if not xs_handle:
 | |  39             ret.append(k)
 |      | |    |   |      |  20     return xs_handle
 |  |  34     for k in sexpr:
 |      ||       |  |      | |< xenstore/xsutil.py:xshandle
  35         if type(k) in (types.ListType, types.TupleType):
|    |    |      39             ret.append(k)
||     |    |     |  |         34     for k in sexpr:
 |   < xenstore/xstransact.py:_read
 |    | |      |   |   185             if val is None:
 |     40     return ret
 |      ||        | |     < server/XMLRPCServer.py:fixup_sxpr
 188                 val = fn(val)
|   |  |     |   |   |   189             ret.append(val)
 |    |    34     for k in sexpr:
 |     | |    172         for tup in args:
 |      ||        35         if type(k) in (types.ListType, types.TupleType):
||    173             if len(tup) == 2:
 |    |  |    |   174                 (key, fn) = tup
 |    |   |      |   175                 defval = None
  36             if len(k) != 2 or k[0] != 'vcpu_avail':
| |       | |       ||     37                 ret.append(fixup_sxpr(k))
 |  179             val = self._read(key)
 |   |       ||    > server/XMLRPCServer.py:fixup_sxpr
 |    |    |      |> xenstore/xstransact.py:_read
 |        33     ret = []
 | |    |    |    |        44         path = self.prependPath(key)
 |   34     for k in sexpr:
 |   |     |      | |     |> xenstore/xstransact.py:prependPath
 |     |  35         if type(k) in (types.ListType, types.TupleType):
||    |     |      |  |   |  39             ret.append(k)
 283         if self.path:
|    ||        |  |     |  34     for k in sexpr:
 |  |     |    | | 284             return self.path + '/' + key
 |    |   |  35         if type(k) in (types.ListType, types.TupleType):
 |       |  |   |< xenstore/xstransact.py:prependPath
 |   |   |     |  39             ret.append(k)
 |      |   |  |         45         try:
  34     for k in sexpr:
| |      | |       |   |        46             return 
xshandle().read(self.transaction, path)
  40     return ret
|    |  |   |       ||      |> xenstore/xsutil.py:xshandle
 |    |  |< server/XMLRPCServer.py:fixup_sxpr
 |    |      | |  15     if not xs_handle:
 |      | |       |      20     return xs_handle
  34     for k in sexpr:
|  |   |       ||        | < xenstore/xsutil.py:xshandle
     35         if type(k) in (types.ListType, types.TupleType):
|    |    |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    | |       |     37                 ret.append(fixup_sxpr(k))
||       |    |   |  < xenstore/xstransact.py:_read
 |     > server/XMLRPCServer.py:fixup_sxpr
 | |       ||      |   185             if val is None:
 |    |    33     ret = []
 |      | |    188                 val = fn(val)
 |      |    ||    189             ret.append(val)
 |      |    34     for k in sexpr:
 |  |    172         for tup in args:
 |   |     |  |    |     35         if type(k) in (types.ListType, 
types.TupleType):
 |       173             if len(tup) == 2:
||    |      |       39             ret.append(k)
||       174                 (key, fn) = tup
 |   |  |      |  |   175                 defval = None
 |     34     for k in sexpr:
 |   |    |    |       179             val = self._read(key)
||      |    35         if type(k) in (types.ListType, types.TupleType):
 |      | |     |     > xenstore/xstransact.py:_read
 |    |  39             ret.append(k)
 |    |        44         path = self.prependPath(key)
 |  |      ||       34     for k in sexpr:
 |    |     |  |      |> xenstore/xstransact.py:prependPath
 |  |  40     return ret
 |  |    |       |    || 283         if self.path:
 |      |    |< server/XMLRPCServer.py:fixup_sxpr
 |    ||       | 284             return self.path + '/' + key
 |   |   |      34     for k in sexpr:
 |  |      < xenstore/xstransact.py:prependPath
 |    | |       ||        45         try:
 |    |  35         if type(k) in (types.ListType, types.TupleType):
 |     |     |    |    46             return xshandle().read(self.transaction, 
path)
 |      36             if len(k) != 2 or k[0] != 'vcpu_avail':
||    |       |     |      37                 ret.append(fixup_sxpr(k))
> xenstore/xsutil.py:xshandle
| |       ||    |        ||  15     if not xs_handle:
 |       |  |> server/XMLRPCServer.py:fixup_sxpr
 |    |  |      |  20     return xs_handle
 | |      |    |  33     ret = []
 |    | |      |< xenstore/xsutil.py:xshandle
 |    |  34     for k in sexpr:
|    |    |      35         if type(k) in (types.ListType, types.TupleType):
|    ||        | |       |   < xenstore/xstransact.py:_read
 |   39             ret.append(k)
 |      | |       |     34     for k in sexpr:
||       |  185             if val is None:
 |      | |        35         if type(k) in (types.ListType, types.TupleType):
||     188                 val = fn(val)
 |     |    | |         39             ret.append(k)
||     189             ret.append(val)
 |   |       | |      |     34     for k in sexpr:
 172         for tup in args:
| |       | |      |   |     40     return ret
 |   190         if len(ret) == 1:
 |  |       |   |  < server/XMLRPCServer.py:fixup_sxpr
 |     |  |    192         return ret
 |  |    |    34     for k in sexpr:
 |      |  < xenstore/xstransact.py:gather
||      |      ||  < xenstore/xstransact.py:<lambda>
 |     35         if type(k) in (types.ListType, types.TupleType):
 | |       | 354             if t.commit():
||    |       | | > xenstore/xstransact.py:commit
  36             if len(k) != 2 or k[0] != 'vcpu_avail':
| |       | |     |   |  37                 ret.append(fixup_sxpr(k))
 |  28         if not self.in_transaction:
 |     |    |      |    30         self.in_transaction = False
||      > server/XMLRPCServer.py:fixup_sxpr
||    |        |    31         rc = 
xshandle().transaction_end(self.transaction, False)
||        33     ret = []
||        |   > xenstore/xsutil.py:xshandle
||      |      |  |    15     if not xs_handle:
 |    34     for k in sexpr:
 |    |     | |       |   20     return xs_handle
 |       35         if type(k) in (types.ListType, types.TupleType):
||      |     | < xenstore/xsutil.py:xshandle
   |     39             ret.append(k)
|    |    |    34     for k in sexpr:
|    |    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    | |     39             ret.append(k)
 |  |    |    |    34     for k in sexpr:
 |    |    |    40     return ret
 |    |    |  < server/XMLRPCServer.py:fixup_sxpr
 | |    32         self.transaction = "0"
 |     |    |   34     for k in sexpr:
 |    |    |   35         if type(k) in (types.ListType, types.TupleType):
||      |    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |    |   37                 ret.append(fixup_sxpr(k))
 |    |    | |  > server/XMLRPCServer.py:fixup_sxpr
  33         return rc
| |    |    |  < xenstore/xstransact.py:commit
 |     |  |      |  | 355                 return result
 |    |    | < xenstore/xstransact.py:complete
 |   33     ret = []
 |    |    |   34     for k in sexpr:
 |    |    |   35         if type(k) in (types.ListType, types.TupleType):
 |    |    | |   39             ret.append(k)
 |    |    |   34     for k in sexpr:
 |  | > xenstore/xstransact.py:__del__
 |    |    |   24         if self.in_transaction:
 |  |     |   |   35         if type(k) in (types.ListType, types.TupleType):
 |    |    |   < xenstore/xstransact.py:__del__
||    39             ret.append(k)
 |    |    |  34     for k in sexpr:
 |    |    |  40     return ret
 |    |    |< server/XMLRPCServer.py:fixup_sxpr
||       | < xenstore/xstransact.py:Gather
|      34     for k in sexpr:
| |    |     35         if type(k) in (types.ListType, types.TupleType):
 |    |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |     37                 ret.append(fixup_sxpr(k))
 |    |    > server/XMLRPCServer.py:fixup_sxpr
||       < XendDomainInfo.py:_gatherVm
||      |     < XendDomainInfo.py:_readVMDetails
  33     ret = []
|  |   |      |> XendDomainInfo.py:f
 |      |  34     for k in sexpr:
 |    739             if y is not None and self.info[x[0]] != y:
 |      ||        35         if type(k) in (types.ListType, types.TupleType):
< XendDomainInfo.py:f
| |       ||     > XendDomainInfo.py:f
 |   39             ret.append(k)
 |    |     34     for k in sexpr:
 |    |     35         if type(k) in (types.ListType, types.TupleType):
 |    |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
||    |     37                 ret.append(fixup_sxpr(k))
 |    |     739             if y is not None and self.info[x[0]] != y:
 |   > server/XMLRPCServer.py:fixup_sxpr
 |    |      33     ret = []
 |    |      34     for k in sexpr:
|  |     < XendDomainInfo.py:f
 |  |   |       > XendDomainInfo.py:f
  35         if type(k) in (types.ListType, types.TupleType):
| |    |      39             ret.append(k)
 |   |     |      34     for k in sexpr:
 |      739             if y is not None and self.info[x[0]] != y:
||          35         if type(k) in (types.ListType, types.TupleType):
||        |< XendDomainInfo.py:f
 |      36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |        37                 ret.append(fixup_sxpr(k))
||    |    |> server/XMLRPCServer.py:fixup_sxpr
 |    |    |  33     ret = []
 |    |    |  34     for k in sexpr:
 |    |    |  35         if type(k) in (types.ListType, types.TupleType):
 | > XendDomainInfo.py:f
 |      |  |    |  |  39             ret.append(k)
 739             if y is not None and self.info[x[0]] != y:
| |     |     |  |  34     for k in sexpr:
 |   |< XendDomainInfo.py:f
 |    |   |       745         im = self._readVm('image')
 | |     35         if type(k) in (types.ListType, types.TupleType):
||      |    |> XendDomainInfo.py:_readVm
 |    |   |    39             ret.append(k)
||    |  644         return xstransact.Read(self.vmpath, *args)
 |   |  34     for k in sexpr:
 |      | |       | | > xenstore/xstransact.py:Read
  40     return ret
| |    |      | | < server/XMLRPCServer.py:fixup_sxpr
 |       |  |  297         return complete(path, lambda t: t.read(*args))
 |    | |    34     for k in sexpr:
 |     | |  > xenstore/xstransact.py:complete
 |     ||    35         if type(k) in (types.ListType, types.TupleType):
 |   |  350     while True:
 |    |    |      | |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
 351         t = xstransact(path)
| |      |  |     |  |   37                 ret.append(fixup_sxpr(k))
 |   > xenstore/xstransact.py:__init__
 |     |  |   |    |      14         assert path is not None
 |  > server/XMLRPCServer.py:fixup_sxpr
 |    |   |    |   |       33     ret = []
  16         self.in_transaction = False # Set this temporarily -- if this
| |       | |      |  |       19         self.path = path.rstrip("/")
  34     for k in sexpr:
|   |     |  |   |       20         self.transaction = 
xshandle().transaction_start()
 |    | |      |  35         if type(k) in (types.ListType, types.TupleType):
 |    > xenstore/xsutil.py:xshandle
 |    |     |    | |         15     if not xs_handle:
 |   39             ret.append(k)
 |   |     |   |      20     return xs_handle
 |   |       |     34     for k in sexpr:
 |  |    < xenstore/xsutil.py:xshandle
  |    |      35         if type(k) in (types.ListType, types.TupleType):
|    |    |     39             ret.append(k)
|    |    |     34     for k in sexpr:
|    |    |     40     return ret
|    |    |   < server/XMLRPCServer.py:fixup_sxpr
|    |    |    34     for k in sexpr:
|    | |       ||       40     return ret
 |   |   |    |  < server/XMLRPCServer.py:fixup_sxpr
  21         self.in_transaction = True
|    |    |   34     for k in sexpr:
|   |  |    |   < xenstore/xstransact.py:__init__
 |    | |    | 352         try:
 |     |  |  40     return ret
 |    |    |   | 353             result = f(t)
< server/XMLRPCServer.py:fixup_sxpr
| |    |      |  34     for k in sexpr:
 | |    | > xenstore/xstransact.py:<lambda>
 |   |    |  35         if type(k) in (types.ListType, types.TupleType):
 |    |    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |  |       || 297         return complete(path, lambda t: t.read(*args))
 |      |     |  37                 ret.append(fixup_sxpr(k))
||    > xenstore/xstransact.py:read
 | |      | |      |    59         if len(args) == 0:
> server/XMLRPCServer.py:fixup_sxpr
||       |    |    |   |   33     ret = []
 |    |    |    34     for k in sexpr:
  61         if len(args) == 1:
| |    |       ||     62             return self._read(args[0])
 |   |    35         if type(k) in (types.ListType, types.TupleType):
 |    |    |     39             ret.append(k)
 |    |    |     34     for k in sexpr:
 | |    |   > xenstore/xstransact.py:_read
 |    |    |     44         path = self.prependPath(key)
 |    |  |     |       35         if type(k) in (types.ListType, 
types.TupleType):
||    |    > xenstore/xstransact.py:prependPath
 |    |    |     283         if self.path:
 |    |    |     284             return self.path + '/' + key
 |    |    | |      39             ret.append(k)
 |    |    |      34     for k in sexpr:
 |    |    |      40     return ret
 |  < xenstore/xstransact.py:prependPath
 |    |    |     45         try:
  |    |    < server/XMLRPCServer.py:fixup_sxpr
|    |    |   |    |    |    34     for k in sexpr:
  46             return xshandle().read(self.transaction, path)
| |      |   |  |       > xenstore/xsutil.py:xshandle
||        35         if type(k) in (types.ListType, types.TupleType):
||       |   |   15     if not xs_handle:
 |      |  |       36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |    |     37                 ret.append(fixup_sxpr(k))
||    |    |    > server/XMLRPCServer.py:fixup_sxpr
  |    20     return xs_handle
 |      |  |      |      33     ret = []
||    |    |      34     for k in sexpr:
 |    |    |      35         if type(k) in (types.ListType, types.TupleType):
 |   < xenstore/xsutil.py:xshandle
   |    |      39             ret.append(k)
|    |    |     34     for k in sexpr:
|  |   |     |  |       |     35         if type(k) in (types.ListType, 
types.TupleType):
< xenstore/xstransact.py:_read
|    |    |     39             ret.append(k)
|   |  |    |    |       34     for k in sexpr:
||    |    |    < xenstore/xstransact.py:read
  40     return ret
| |    |    | < server/XMLRPCServer.py:fixup_sxpr
 |     |   |    |  34     for k in sexpr:
 |  |    |    |  35         if type(k) in (types.ListType, types.TupleType):
< xenstore/xstransact.py:<lambda>
|  |     |  |    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    354             if t.commit():
 |    |      37                 ret.append(fixup_sxpr(k))
 |    |    | > server/XMLRPCServer.py:fixup_sxpr
 |    |    |   33     ret = []
| |      |> xenstore/xstransact.py:commit
 | |    |   34     for k in sexpr:
 |    |    |   35         if type(k) in (types.ListType, types.TupleType):
 |  |      | |   28         if not self.in_transaction:
 |    |   39             ret.append(k)
 |    |    |   34     for k in sexpr:
 |  |       ||     |   35         if type(k) in (types.ListType, 
types.TupleType):
  30         self.in_transaction = False
| |      |  |       |   39             ret.append(k)
||     31         rc = xshandle().transaction_end(self.transaction, False)
 |   |   |       | |   34     for k in sexpr:
 |  > xenstore/xsutil.py:xshandle
 |  |   |      |     15     if not xs_handle:
 |    |  |    |    40     return ret
  20     return xs_handle
| |      | |    |     < xenstore/xsutil.py:xshandle
 |  < server/XMLRPCServer.py:fixup_sxpr
|    |    |  34     for k in sexpr:
|    |    |  35         if type(k) in (types.ListType, types.TupleType):
|    |    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
| |    |    |  37                 ret.append(fixup_sxpr(k))
 |    |    | > server/XMLRPCServer.py:fixup_sxpr
 |    |    | |    33     ret = []
 |    |    |   34     for k in sexpr:
 |  |  32         self.transaction = "0"
 |      |   |  |   33         return rc
 |      | |     35         if type(k) in (types.ListType, types.TupleType):
 |    |    |   39             ret.append(k)
||    |    | < xenstore/xstransact.py:commit
 |      34     for k in sexpr:
||    |    |  35         if type(k) in (types.ListType, types.TupleType):
 |    |      |  39             ret.append(k)
 |    |   | 355                 return result
 | |  34     for k in sexpr:
 |    |    |  40     return ret
  | |      |< xenstore/xstransact.py:complete
 |  |    |< server/XMLRPCServer.py:fixup_sxpr
 |   |   |      34     for k in sexpr:
 |    |      35         if type(k) in (types.ListType, types.TupleType):
 |    |      36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |      37                 ret.append(fixup_sxpr(k))
||    |    |> server/XMLRPCServer.py:fixup_sxpr
> xenstore/xstransact.py:__del__
| |       |    |  33     ret = []
||    |    |  34     for k in sexpr:
 |    |    |  35         if type(k) in (types.ListType, types.TupleType):
  |  |  24         if self.in_transaction:
 |      |    ||   39             ret.append(k)
 |   |  < xenstore/xstransact.py:__del__
 |  |      |  34     for k in sexpr:
||       < xenstore/xstransact.py:Read
 | |         35         if type(k) in (types.ListType, types.TupleType):
||       |     39             ret.append(k)
< XendDomainInfo.py:_readVm
| |      |  |   746         current_im = self.info['image']
 |     34     for k in sexpr:
 |    |    40     return ret
 |    |  < server/XMLRPCServer.py:fixup_sxpr
| |    |   34     for k in sexpr:
 | 747         if (im is not None and
 |     |   35         if type(k) in (types.ListType, types.TupleType):
  | |  752         if changed:
 |     |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
||   757         return 1
 |      | |   37                 ret.append(fixup_sxpr(k))
< XendDomainInfo.py:_storeChanged
|    |  | > server/XMLRPCServer.py:fixup_sxpr
 |   |    |   33     ret = []
  67             if not res:
|    |   34     for k in sexpr:
| |    |   35         if type(k) in (types.ListType, types.TupleType):
 |    |   39             ret.append(k)
 | |     62     while True:
 |  |   34     for k in sexpr:
 |    |   35         if type(k) in (types.ListType, types.TupleType):
  | |     63         try:
 |   |  |   64             we = xs.read_watch()
  39             ret.append(k)
|    |   34     for k in sexpr:
|   |  |    |   40     return ret
  65             watch = we[1]
| |      | |   66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
 |    |< server/XMLRPCServer.py:fixup_sxpr
 |    |   34     for k in sexpr:
 | > XendDomainInfo.py:_handleShutdownWatch
 |      | |   35         if type(k) in (types.ListType, types.TupleType):
 760         log.debug('XendDomainInfo.handleShutdownWatch')
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    ||       37                 ret.append(fixup_sxpr(k))
||    |  > server/XMLRPCServer.py:fixup_sxpr
  762         reason = self._readDom('control/shutdown')
| |      |  |    > XendDomainInfo.py:_readDom
  33     ret = []
| |    |     34     for k in sexpr:
 |   |      | 663         return xstransact.Read(self.dompath, *args)
 |      |  35         if type(k) in (types.ListType, types.TupleType):
 |    |      39             ret.append(k)
 |    |      34     for k in sexpr:
 |    |      35         if type(k) in (types.ListType, types.TupleType):
|  > xenstore/xstransact.py:Read
 |    |     |   297         return complete(path, lambda t: t.read(*args))
 |       39             ret.append(k)
 |    |    |  34     for k in sexpr:
| |      | |    |  40     return ret
> xenstore/xstransact.py:complete
| |      |     | 350     while True:
||      |    | 351         t = xstransact(path)
 |    | |   < server/XMLRPCServer.py:fixup_sxpr
 |    |    |  34     for k in sexpr:
||    |    |  35         if type(k) in (types.ListType, types.TupleType):
 |    |    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
> xenstore/xstransact.py:__init__
| |      |   |    |  14         assert path is not None
 |    | |   37                 ret.append(fixup_sxpr(k))
 |     |  16         self.in_transaction = False # Set this temporarily -- if 
this
 | |      |     ||  > server/XMLRPCServer.py:fixup_sxpr
  19         self.path = path.rstrip("/")
||        ||        | |   20         self.transaction = 
xshandle().transaction_start()
  33     ret = []
| |       ||      |    |    34     for k in sexpr:
> xenstore/xsutil.py:xshandle
| |      |    |    35         if type(k) in (types.ListType, types.TupleType):
 | |     |    15     if not xs_handle:
 |   |  |        | |    20     return xs_handle
   39             ret.append(k)
| |     |    |    |   34     for k in sexpr:
 |   |  < xenstore/xsutil.py:xshandle
   |    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    |   39             ret.append(k)
|    |    |   34     for k in sexpr:
|    |    |   40     return ret
|    |    | < server/XMLRPCServer.py:fixup_sxpr
|    |    |  34     for k in sexpr:
|    |    |  35         if type(k) in (types.ListType, types.TupleType):
||        | |    |  21         self.in_transaction = True
 |   |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |    |  37                 ret.append(fixup_sxpr(k))
 |    |    | > server/XMLRPCServer.py:fixup_sxpr
 | |    |    |   33     ret = []
 |    |    |   34     for k in sexpr:
 |    |    |   35         if type(k) in (types.ListType, types.TupleType):
 | |< xenstore/xstransact.py:__init__
 |    |    |   39             ret.append(k)
 |    |    |  34     for k in sexpr:
 |    |    |  35         if type(k) in (types.ListType, types.TupleType):
||    |      |  39             ret.append(k)
 |    | |    |  34     for k in sexpr:
 352         try:
| |    |    | 353             result = f(t)
   |    |  40     return ret
|    |    | > xenstore/xstransact.py:<lambda>
|    |    | < server/XMLRPCServer.py:fixup_sxpr
| |    |    |  297         return complete(path, lambda t: t.read(*args))
 |    |    | > xenstore/xstransact.py:read
  |    |  34     for k in sexpr:
| |    |    |     35         if type(k) in (types.ListType, types.TupleType):
 | |      |   59         if len(args) == 0:
 | |    |    |   61         if len(args) == 1:
 |    |      | |   62             return self._read(args[0])
  36             if len(k) != 2 or k[0] != 'vcpu_avail':
| |    |    |    37                 ret.append(fixup_sxpr(k))
 |    |      |   > server/XMLRPCServer.py:fixup_sxpr
||    |    |     33     ret = []
 |    |    |       34     for k in sexpr:
 | |    > xenstore/xstransact.py:_read
 |    |    | |     44         path = self.prependPath(key)
 |    |    |    > xenstore/xstransact.py:prependPath
 |  |     |     35         if type(k) in (types.ListType, types.TupleType):
 |  |   |    |      39             ret.append(k)
 |    |    |      34     for k in sexpr:
 |      283         if self.path:
 |    |    | |     284             return self.path + '/' + key
 |    |     |    |    < xenstore/xstransact.py:prependPath
 |   35         if type(k) in (types.ListType, types.TupleType):
 |    |    |     39             ret.append(k)
  | |      |    |     34     for k in sexpr:
 |    |    |     40     return ret
||    |    |   < server/XMLRPCServer.py:fixup_sxpr
  |    45         try:
 |    |    |    46             return xshandle().read(self.transaction, path)
  |    |    34     for k in sexpr:
|    |    |   | > xenstore/xsutil.py:xshandle
 |    |   |      |     15     if not xs_handle:
 | |       35         if type(k) in (types.ListType, types.TupleType):
 |    |    |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
||    |    |      |      37                 ret.append(fixup_sxpr(k))
  20     return xs_handle
| |       ||     |    > server/XMLRPCServer.py:fixup_sxpr
 |    |    |      33     ret = []
 |    |    |      34     for k in sexpr:
 | |    < xenstore/xsutil.py:xshandle
   |    |      35         if type(k) in (types.ListType, types.TupleType):
|    |    |     39             ret.append(k)
|    ||     |     34     for k in sexpr:
 |   |      |    |     35         if type(k) in (types.ListType, 
types.TupleType):
 |    |    |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
||    |    |     37                 ret.append(fixup_sxpr(k))
 |   < xenstore/xstransact.py:_read
 |     |    |    > server/XMLRPCServer.py:fixup_sxpr
 |    |    |     33     ret = []
||    |    |       34     for k in sexpr:
 |  |     |    |     35         if type(k) in (types.ListType, types.TupleType):
 |    |    |   < xenstore/xstransact.py:read
  39             ret.append(k)
| |    |    |    34     for k in sexpr:
 |    |    |    35         if type(k) in (types.ListType, types.TupleType):
  | |      |  | < xenstore/xstransact.py:<lambda>
 |    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |    |   37                 ret.append(fixup_sxpr(k))
 |    |    |  > server/XMLRPCServer.py:fixup_sxpr
 |    |    |    33     ret = []
||    |    |    34     for k in sexpr:
 |       |    |    35         if type(k) in (types.ListType, types.TupleType):
||    |    |    39             ret.append(k)
  354             if t.commit():
| |      |  |      |    34     for k in sexpr:
 |    |    |     35         if type(k) in (types.ListType, types.TupleType):
||    |    |     39             ret.append(k)
   > xenstore/xstransact.py:commit
| |       |    |     34     for k in sexpr:
||     |       28         if not self.in_transaction:
 |  |   |     |     40     return ret
 |    |    |   < server/XMLRPCServer.py:fixup_sxpr
 ||        30         self.in_transaction = False
 |  |     |    | |      34     for k in sexpr:
  31         rc = xshandle().transaction_end(self.transaction, False)
|  |      | |       ||    > xenstore/xsutil.py:xshandle
 |   35         if type(k) in (types.ListType, types.TupleType):
 |    |    |     |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |   |   |    |     37                 ret.append(fixup_sxpr(k))
 |    |        15     if not xs_handle:
||      |     > server/XMLRPCServer.py:fixup_sxpr
 |   |   |    |      33     ret = []
 |    20     return xs_handle
 |    |     |  |         34     for k in sexpr:
||    |    |      35         if type(k) in (types.ListType, types.TupleType):
 |    |    |        39             ret.append(k)
 | < xenstore/xsutil.py:xshandle
   |    |      34     for k in sexpr:
|    |    |     35         if type(k) in (types.ListType, types.TupleType):
|    |    |     39             ret.append(k)
| |    |      |   |     34     for k in sexpr:
 |  |     32         self.transaction = "0"
 |    |    |     33         return rc
 |  |      |     40     return ret
 | |     |    |     < xenstore/xstransact.py:commit
||    |      |   355                 return result
 | < server/XMLRPCServer.py:fixup_sxpr
 |    |    |   34     for k in sexpr:
 |    |    |   35         if type(k) in (types.ListType, types.TupleType):
 | |    |  < xenstore/xstransact.py:complete
 |    |    | > xenstore/xstransact.py:__del__
  |    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
| |    |    |   37                 ret.append(fixup_sxpr(k))
   |    |   24         if self.in_transaction:
|    |    |  > server/XMLRPCServer.py:fixup_sxpr
| |      |    |  < xenstore/xstransact.py:__del__
 |    |    | | < xenstore/xstransact.py:Read
 |      |    |< XendDomainInfo.py:_readDom
||     33     ret = []
 |    |      34     for k in sexpr:
 |  |       764         if reason and reason != 'suspend':
 | |        35         if type(k) in (types.ListType, types.TupleType):
 | |       |      39             ret.append(k)
 780         return True
|    |      34     for k in sexpr:
|    |    < XendDomainInfo.py:_handleShutdownWatch
|    |      35         if type(k) in (types.ListType, types.TupleType):
|    |   |   67             if not res:
 |     |  |      39             ret.append(k)
 |   62     while True:
 |    |     63         try:
 |    |     64             we = xs.read_watch()
 |     34     for k in sexpr:
|    |     40     return ret
|    |   < server/XMLRPCServer.py:fixup_sxpr
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |    37                 ret.append(fixup_sxpr(k))
|    |   > server/XMLRPCServer.py:fixup_sxpr
|    |     33     ret = []
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     40     return ret
|    |   < server/XMLRPCServer.py:fixup_sxpr
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |    37                 ret.append(fixup_sxpr(k))
|    |   > server/XMLRPCServer.py:fixup_sxpr
|    |     33     ret = []
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     40     return ret
|    |   < server/XMLRPCServer.py:fixup_sxpr
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  40     return ret
|    |< server/XMLRPCServer.py:fixup_sxpr
|    < server/XMLRPCServer.py:domain_create
|    153             while self.running:
|    154                 self.server.handle_request()
|    > server/XMLRPCServer.py:dispatch
|      49     info = lookup(domid)
|    |> server/XMLRPCServer.py:lookup
|    |  43     info = XendDomain.instance().domain_lookup(domid)
|    | > XendDomain.py:instance
|    | 1333     try:
|    | 1334         inst
|    | 1338     return inst
|    | < XendDomain.py:instance
|    | > XendDomain.py:domain_lookup
|    |  465         self.domains_lock.acquire()
|    |  466         try:
|    |  467             self._refresh()
|    |  > XendDomain.py:_refresh
|    |   379         running = self._running_domains()
|    |   > XendDomain.py:_running_domains
|    |    343         try:
|    |    344             return xc.domain_getinfo()
|    |   < XendDomain.py:_running_domains
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 206     ('image',        lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     783             if d_type not in XendDevices.valid_devices():
|    |    |> XendDevices.py:valid_devices
|    |    |  48         return cls.controllers.keys()
|    |    |< XendDevices.py:valid_devices
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |  < XendDomain.py:_refresh
|    |  468             dom = self.domain_lookup_nr(domid)
|    |  > XendDomain.py:domain_lookup_nr
|    |   485         self.domains_lock.acquire()
|    |   486         try:
|    |   488             match = [dom for dom in self.domains.values() \
|    |   > XendDomainInfo.py:getName
|    |    797         return self.info['name']
|    |   < XendDomainInfo.py:getName
|    |   488             match = [dom for dom in self.domains.values() \
|    |   > XendDomainInfo.py:getName
|    |    797         return self.info['name']
|    |   < XendDomainInfo.py:getName
|    |   488             match = [dom for dom in self.domains.values() \
|    |   490             if match:
|    |   491                 return match[0]
|    |   517             self.domains_lock.release()
|    |  < XendDomain.py:domain_lookup_nr
|    |  469             if not dom:
|    |  471             return dom
|    |  473             self.domains_lock.release()
|    | < XendDomain.py:domain_lookup
|    |  44     if not info:
|    |  46     return info
|    |< server/XMLRPCServer.py:lookup
|      50     return getattr(info, fn)(*args)
|    |> XendDomainInfo.py:waitForDevices
|    | 539         for devclass in XendDevices.valid_devices():
|    | > XendDevices.py:valid_devices
|    |   48         return cls.controllers.keys()
|    | < XendDevices.py:valid_devices
|    | 540             self.getDeviceController(devclass).waitForDevices()
|    | > XendDomainInfo.py:getDeviceController
|    | 1152         if name not in self._deviceControllers:
|    | 1158         return self._deviceControllers[name]
|    | < XendDomainInfo.py:getDeviceController
|    | > server/DevController.py:waitForDevices
|    |  143         log.debug("Waiting for devices %s.", self.deviceClass)
|    |  144         return map(self.waitForDevice, self.deviceIDs())
|    |  > server/DevController.py:deviceIDs
|    |   368         fe = self.backendRoot()
|    |   > server/DevController.py:backendRoot
|    |    476         from xen.xend.XendDomain import DOM0_ID
|    |    477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    > xenstore/xsutil.py:GetDomainPath
|    |      26     return xshandle().get_domain_path(domid)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |    < xenstore/xsutil.py:GetDomainPath
|    |    > XendDomainInfo.py:getDomid
|    |     789         return self.domid
|    |    < XendDomainInfo.py:getDomid
|    |   < server/DevController.py:backendRoot
|    |   369         if transaction:
|    |   372             return map(int, xstransact.List(fe))
|    |   > xenstore/xstransact.py:List
|    |    319         return complete(path, lambda t: t.list(*args))
|    |    > xenstore/xstransact.py:complete
|    |     350     while True:
|    |     351         t = xstransact(path)
|    |    |> xenstore/xstransact.py:__init__
|    |    |  14         assert path is not None
|    |    |  16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |  19         self.path = path.rstrip("/")
|    |    |  20         self.transaction = xshandle().transaction_start()
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  21         self.in_transaction = True
|    |    |< xenstore/xstransact.py:__init__
|    |     352         try:
|    |     353             result = f(t)
|    |    |> xenstore/xstransact.py:<lambda>
|    |    | 319         return complete(path, lambda t: t.list(*args))
|    |    | > xenstore/xstransact.py:list
|    |    |  129         if len(args) == 0:
|    |    |  130             ret = xshandle().ls(self.transaction, self.path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |  131             if ret is None:
|    |    |  132                 return []
|    |    | < xenstore/xstransact.py:list
|    |    |< xenstore/xstransact.py:<lambda>
|    |     354             if t.commit():
|    |    |> xenstore/xstransact.py:commit
|    |    |  28         if not self.in_transaction:
|    |    |  30         self.in_transaction = False
|    |    |  31         rc = xshandle().transaction_end(self.transaction, False)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  32         self.transaction = "0"
|    |    |  33         return rc
|    |    |< xenstore/xstransact.py:commit
|    |     355                 return result
|    |    < xenstore/xstransact.py:complete
|    |    > xenstore/xstransact.py:__del__
|    |      24         if self.in_transaction:
|    |    < xenstore/xstransact.py:__del__
|    |   < xenstore/xstransact.py:List
|    |  < server/DevController.py:deviceIDs
|    | < server/DevController.py:waitForDevices
|    | 539         for devclass in XendDevices.valid_devices():
|    | 540             self.getDeviceController(devclass).waitForDevices()
|    | > XendDomainInfo.py:getDeviceController
|    | 1152         if name not in self._deviceControllers:
|    | 1158         return self._deviceControllers[name]
|    | < XendDomainInfo.py:getDeviceController
|    | > server/DevController.py:waitForDevices
|    |  143         log.debug("Waiting for devices %s.", self.deviceClass)
|    |  144         return map(self.waitForDevice, self.deviceIDs())
|    |  > server/DevController.py:deviceIDs
|    |   368         fe = self.backendRoot()
|    |   > server/DevController.py:backendRoot
|    |    476         from xen.xend.XendDomain import DOM0_ID
|    |    477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    > xenstore/xsutil.py:GetDomainPath
|    |      26     return xshandle().get_domain_path(domid)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |    < xenstore/xsutil.py:GetDomainPath
|    |    > XendDomainInfo.py:getDomid
|    |     789         return self.domid
|    |    < XendDomainInfo.py:getDomid
|    |   < server/DevController.py:backendRoot
|    |   369         if transaction:
|    |   372             return map(int, xstransact.List(fe))
|    |   > xenstore/xstransact.py:List
|    |    319         return complete(path, lambda t: t.list(*args))
|    |    > xenstore/xstransact.py:complete
|    |     350     while True:
|    |     351         t = xstransact(path)
|    |    |> xenstore/xstransact.py:__init__
|    |    |  14         assert path is not None
|    |    |  16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |  19         self.path = path.rstrip("/")
|    |    |  20         self.transaction = xshandle().transaction_start()
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  21         self.in_transaction = True
|    |    |< xenstore/xstransact.py:__init__
|    |     352         try:
|    |     353             result = f(t)
|    |    |> xenstore/xstransact.py:<lambda>
|    |    | 319         return complete(path, lambda t: t.list(*args))
|    |    | > xenstore/xstransact.py:list
|    |    |  129         if len(args) == 0:
|    |    |  130             ret = xshandle().ls(self.transaction, self.path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |  131             if ret is None:
|    |    |  132                 return []
|    |    | < xenstore/xstransact.py:list
|    |    |< xenstore/xstransact.py:<lambda>
|    |     354             if t.commit():
|    |    |> xenstore/xstransact.py:commit
|    |    |  28         if not self.in_transaction:
|    |    |  30         self.in_transaction = False
|    |    |  31         rc = xshandle().transaction_end(self.transaction, False)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  32         self.transaction = "0"
|    |    |  33         return rc
|    |    |< xenstore/xstransact.py:commit
|    |     355                 return result
|    |    < xenstore/xstransact.py:complete
|    |    > xenstore/xstransact.py:__del__
|    |      24         if self.in_transaction:
|    |    < xenstore/xstransact.py:__del__
|    |   < xenstore/xstransact.py:List
|    |  < server/DevController.py:deviceIDs
|    | < server/DevController.py:waitForDevices
|    | 539         for devclass in XendDevices.valid_devices():
|    | 540             self.getDeviceController(devclass).waitForDevices()
|    | > XendDomainInfo.py:getDeviceController
|    | 1152         if name not in self._deviceControllers:
|    | 1158         return self._deviceControllers[name]
|    | < XendDomainInfo.py:getDeviceController
|    | > server/DevController.py:waitForDevices
|    |  143         log.debug("Waiting for devices %s.", self.deviceClass)
|    |  144         return map(self.waitForDevice, self.deviceIDs())
|    |  > server/DevController.py:deviceIDs
|    |   368         fe = self.backendRoot()
|    |   > server/DevController.py:backendRoot
|    |    476         from xen.xend.XendDomain import DOM0_ID
|    |    477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    > xenstore/xsutil.py:GetDomainPath
|    |      26     return xshandle().get_domain_path(domid)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |    < xenstore/xsutil.py:GetDomainPath
|    |    > XendDomainInfo.py:getDomid
|    |     789         return self.domid
|    |    < XendDomainInfo.py:getDomid
|    |   < server/DevController.py:backendRoot
|    |   369         if transaction:
|    |   372             return map(int, xstransact.List(fe))
|    |   > xenstore/xstransact.py:List
|    |    319         return complete(path, lambda t: t.list(*args))
|    |    > xenstore/xstransact.py:complete
|    |     350     while True:
|    |     351         t = xstransact(path)
|    |    |> xenstore/xstransact.py:__init__
|    |    |  14         assert path is not None
|    |    |  16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |  19         self.path = path.rstrip("/")
|    |    |  20         self.transaction = xshandle().transaction_start()
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  21         self.in_transaction = True
|    |    |< xenstore/xstransact.py:__init__
|    |     352         try:
|    |     353             result = f(t)
|    |    |> xenstore/xstransact.py:<lambda>
|    |    | 319         return complete(path, lambda t: t.list(*args))
|    |    | > xenstore/xstransact.py:list
|    |    |  129         if len(args) == 0:
|    |    |  130             ret = xshandle().ls(self.transaction, self.path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |  131             if ret is None:
|    |    |  134                 return ret
|    |    | < xenstore/xstransact.py:list
|    |    |< xenstore/xstransact.py:<lambda>
|    |     354             if t.commit():
|    |    |> xenstore/xstransact.py:commit
|    |    |  28         if not self.in_transaction:
|    |    |  30         self.in_transaction = False
|    |    |  31         rc = xshandle().transaction_end(self.transaction, False)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  32         self.transaction = "0"
|    |    |  33         return rc
|    |    |< xenstore/xstransact.py:commit
|    |     355                 return result
|    |    < xenstore/xstransact.py:complete
|    |    > xenstore/xstransact.py:__del__
|    |      24         if self.in_transaction:
|    |    < xenstore/xstransact.py:__del__
|    |   < xenstore/xstransact.py:List
|    |  < server/DevController.py:deviceIDs
|    |  > server/DevController.py:waitForDevice
|    |   148         log.debug("Waiting for %s.", devid)
|    |   150         status = self.waitForBackend(devid)
|    |   > server/DevController.py:waitForBackend
|    |    441         frontpath = self.frontendPath(devid)
|    |    > server/DevController.py:frontendPath
|    |     468         return "%s/%d" % (self.frontendRoot(), devid)
|    |    |> server/DevController.py:frontendRoot
|    |    | 472         return "%s/device/%s" % (self.vm.getDomainPath(), 
self.deviceClass)
|    |    | > XendDomainInfo.py:getDomainPath
|    |    |  800         return self.dompath
|    |    | < XendDomainInfo.py:getDomainPath
|    |    |< server/DevController.py:frontendRoot
|    |    < server/DevController.py:frontendPath
|    |    442         backpath = xstransact.Read(frontpath, "backend")
|    |    > xenstore/xstransact.py:Read
|    |     297         return complete(path, lambda t: t.read(*args))
|    |    |> xenstore/xstransact.py:complete
|    |    | 350     while True:
|    |    | 351         t = xstransact(path)
|    |    | > xenstore/xstransact.py:__init__
|    |    |   14         assert path is not None
|    |    |   16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |   19         self.path = path.rstrip("/")
|    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |   21         self.in_transaction = True
|    |    | < xenstore/xstransact.py:__init__
|    |    | 352         try:
|    |    | 353             result = f(t)
|    |    | > xenstore/xstransact.py:<lambda>
|    |    |  297         return complete(path, lambda t: t.read(*args))
|    |    |  > xenstore/xstransact.py:read
|    |    |    59         if len(args) == 0:
|    |    |    61         if len(args) == 1:
|    |    |    62             return self._read(args[0])
|    |    |   > xenstore/xstransact.py:_read
|    |    |     44         path = self.prependPath(key)
|    |    |    > xenstore/xstransact.py:prependPath
|    |    |     283         if self.path:
|    |    |     284             return self.path + '/' + key
|    |    |    < xenstore/xstransact.py:prependPath
|    |    |     45         try:
|    |    |     46             return xshandle().read(self.transaction, path)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |   < xenstore/xstransact.py:_read
|    |    |  < xenstore/xstransact.py:read
|    |    | < xenstore/xstransact.py:<lambda>
|    |    | 354             if t.commit():
|    |    | > xenstore/xstransact.py:commit
|    |    |   28         if not self.in_transaction:
|    |    |   30         self.in_transaction = False
|    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |   32         self.transaction = "0"
|    |    |   33         return rc
|    |    | < xenstore/xstransact.py:commit
|    |    | 355                 return result
|    |    |< xenstore/xstransact.py:complete
|    |    |> xenstore/xstransact.py:__del__
|    |    |  24         if self.in_transaction:
|    |    |< xenstore/xstransact.py:__del__
|    |    < xenstore/xstransact.py:Read
|    |    444         if backpath:
|    |    445             statusPath = backpath + '/' + HOTPLUG_STATUS_NODE
|    |    446             ev = Event()
|    |    447             result = { 'status': Timeout }
|    |    449             xswatch(statusPath, hotplugStatusCallback, ev, result)
|    |    > xenstore/xswatch.py:__init__
|    |      29         self.path = path
|    |      30         self.fn = fn
|    |      31         self.args = args
|    |      32         self.kwargs = kwargs
|    |      33         watchStart()
|    |    |> xenstore/xswatch.py:watchStart
|    |    |  49     xslock.acquire()
|    |    |  50     try:
|    |    |  51         if watchThread:
|    |    |  52             return
|    |    |  58         xslock.release()
|    |    |< xenstore/xswatch.py:watchStart
|    |      34         xs.watch(path, self)
|    |      65             watch = we[1]
|    |      66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    |    |> server/DevController.py:hotplugStatusCallback
|    |    | 487     log.debug("hotplugStatusCallback %s.", statusPath)
|    |    | 489     status = xstransact.Read(statusPath)
|    |    | > xenstore/xstransact.py:Read
|    |    |  297         return complete(path, lambda t: t.read(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    297         return complete(path, lambda t: t.read(*args))
|    |    |    > xenstore/xstransact.py:read
|    |    |      59         if len(args) == 0:
|    |    |      60             return xshandle().read(self.transaction, 
self.path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    < xenstore/xstransact.py:read
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:Read
|    |    | 491     if status is not None:
|    |    | 492         if status == HOTPLUG_STATUS_ERROR:
|    |    | 494         elif status == HOTPLUG_STATUS_BUSY:
|    |    | 497             result['status'] = Connected
|    |    | 501     log.debug("hotplugStatusCallback %d.", result['status'])
|    |    | 503     ev.set()
|    |    | 504     return 0
|    |    |< server/DevController.py:hotplugStatusCallback
|    |      67             if not res:
|    |      68                 watch.unwatch()
|    |    |> xenstore/xswatch.py:unwatch
|    |    |  38         xs.unwatch(self.path, self)
|    |    |< xenstore/xswatch.py:unwatch
|    |      62     while True:
|    |      63         try:
|    |      64             we = xs.read_watch()
|    |    < xenstore/xswatch.py:__init__
|    |    451             ev.wait(DEVICE_CREATE_TIMEOUT)
|    |    452             return result['status']
|    |   < server/DevController.py:waitForBackend
|    |   152         if status == Timeout:
|    |   158         elif status == Error:
|    |   164         elif status == Missing:
|    |   169         elif status == Busy:
|    |  < server/DevController.py:waitForDevice
|    | < server/DevController.py:waitForDevices
|    | 539         for devclass in XendDevices.valid_devices():
|    | 540             self.getDeviceController(devclass).waitForDevices()
|    | > XendDomainInfo.py:getDeviceController
|    | 1152         if name not in self._deviceControllers:
|    | 1158         return self._deviceControllers[name]
|    | < XendDomainInfo.py:getDeviceController
|    | > server/DevController.py:waitForDevices
|    |  143         log.debug("Waiting for devices %s.", self.deviceClass)
|    |  144         return map(self.waitForDevice, self.deviceIDs())
|    |  > server/DevController.py:deviceIDs
|    |   368         fe = self.backendRoot()
|    |   > server/DevController.py:backendRoot
|    |    476         from xen.xend.XendDomain import DOM0_ID
|    |    477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    > xenstore/xsutil.py:GetDomainPath
|    |      26     return xshandle().get_domain_path(domid)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |    < xenstore/xsutil.py:GetDomainPath
|    |    > XendDomainInfo.py:getDomid
|    |     789         return self.domid
|    |    < XendDomainInfo.py:getDomid
|    |   < server/DevController.py:backendRoot
|    |   369         if transaction:
|    |   372             return map(int, xstransact.List(fe))
|    |   > xenstore/xstransact.py:List
|    |    319         return complete(path, lambda t: t.list(*args))
|    |    > xenstore/xstransact.py:complete
|    |     350     while True:
|    |     351         t = xstransact(path)
|    |    |> xenstore/xstransact.py:__init__
|    |    |  14         assert path is not None
|    |    |  16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |  19         self.path = path.rstrip("/")
|    |    |  20         self.transaction = xshandle().transaction_start()
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  21         self.in_transaction = True
|    |    |< xenstore/xstransact.py:__init__
|    |     352         try:
|    |     353             result = f(t)
|    |    |> xenstore/xstransact.py:<lambda>
|    |    | 319         return complete(path, lambda t: t.list(*args))
|    |    | > xenstore/xstransact.py:list
|    |    |  129         if len(args) == 0:
|    |    |  130             ret = xshandle().ls(self.transaction, self.path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |  131             if ret is None:
|    |    |  132                 return []
|    |    | < xenstore/xstransact.py:list
|    |    |< xenstore/xstransact.py:<lambda>
|    |     354             if t.commit():
|    |    |> xenstore/xstransact.py:commit
|    |    |  28         if not self.in_transaction:
|    |    |  30         self.in_transaction = False
|    |    |  31         rc = xshandle().transaction_end(self.transaction, False)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  32         self.transaction = "0"
|    |    |  33         return rc
|    |    |< xenstore/xstransact.py:commit
|    |     355                 return result
|    |    < xenstore/xstransact.py:complete
|    |    > xenstore/xstransact.py:__del__
|    |      24         if self.in_transaction:
|    |    < xenstore/xstransact.py:__del__
|    |   < xenstore/xstransact.py:List
|    |  < server/DevController.py:deviceIDs
|    | < server/DevController.py:waitForDevices
|    | 539         for devclass in XendDevices.valid_devices():
|    | 540             self.getDeviceController(devclass).waitForDevices()
|    | > XendDomainInfo.py:getDeviceController
|    | 1152         if name not in self._deviceControllers:
|    | 1158         return self._deviceControllers[name]
|    | < XendDomainInfo.py:getDeviceController
|    | > server/DevController.py:waitForDevices
|    |  143         log.debug("Waiting for devices %s.", self.deviceClass)
|    |  144         return map(self.waitForDevice, self.deviceIDs())
|    |  > server/DevController.py:deviceIDs
|    |   368         fe = self.backendRoot()
|    |   > server/DevController.py:backendRoot
|    |    476         from xen.xend.XendDomain import DOM0_ID
|    |    477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    > xenstore/xsutil.py:GetDomainPath
|    |      26     return xshandle().get_domain_path(domid)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |    < xenstore/xsutil.py:GetDomainPath
|    |    > XendDomainInfo.py:getDomid
|    |     789         return self.domid
|    |    < XendDomainInfo.py:getDomid
|    |   < server/DevController.py:backendRoot
|    |   369         if transaction:
|    |   372             return map(int, xstransact.List(fe))
|    |   > xenstore/xstransact.py:List
|    |    319         return complete(path, lambda t: t.list(*args))
|    |    > xenstore/xstransact.py:complete
|    |     350     while True:
|    |     351         t = xstransact(path)
|    |    |> xenstore/xstransact.py:__init__
|    |    |  14         assert path is not None
|    |    |  16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |  19         self.path = path.rstrip("/")
|    |    |  20         self.transaction = xshandle().transaction_start()
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  21         self.in_transaction = True
|    |    |< xenstore/xstransact.py:__init__
|    |     352         try:
|    |     353             result = f(t)
|    |    |> xenstore/xstransact.py:<lambda>
|    |    | 319         return complete(path, lambda t: t.list(*args))
|    |    | > xenstore/xstransact.py:list
|    |    |  129         if len(args) == 0:
|    |    |  130             ret = xshandle().ls(self.transaction, self.path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |  131             if ret is None:
|    |    |  132                 return []
|    |    | < xenstore/xstransact.py:list
|    |    |< xenstore/xstransact.py:<lambda>
|    |     354             if t.commit():
|    |    |> xenstore/xstransact.py:commit
|    |    |  28         if not self.in_transaction:
|    |    |  30         self.in_transaction = False
|    |    |  31         rc = xshandle().transaction_end(self.transaction, False)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  32         self.transaction = "0"
|    |    |  33         return rc
|    |    |< xenstore/xstransact.py:commit
|    |     355                 return result
|    |    < xenstore/xstransact.py:complete
|    |    > xenstore/xstransact.py:__del__
|    |      24         if self.in_transaction:
|    |    < xenstore/xstransact.py:__del__
|    |   < xenstore/xstransact.py:List
|    |  < server/DevController.py:deviceIDs
|    | < server/DevController.py:waitForDevices
|    | 539         for devclass in XendDevices.valid_devices():
|    | 540             self.getDeviceController(devclass).waitForDevices()
|    | > XendDomainInfo.py:getDeviceController
|    | 1152         if name not in self._deviceControllers:
|    | 1158         return self._deviceControllers[name]
|    | < XendDomainInfo.py:getDeviceController
|    | > server/DevController.py:waitForDevices
|    |  143         log.debug("Waiting for devices %s.", self.deviceClass)
|    |  144         return map(self.waitForDevice, self.deviceIDs())
|    |  > server/DevController.py:deviceIDs
|    |   368         fe = self.backendRoot()
|    |   > server/DevController.py:backendRoot
|    |    476         from xen.xend.XendDomain import DOM0_ID
|    |    477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    > xenstore/xsutil.py:GetDomainPath
|    |      26     return xshandle().get_domain_path(domid)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |    < xenstore/xsutil.py:GetDomainPath
|    |    > XendDomainInfo.py:getDomid
|    |     789         return self.domid
|    |    < XendDomainInfo.py:getDomid
|    |   < server/DevController.py:backendRoot
|    |   369         if transaction:
|    |   372             return map(int, xstransact.List(fe))
|    |   > xenstore/xstransact.py:List
|    |    319         return complete(path, lambda t: t.list(*args))
|    |    > xenstore/xstransact.py:complete
|    |     350     while True:
|    |     351         t = xstransact(path)
|    |    |> xenstore/xstransact.py:__init__
|    |    |  14         assert path is not None
|    |    |  16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |  19         self.path = path.rstrip("/")
|    |    |  20         self.transaction = xshandle().transaction_start()
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  21         self.in_transaction = True
|    |    |< xenstore/xstransact.py:__init__
|    |     352         try:
|    |     353             result = f(t)
|    |    |> xenstore/xstransact.py:<lambda>
|    |    | 319         return complete(path, lambda t: t.list(*args))
|    |    | > xenstore/xstransact.py:list
|    |    |  129         if len(args) == 0:
|    |    |  130             ret = xshandle().ls(self.transaction, self.path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |  131             if ret is None:
|    |    |  132                 return []
|    |    | < xenstore/xstransact.py:list
|    |    |< xenstore/xstransact.py:<lambda>
|    |     354             if t.commit():
|    |    |> xenstore/xstransact.py:commit
|    |    |  28         if not self.in_transaction:
|    |    |  30         self.in_transaction = False
|    |    |  31         rc = xshandle().transaction_end(self.transaction, False)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  32         self.transaction = "0"
|    |    |  33         return rc
|    |    |< xenstore/xstransact.py:commit
|    |     355                 return result
|    |    < xenstore/xstransact.py:complete
|    |    > xenstore/xstransact.py:__del__
|    |      24         if self.in_transaction:
|    |    < xenstore/xstransact.py:__del__
|    |   < xenstore/xstransact.py:List
|    |  < server/DevController.py:deviceIDs
|    | < server/DevController.py:waitForDevices
|    | 539         for devclass in XendDevices.valid_devices():
|    | 540             self.getDeviceController(devclass).waitForDevices()
|    | > XendDomainInfo.py:getDeviceController
|    | 1152         if name not in self._deviceControllers:
|    | 1158         return self._deviceControllers[name]
|    | < XendDomainInfo.py:getDeviceController
|    | > server/DevController.py:waitForDevices
|    |  143         log.debug("Waiting for devices %s.", self.deviceClass)
|    |  144         return map(self.waitForDevice, self.deviceIDs())
|    |  > server/DevController.py:deviceIDs
|    |   368         fe = self.backendRoot()
|    |   > server/DevController.py:backendRoot
|    |    476         from xen.xend.XendDomain import DOM0_ID
|    |    477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    > xenstore/xsutil.py:GetDomainPath
|    |      26     return xshandle().get_domain_path(domid)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |    < xenstore/xsutil.py:GetDomainPath
|    |    > XendDomainInfo.py:getDomid
|    |     789         return self.domid
|    |    < XendDomainInfo.py:getDomid
|    |   < server/DevController.py:backendRoot
|    |   369         if transaction:
|    |   372             return map(int, xstransact.List(fe))
|    |   > xenstore/xstransact.py:List
|    |    319         return complete(path, lambda t: t.list(*args))
|    |    > xenstore/xstransact.py:complete
|    |     350     while True:
|    |     351         t = xstransact(path)
|    |    |> xenstore/xstransact.py:__init__
|    |    |  14         assert path is not None
|    |    |  16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |  19         self.path = path.rstrip("/")
|    |    |  20         self.transaction = xshandle().transaction_start()
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  21         self.in_transaction = True
|    |    |< xenstore/xstransact.py:__init__
|    |     352         try:
|    |     353             result = f(t)
|    |    |> xenstore/xstransact.py:<lambda>
|    |    | 319         return complete(path, lambda t: t.list(*args))
|    |    | > xenstore/xstransact.py:list
|    |    |  129         if len(args) == 0:
|    |    |  130             ret = xshandle().ls(self.transaction, self.path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |  131             if ret is None:
|    |    |  132                 return []
|    |    | < xenstore/xstransact.py:list
|    |    |< xenstore/xstransact.py:<lambda>
|    |     354             if t.commit():
|    |    |> xenstore/xstransact.py:commit
|    |    |  28         if not self.in_transaction:
|    |    |  30         self.in_transaction = False
|    |    |  31         rc = xshandle().transaction_end(self.transaction, False)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  32         self.transaction = "0"
|    |    |  33         return rc
|    |    |< xenstore/xstransact.py:commit
|    |     355                 return result
|    |    < xenstore/xstransact.py:complete
|    |    > xenstore/xstransact.py:__del__
|    |      24         if self.in_transaction:
|    |    < xenstore/xstransact.py:__del__
|    |   < xenstore/xstransact.py:List
|    |  < server/DevController.py:deviceIDs
|    | < server/DevController.py:waitForDevices
|    | 539         for devclass in XendDevices.valid_devices():
|    | 540             self.getDeviceController(devclass).waitForDevices()
|    | > XendDomainInfo.py:getDeviceController
|    | 1152         if name not in self._deviceControllers:
|    | 1158         return self._deviceControllers[name]
|    | < XendDomainInfo.py:getDeviceController
|    | > server/DevController.py:waitForDevices
|    |  143         log.debug("Waiting for devices %s.", self.deviceClass)
|    |  144         return map(self.waitForDevice, self.deviceIDs())
|    |  > server/DevController.py:deviceIDs
|    |   368         fe = self.backendRoot()
|    |   > server/DevController.py:backendRoot
|    |    476         from xen.xend.XendDomain import DOM0_ID
|    |    477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    > xenstore/xsutil.py:GetDomainPath
|    |      26     return xshandle().get_domain_path(domid)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |    < xenstore/xsutil.py:GetDomainPath
|    |    > XendDomainInfo.py:getDomid
|    |     789         return self.domid
|    |    < XendDomainInfo.py:getDomid
|    |   < server/DevController.py:backendRoot
|    |   369         if transaction:
|    |   372             return map(int, xstransact.List(fe))
|    |   > xenstore/xstransact.py:List
|    |    319         return complete(path, lambda t: t.list(*args))
|    |    > xenstore/xstransact.py:complete
|    |     350     while True:
|    |     351         t = xstransact(path)
|    |    |> xenstore/xstransact.py:__init__
|    |    |  14         assert path is not None
|    |    |  16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |  19         self.path = path.rstrip("/")
|    |    |  20         self.transaction = xshandle().transaction_start()
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  21         self.in_transaction = True
|    |    |< xenstore/xstransact.py:__init__
|    |     352         try:
|    |     353             result = f(t)
|    |    |> xenstore/xstransact.py:<lambda>
|    |    | 319         return complete(path, lambda t: t.list(*args))
|    |    | > xenstore/xstransact.py:list
|    |    |  129         if len(args) == 0:
|    |    |  130             ret = xshandle().ls(self.transaction, self.path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |  131             if ret is None:
|    |    |  132                 return []
|    |    | < xenstore/xstransact.py:list
|    |    |< xenstore/xstransact.py:<lambda>
|    |     354             if t.commit():
|    |    |> xenstore/xstransact.py:commit
|    |    |  28         if not self.in_transaction:
|    |    |  30         self.in_transaction = False
|    |    |  31         rc = xshandle().transaction_end(self.transaction, False)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |  32         self.transaction = "0"
|    |    |  33         return rc
|    |    |< xenstore/xstransact.py:commit
|    |     355                 return result
|    |    < xenstore/xstransact.py:complete
|    |    > xenstore/xstransact.py:__del__
|    |      24         if self.in_transaction:
|    |    < xenstore/xstransact.py:__del__
|    |   < xenstore/xstransact.py:List
|    |  < server/DevController.py:deviceIDs
|    | < server/DevController.py:waitForDevices
|    | 539         for devclass in XendDevices.valid_devices():
|    |< XendDomainInfo.py:waitForDevices
|    < server/XMLRPCServer.py:dispatch
|    153             while self.running:
|    154                 self.server.handle_request()
|    > XendDomain.py:domain_unpause
|     947         try:
|     948             dominfo = self.domain_lookup_nr(domid)
|    |> XendDomain.py:domain_lookup_nr
|    | 485         self.domains_lock.acquire()
|    | 486         try:
|    | 488             match = [dom for dom in self.domains.values() \
|    | > XendDomainInfo.py:getName
|    |  797         return self.info['name']
|    | < XendDomainInfo.py:getName
|    | 488             match = [dom for dom in self.domains.values() \
|    | > XendDomainInfo.py:getName
|    |  797         return self.info['name']
|    | < XendDomainInfo.py:getName
|    | 488             match = [dom for dom in self.domains.values() \
|    | 490             if match:
|    | 491                 return match[0]
|    | 517             self.domains_lock.release()
|    |< XendDomain.py:domain_lookup_nr
|     949             if not dominfo:
|     951             if dominfo.getDomid() == DOM0_ID:
|    |> XendDomainInfo.py:getDomid
|    | 789         return self.domid
|    |< XendDomainInfo.py:getDomid
|     953             log.info("Domain %s (%d) unpaused.", dominfo.getName(),
|    |> XendDomainInfo.py:getName
|    | 797         return self.info['name']
|    |< XendDomainInfo.py:getName
|     954                      int(dominfo.getDomid()))
|    |> XendDomainInfo.py:getDomid
|    | 789         return self.domid
|    |< XendDomainInfo.py:getDomid
|     955             dominfo.unpause()
|    |> XendDomainInfo.py:unpause
|    | 499         try:
|    | 500             xc.domain_unpause(self.domid)
|    | 501             self._stateSet(DOM_STATE_RUNNING)
|    | > XendDomainInfo.py:_stateSet
|    | 1595         self.state_updated.acquire()
|    | 1596         try:
|    | 1597             if self.state != state:
|    | 1601             self.state_updated.release()
|    | < XendDomainInfo.py:_stateSet
|    |< XendDomainInfo.py:unpause
|    < XendDomain.py:domain_unpause
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    > server/XMLRPCServer.py:domains
|      57     if detail < 1:
|      60         domains = XendDomain.instance().list_sorted()
|    |> XendDomain.py:instance
|    |1333     try:
|    |1334         inst
|    |1338     return inst
|    |< XendDomain.py:instance
|    |> XendDomain.py:list_sorted
|    | 704         doms = self.list()
|    | > XendDomain.py:list
|    |  679         self.domains_lock.acquire()
|    |  680         try:
|    |  681             self._refresh()
|    |  > XendDomain.py:_refresh
|    |   379         running = self._running_domains()
|    |   > XendDomain.py:_running_domains
|    |    343         try:
|    |    344             return xc.domain_getinfo()
|    |   < XendDomain.py:_running_domains
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 206     ('image',        lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     783             if d_type not in XendDevices.valid_devices():
|    |    |> XendDevices.py:valid_devices
|    |    |  48         return cls.controllers.keys()
|    |    |< XendDevices.py:valid_devices
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |  < XendDomain.py:_refresh
|    |  684             active_domains = self.domains.values()
|    |  685             active_uuids = [d.get_uuid() for d in active_domains]
|    |  > XendDomainInfo.py:get_uuid
|    |  1678         dom_uuid = self.info.get('uuid')
|    |  1679         if not dom_uuid: # if it doesn't exist, make one up
|    |  1682         return dom_uuid
|    |  < XendDomainInfo.py:get_uuid
|    |  685             active_uuids = [d.get_uuid() for d in active_domains]
|    |  > XendDomainInfo.py:get_uuid
|    |  1678         dom_uuid = self.info.get('uuid')
|    |  1679         if not dom_uuid: # if it doesn't exist, make one up
|    |  1682         return dom_uuid
|    |  < XendDomainInfo.py:get_uuid
|    |  685             active_uuids = [d.get_uuid() for d in active_domains]
|    |  688             inactive_domains = []
|    |  689             for dom_uuid, dom in self.managed_domains.items():
|    |  693             return active_domains + inactive_domains
|    |  695             self.domains_lock.release()
|    | < XendDomain.py:list
|    | 705         doms.sort(lambda x, y: cmp(x.getName(), y.getName()))
|    | > XendDomain.py:<lambda>
|    |  705         doms.sort(lambda x, y: cmp(x.getName(), y.getName()))
|    |  > XendDomainInfo.py:getName
|    |   797         return self.info['name']
|    |  < XendDomainInfo.py:getName
|    |  > XendDomainInfo.py:getName
|    |   797         return self.info['name']
|    |  < XendDomainInfo.py:getName
|    | < XendDomain.py:<lambda>
|    | 706         return doms
|    |< XendDomain.py:list_sorted
|      61         return map(lambda dom: fixup_sxpr(dom.sxpr(not full)), 
domains)
|    |> server/XMLRPCServer.py:<lambda>
|    |  61         return map(lambda dom: fixup_sxpr(dom.sxpr(not full)), 
domains)
|    | > XendDomainInfo.py:sxpr
|    | 1663         result = self.info.get_sxp(domain = self,
|    | 1664                                    ignore_devices = ignore_store)
|    |  > XendConfig.py:get_sxp
|    |   683         sxpr = ['domain']
|    |   688         if domain.getDomid() != None:
|    |   > XendDomainInfo.py:getDomid
|    |    789         return self.domid
|    |   < XendDomainInfo.py:getDomid
|    |   689             sxpr.append(['domid', domain.getDomid()])
|    |   > XendDomainInfo.py:getDomid
|    |    789         return self.domid
|    |   < XendDomainInfo.py:getDomid
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   696         if 'image' in self and self['image'] != None:
|    |   698         if 'security' in self and self['security']:
|    |   700         if 'shutdown_reason' in self:
|    |   701             sxpr.append(['shutdown_reason', 
self['shutdown_reason']])
|    |   702         if 'cpu_time' in self:
|    |   703             sxpr.append(['cpu_time', self['cpu_time']/1e9])
|    |   705         sxpr.append(['online_vcpus', self['online_vcpus']])
|    |   707         if 'start_time' in self:
|    |   712         if domain:
|    |   713             sxpr.append(['status', str(domain.state)])
|    |   717         sxpr.append(['state', self._get_old_state_string()])
|    |   > XendConfig.py:_get_old_state_string
|    |    662         state_string = ''
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    664             on_off = self.get(state_name, 0)
|    |    665             if on_off:
|    |    666                 state_string += state_name[0]
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    664             on_off = self.get(state_name, 0)
|    |    665             if on_off:
|    |    668                 state_string += '-'
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    664             on_off = self.get(state_name, 0)
|    |    665             if on_off:
|    |    668                 state_string += '-'
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    664             on_off = self.get(state_name, 0)
|    |    665             if on_off:
|    |    668                 state_string += '-'
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    664             on_off = self.get(state_name, 0)
|    |    665             if on_off:
|    |    668                 state_string += '-'
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    664             on_off = self.get(state_name, 0)
|    |    665             if on_off:
|    |    668                 state_string += '-'
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    670         return state_string
|    |   < XendConfig.py:_get_old_state_string
|    |   718         sxpr.append(['memory_dynamic_max', 
self.get('memory_dynamic_max',
|    |   719                                                     
self['memory'])])
|    |   722         if domain:
|    |   723             if domain.store_mfn:
|    |   725             if domain.console_mfn:
|    |   729         if not ignore_devices:
|    |   752         return sxpr
|    |  < XendConfig.py:get_sxp
|    | 1666         if not ignore_store:
|    | 1672         return result
|    | < XendDomainInfo.py:sxpr
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |< server/XMLRPCServer.py:<lambda>
|    |> server/XMLRPCServer.py:<lambda>
|    |  61         return map(lambda dom: fixup_sxpr(dom.sxpr(not full)), 
domains)
|    | > XendDomainInfo.py:sxpr
|    | 1663         result = self.info.get_sxp(domain = self,
|    | 1664                                    ignore_devices = ignore_store)
|    |  > XendConfig.py:get_sxp
|    |   683         sxpr = ['domain']
|    |   688         if domain.getDomid() != None:
|    |   > XendDomainInfo.py:getDomid
|    |    789         return self.domid
|    |   < XendDomainInfo.py:getDomid
|    |   689             sxpr.append(['domid', domain.getDomid()])
|    |   > XendDomainInfo.py:getDomid
|    |    789         return self.domid
|    |   < XendDomainInfo.py:getDomid
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   692             if cfg in self:
|    |   693                 if self[cfg] != None:
|    |   694                     sxpr.append([cfg, self[cfg]])
|    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |   696         if 'image' in self and self['image'] != None:
|    |   697             sxpr.append(['image', self['image']])
|    |   698         if 'security' in self and self['security']:
|    |   700         if 'shutdown_reason' in self:
|    |   701             sxpr.append(['shutdown_reason', 
self['shutdown_reason']])
|    |   702         if 'cpu_time' in self:
|    |   703             sxpr.append(['cpu_time', self['cpu_time']/1e9])
|    |   705         sxpr.append(['online_vcpus', self['online_vcpus']])
|    |   707         if 'start_time' in self:
|    |   708             uptime = time.time() - self['start_time']
|    |   709             sxpr.append(['up_time', str(uptime)])
|    |   710             sxpr.append(['start_time', str(self['start_time'])])
|    |   712         if domain:
|    |   713             sxpr.append(['status', str(domain.state)])
|    |   717         sxpr.append(['state', self._get_old_state_string()])
|    |   > XendConfig.py:_get_old_state_string
|    |    662         state_string = ''
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    664             on_off = self.get(state_name, 0)
|    |    665             if on_off:
|    |    668                 state_string += '-'
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    664             on_off = self.get(state_name, 0)
|    |    665             if on_off:
|    |    666                 state_string += state_name[0]
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    664             on_off = self.get(state_name, 0)
|    |    665             if on_off:
|    |    668                 state_string += '-'
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    664             on_off = self.get(state_name, 0)
|    |    665             if on_off:
|    |    668                 state_string += '-'
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    664             on_off = self.get(state_name, 0)
|    |    665             if on_off:
|    |    668                 state_string += '-'
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    664             on_off = self.get(state_name, 0)
|    |    665             if on_off:
|    |    668                 state_string += '-'
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    670         return state_string
|    |   < XendConfig.py:_get_old_state_string
|    |   718         sxpr.append(['memory_dynamic_max', 
self.get('memory_dynamic_max',
|    |   719                                                     
self['memory'])])
|    |   722         if domain:
|    |   723             if domain.store_mfn:
|    |   724                 sxpr.append(['store_mfn', domain.store_mfn])
|    |   725             if domain.console_mfn:
|    |   726                 sxpr.append(['console_mfn', domain.console_mfn])
|    |   729         if not ignore_devices:
|    |   752         return sxpr
|    |  < XendConfig.py:get_sxp
|    | 1666         if not ignore_store:
|    | 1672         return result
|    | < XendDomainInfo.py:sxpr
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |    37                 ret.append(fixup_sxpr(k))
|    |   > server/XMLRPCServer.py:fixup_sxpr
|    |     33     ret = []
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |     37                 ret.append(fixup_sxpr(k))
|    |    > server/XMLRPCServer.py:fixup_sxpr
|    |      33     ret = []
|    |      34     for k in sexpr:
|    |      35         if type(k) in (types.ListType, types.TupleType):
|    |      39             ret.append(k)
|    |      34     for k in sexpr:
|    |      35         if type(k) in (types.ListType, types.TupleType):
|    |      39             ret.append(k)
|    |      34     for k in sexpr:
|    |      40     return ret
|    |    < server/XMLRPCServer.py:fixup_sxpr
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |     37                 ret.append(fixup_sxpr(k))
|    |    > server/XMLRPCServer.py:fixup_sxpr
|    |      33     ret = []
|    |      34     for k in sexpr:
|    |      35         if type(k) in (types.ListType, types.TupleType):
|    |      39             ret.append(k)
|    |      34     for k in sexpr:
|    |      35         if type(k) in (types.ListType, types.TupleType):
|    |      39             ret.append(k)
|    |      34     for k in sexpr:
|    |      40     return ret
|    |    < server/XMLRPCServer.py:fixup_sxpr
|    |     34     for k in sexpr:
|    |     40     return ret
|    |   < server/XMLRPCServer.py:fixup_sxpr
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |< server/XMLRPCServer.py:<lambda>
|    < server/XMLRPCServer.py:domains
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    153             while self.running:
|    154                 self.server.handle_request()
|    > server/XMLRPCServer.py:domain
|      53     info = lookup(domid)
|    |> server/XMLRPCServer.py:lookup
|    |  43     info = XendDomain.instance().domain_lookup(domid)
|    | > XendDomain.py:instance
|    | 1333     try:
|    | 1334         inst
|    | 1338     return inst
|    | < XendDomain.py:instance
|    | > XendDomain.py:domain_lookup
|    |  465         self.domains_lock.acquire()
|    |  466         try:
|    |  467             self._refresh()
|    |  > XendDomain.py:_refresh
|    |   379         running = self._running_domains()
|    |   > XendDomain.py:_running_domains
|    |    343         try:
|    |    344             return xc.domain_getinfo()
|    |   < XendDomain.py:_running_domains
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 206     ('image',        lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     783             if d_type not in XendDevices.valid_devices():
|    |    |> XendDevices.py:valid_devices
|    |    |  48         return cls.controllers.keys()
|    |    |< XendDevices.py:valid_devices
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |  < XendDomain.py:_refresh
|    |  468             dom = self.domain_lookup_nr(domid)
|    |  > XendDomain.py:domain_lookup_nr
|    |   485         self.domains_lock.acquire()
|    |   486         try:
|    |   488             match = [dom for dom in self.domains.values() \
|    |   > XendDomainInfo.py:getName
|    |    797         return self.info['name']
|    |   < XendDomainInfo.py:getName
|    |   488             match = [dom for dom in self.domains.values() \
|    |   > XendDomainInfo.py:getName
|    |    797         return self.info['name']
|    |   < XendDomainInfo.py:getName
|    |   488             match = [dom for dom in self.domains.values() \
|    |   490             if match:
|    |   493             match = [dom for dom in self.managed_domains.values() \
|    |   495             if match:
|    |   499             try:
|    |   500                 if int(domid) in self.domains:
|    |   501                     return self.domains[int(domid)]
|    |   517             self.domains_lock.release()
|    |  < XendDomain.py:domain_lookup_nr
|    |  469             if not dom:
|    |  471             return dom
|    |  473             self.domains_lock.release()
|    | < XendDomain.py:domain_lookup
|    |  44     if not info:
|    |  46     return info
|    |< server/XMLRPCServer.py:lookup
|      54     return fixup_sxpr(info.sxpr(not full))
|    |> XendDomainInfo.py:sxpr
|    |1663         result = self.info.get_sxp(domain = self,
|    |1664                                    ignore_devices = ignore_store)
|    | > XendConfig.py:get_sxp
|    |  683         sxpr = ['domain']
|    |  688         if domain.getDomid() != None:
|    |  > XendDomainInfo.py:getDomid
|    |   789         return self.domid
|    |  < XendDomainInfo.py:getDomid
|    |  689             sxpr.append(['domid', domain.getDomid()])
|    |  > XendDomainInfo.py:getDomid
|    |   789         return self.domid
|    |  < XendDomainInfo.py:getDomid
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  696         if 'image' in self and self['image'] != None:
|    |  697             sxpr.append(['image', self['image']])
|    |  698         if 'security' in self and self['security']:
|    |  700         if 'shutdown_reason' in self:
|    |  701             sxpr.append(['shutdown_reason', 
self['shutdown_reason']])
|    |  702         if 'cpu_time' in self:
|    |  703             sxpr.append(['cpu_time', self['cpu_time']/1e9])
|    |  705         sxpr.append(['online_vcpus', self['online_vcpus']])
|    |  707         if 'start_time' in self:
|    |  708             uptime = time.time() - self['start_time']
|    |  709             sxpr.append(['up_time', str(uptime)])
|    |  710             sxpr.append(['start_time', str(self['start_time'])])
|    |  712         if domain:
|    |  713             sxpr.append(['status', str(domain.state)])
|    |  717         sxpr.append(['state', self._get_old_state_string()])
|    |  > XendConfig.py:_get_old_state_string
|    |   662         state_string = ''
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   664             on_off = self.get(state_name, 0)
|    |   665             if on_off:
|    |   668                 state_string += '-'
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   664             on_off = self.get(state_name, 0)
|    |   665             if on_off:
|    |   666                 state_string += state_name[0]
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   664             on_off = self.get(state_name, 0)
|    |   665             if on_off:
|    |   668                 state_string += '-'
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   664             on_off = self.get(state_name, 0)
|    |   665             if on_off:
|    |   668                 state_string += '-'
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   664             on_off = self.get(state_name, 0)
|    |   665             if on_off:
|    |   668                 state_string += '-'
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   664             on_off = self.get(state_name, 0)
|    |   665             if on_off:
|    |   668                 state_string += '-'
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   670         return state_string
|    |  < XendConfig.py:_get_old_state_string
|    |  718         sxpr.append(['memory_dynamic_max', 
self.get('memory_dynamic_max',
|    |  719                                                     
self['memory'])])
|    |  722         if domain:
|    |  723             if domain.store_mfn:
|    |  724                 sxpr.append(['store_mfn', domain.store_mfn])
|    |  725             if domain.console_mfn:
|    |  726                 sxpr.append(['console_mfn', domain.console_mfn])
|    |  729         if not ignore_devices:
|    |  752         return sxpr
|    | < XendConfig.py:get_sxp
|    |1666         if not ignore_store:
|    |1672         return result
|    |< XendDomainInfo.py:sxpr
|    |> server/XMLRPCServer.py:fixup_sxpr
|    |  33     ret = []
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  39             ret.append(k)
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |    37                 ret.append(fixup_sxpr(k))
|    |   > server/XMLRPCServer.py:fixup_sxpr
|    |     33     ret = []
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     40     return ret
|    |   < server/XMLRPCServer.py:fixup_sxpr
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |    37                 ret.append(fixup_sxpr(k))
|    |   > server/XMLRPCServer.py:fixup_sxpr
|    |     33     ret = []
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     40     return ret
|    |   < server/XMLRPCServer.py:fixup_sxpr
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  40     return ret
|    |< server/XMLRPCServer.py:fixup_sxpr
|    < server/XMLRPCServer.py:domain
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    > server/XMLRPCServer.py:dispatch
|      49     info = lookup(domid)
|    |> server/XMLRPCServer.py:lookup
|    |  43     info = XendDomain.instance().domain_lookup(domid)
|    | > XendDomain.py:instance
|    | 1333     try:
|    | 1334         inst
|    | 1338     return inst
|    | < XendDomain.py:instance
|    | > XendDomain.py:domain_lookup
|    |  465         self.domains_lock.acquire()
|    |  466         try:
|    |  467             self._refresh()
|    |  > XendDomain.py:_refresh
|    |   379         running = self._running_domains()
|    |   > XendDomain.py:_running_domains
|    |    343         try:
|    |    344             return xc.domain_getinfo()
|    |   < XendDomain.py:_running_domains
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 206     ('image',        lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     783             if d_type not in XendDevices.valid_devices():
|    |    |> XendDevices.py:valid_devices
|    |    |  48         return cls.controllers.keys()
|    |    |< XendDevices.py:valid_devices
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |  < XendDomain.py:_refresh
|    |  468             dom = self.domain_lookup_nr(domid)
|    |  > XendDomain.py:domain_lookup_nr
|    |   485         self.domains_lock.acquire()
|    |   486         try:
|    |   488             match = [dom for dom in self.domains.values() \
|    |   > XendDomainInfo.py:getName
|    |    797         return self.info['name']
|    |   < XendDomainInfo.py:getName
|    |   488             match = [dom for dom in self.domains.values() \
|    |   > XendDomainInfo.py:getName
|    |    797         return self.info['name']
|    |   < XendDomainInfo.py:getName
|    |   488             match = [dom for dom in self.domains.values() \
|    |   490             if match:
|    |   493             match = [dom for dom in self.managed_domains.values() \
|    |   495             if match:
|    |   499             try:
|    |   500                 if int(domid) in self.domains:
|    |   501                     return self.domains[int(domid)]
|    |   517             self.domains_lock.release()
|    |  < XendDomain.py:domain_lookup_nr
|    |  469             if not dom:
|    |  471             return dom
|    |  473             self.domains_lock.release()
|    | < XendDomain.py:domain_lookup
|    |  44     if not info:
|    |  46     return info
|    |< server/XMLRPCServer.py:lookup
|      50     return getattr(info, fn)(*args)
|    |> XendDomainInfo.py:getRestartCount
|    | 845         return self._readVm('xend/restart_count')
|    | > XendDomainInfo.py:_readVm
|    |  644         return xstransact.Read(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Read
|    |   297         return complete(path, lambda t: t.read(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     297         return complete(path, lambda t: t.read(*args))
|    |    |> xenstore/xstransact.py:read
|    |    |  59         if len(args) == 0:
|    |    |  61         if len(args) == 1:
|    |    |  62             return self._read(args[0])
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    |< xenstore/xstransact.py:read
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Read
|    | < XendDomainInfo.py:_readVm
|    |< XendDomainInfo.py:getRestartCount
|    < server/XMLRPCServer.py:dispatch
|    153             while self.running:
|    154                 self.server.handle_request()
|    > server/XMLRPCServer.py:dispatch
|      49     info = lookup(domid)
|    |> server/XMLRPCServer.py:lookup
|    |  43     info = XendDomain.instance().domain_lookup(domid)
|    | > XendDomain.py:instance
|    | 1333     try:
|    | 1334         inst
|    | 1338     return inst
|    | < XendDomain.py:instance
|    | > XendDomain.py:domain_lookup
|    |  465         self.domains_lock.acquire()
|    |  466         try:
|    |  467             self._refresh()
|    |  > XendDomain.py:_refresh
|    |   379         running = self._running_domains()
|    |   > XendDomain.py:_running_domains
|    |    343         try:
|    |    344             return xc.domain_getinfo()
|    |   < XendDomain.py:_running_domains
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 206     ('image',        lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     783             if d_type not in XendDevices.valid_devices():
|    |    |> XendDevices.py:valid_devices
|    |    |  48         return cls.controllers.keys()
|    |    |< XendDevices.py:valid_devices
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |  < XendDomain.py:_refresh
|    |  468             dom = self.domain_lookup_nr(domid)
|    |  > XendDomain.py:domain_lookup_nr
|    |   485         self.domains_lock.acquire()
|    |   486         try:
|    |   488             match = [dom for dom in self.domains.values() \
|    |   > XendDomainInfo.py:getName
|    |    797         return self.info['name']
|    |   < XendDomainInfo.py:getName
|    |   488             match = [dom for dom in self.domains.values() \
|    |   > XendDomainInfo.py:getName
|    |    797         return self.info['name']
|    |   < XendDomainInfo.py:getName
|    |   488             match = [dom for dom in self.domains.values() \
|    |   490             if match:
|    |   493             match = [dom for dom in self.managed_domains.values() \
|    |   495             if match:
|    |   499             try:
|    |   500                 if int(domid) in self.domains:
|    |   501                     return self.domains[int(domid)]
|    |   517             self.domains_lock.release()
|    |  < XendDomain.py:domain_lookup_nr
|    |  469             if not dom:
|    |  471             return dom
|    |  473             self.domains_lock.release()
|    | < XendDomain.py:domain_lookup
|    |  44     if not info:
|    |  46     return info
|    |< server/XMLRPCServer.py:lookup
|      50     return getattr(info, fn)(*args)
|    |> XendDomainInfo.py:shutdown
|    | 475         log.debug('XendDomainInfo.shutdown')
|    | 476         if self.state in (DOM_STATE_SHUTDOWN, DOM_STATE_HALTED,):
|    | 479         if not reason in DOMAIN_SHUTDOWN_REASONS.values():
|    | 481         self._storeDom("control/shutdown", reason)
|    | > XendDomainInfo.py:_storeDom
|    |  672         return xstransact.Store(self.dompath, *args)
|    |  > xenstore/xstransact.py:Store
|    |   337         complete(path, lambda t: t.store(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     337         complete(path, lambda t: t.store(*args))
|    |    |> xenstore/xstransact.py:store
|    |    | 195         if len(args) and type(args[0]) != tuple:
|    |    | 196             args = args,
|    |    | 197         for tup in args:
|    |    | 198             if len(tup) == 2:
|    |    | 199                 (key, val) = tup
|    |    | 200                 try:
|    |    | 201                     fmt = { str        : "%s",
|    |    | 210             if val is None:
|    |    | 213                 self._write(key, fmt % val)
|    |    | > xenstore/xstransact.py:_write
|    |    |   69         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   70         try:
|    |    |   71             xshandle().write(self.transaction, path, data)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_write
|    |    | 197         for tup in args:
|    |    |< xenstore/xstransact.py:store
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      65             watch = we[1]
|    |      66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    |    |> XendDomainInfo.py:_handleShutdownWatch
|    |    | 760         log.debug('XendDomainInfo.handleShutdownWatch')
|    |    | 762         reason = self._readDom('control/shutdown')
|    |    | > XendDomainInfo.py:_readDom
|    |    |  663         return xstransact.Read(self.dompath, *args)
|    |    |  > xenstore/xstransact.py:Read
|    |    |   297         return complete(path, lambda t: t.read(*args))
|    |    |   > xenstore/xstransact.py:complete
|    |    |    350     while True:
|    |    |    351         t = xstransact(path)
|    |    |    > xenstore/xstransact.py:__init__
|    |    |      14         assert path is not None
|    |    |      16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |      19         self.path = path.rstrip("/")
|    |    |      20         self.transaction = xshandle().transaction_start()
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |      32         self.transaction = "0"
|    |    |      33         return rc
|    |    |    < xenstore/xstransact.py:commit
|    |    |    355                 return result
|    |    |   < xenstore/xstransact.py:complete
|    |    |   > xenstore/xstransact.py:__del__
|    |    |     24         if self.in_transaction:
|    |    |   < xenstore/xstransact.py:__del__
|    |    |  < xenstore/xstransact.py:Store
|    |    | < XendDomainInfo.py:_storeDom
|    |    |< XendDomainInfo.py:shutdown
|    |    < server/XMLRPCServer.py:dispatch
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readDom
|     764         if reason and reason != 'suspend':
|     780         return True
|    < XendDomainInfo.py:_handleShutdownWatch
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_handleShutdownWatch
|     760         log.debug('XendDomainInfo.handleShutdownWatch')
|     762         reason = self._readDom('control/shutdown')
|    |> XendDomainInfo.py:_readDom
|    | 663         return xstransact.Read(self.dompath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readDom
|     764         if reason and reason != 'suspend':
|     780         return True
|    < XendDomainInfo.py:_handleShutdownWatch
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    153             while self.running:
|    154                 self.server.handle_request()
|    > server/XMLRPCServer.py:domain
|      53     info = lookup(domid)
|    |> server/XMLRPCServer.py:lookup
|    |  43     info = XendDomain.instance().domain_lookup(domid)
|    | > XendDomain.py:instance
|    | 1333     try:
|    | 1334         inst
|    | 1338     return inst
|    | < XendDomain.py:instance
|    | > XendDomain.py:domain_lookup
|    |  465         self.domains_lock.acquire()
|    |  466         try:
|    |  467             self._refresh()
|    |  > XendDomain.py:_refresh
|    |   379         running = self._running_domains()
|    |   > XendDomain.py:_running_domains
|    |    343         try:
|    |    344             return xc.domain_getinfo()
|    |   < XendDomain.py:_running_domains
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 206     ('image',        lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   381             domid = dom['domid']
|    |   382             if domid in self.domains and dom['dying'] != 1:
|    |   383                 self.domains[domid].update(dom)
|    |   > XendDomainInfo.py:update
|    |   1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    |   1631                   str(self.domid))
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   1633         if not info:
|    |   1639         if security.on() and info.has_key('ssidref'):
|    |   1647         if 'ssidref' in info:
|    |   1648             info.pop('ssidref')
|    |   1653         self.info.update(info)
|    |   1654         self.info.validate()
|    |    > XendConfig.py:validate
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 202     ('bootloader',   lambda info: None),
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     762                 self[key] = default_func(self)
|    |    |> XendConfig.py:<lambda>
|    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |< XendConfig.py:<lambda>
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     761             if key not in self or self[key] == None:
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |     765         if 'image' in self and isinstance(self['image'], str):
|    |     767         if 'security' in self and isinstance(self['security'], 
str):
|    |     769         if self['memory'] == 0 and 'mem_kb' in self:
|    |     771         if self['memory'] <= 0:
|    |     775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |     778         if 'mem_kb' in self:
|    |     779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     783             if d_type not in XendDevices.valid_devices():
|    |    |> XendDevices.py:valid_devices
|    |    |  48         return cls.controllers.keys()
|    |    |< XendDevices.py:valid_devices
|    |     782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     788             if self[event] not in CONFIG_RESTART_MODES:
|    |     787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |     793         if 'vif_refs' not in self:
|    |     795         if 'vbd_refs' not in self:
|    |     797         if 'vtpm_refs' not in self:
|    |    < XendConfig.py:validate
|    |   1656         if refresh:
|    |   1657             self.refreshShutdown(info)
|    |    > XendDomainInfo.py:refreshShutdown
|    |     856         restart_reason = None
|    |     858         self.refresh_shutdown_lock.acquire()
|    |     859         try:
|    |     860             if xeninfo is None:
|    |     874             if xeninfo['dying']:
|    |     886             elif xeninfo['crashed']:
|    |     901             elif xeninfo['shutdown']:
|    |     928             elif self.dompath is None:
|    |     936                 if xeninfo['paused']:
|    |     939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |> XendDomainInfo.py:_stateSet
|    |    |1595         self.state_updated.acquire()
|    |    |1596         try:
|    |    |1597             if self.state != state:
|    |    |1601             self.state_updated.release()
|    |    |< XendDomainInfo.py:_stateSet
|    |     941                 if self.shutdownStartTime:
|    |     950             self.refresh_shutdown_lock.release()
|    |     952         if restart_reason:
|    |    < XendDomainInfo.py:refreshShutdown
|    |   1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    |   1660                   str(self.domid), self.info)
|    |    > XendLogging.py:trace
|    |      36         self.log(logging.TRACE, *args, **kwargs)
|    |    < XendLogging.py:trace
|    |   < XendDomainInfo.py:update
|    |   380         for dom in running:
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |   391             if domid not in running_domids and domid != DOM0_ID:
|    |   390         for domid, dom in self.domains.items():
|    |  < XendDomain.py:_refresh
|    |  468             dom = self.domain_lookup_nr(domid)
|    |  > XendDomain.py:domain_lookup_nr
|    |   485         self.domains_lock.acquire()
|    |   486         try:
|    |   488             match = [dom for dom in self.domains.values() \
|    |   > XendDomainInfo.py:getName
|    |    797         return self.info['name']
|    |   < XendDomainInfo.py:getName
|    |   488             match = [dom for dom in self.domains.values() \
|    |   > XendDomainInfo.py:getName
|    |    797         return self.info['name']
|    |   < XendDomainInfo.py:getName
|    |   488             match = [dom for dom in self.domains.values() \
|    |   490             if match:
|    |   493             match = [dom for dom in self.managed_domains.values() \
|    |   495             if match:
|    |   499             try:
|    |   500                 if int(domid) in self.domains:
|    |   501                     return self.domains[int(domid)]
|    |   517             self.domains_lock.release()
|    |  < XendDomain.py:domain_lookup_nr
|    |  469             if not dom:
|    |  471             return dom
|    |  473             self.domains_lock.release()
|    | < XendDomain.py:domain_lookup
|    |  44     if not info:
|    |  46     return info
|    |< server/XMLRPCServer.py:lookup
|      54     return fixup_sxpr(info.sxpr(not full))
|    |> XendDomainInfo.py:sxpr
|    |1663         result = self.info.get_sxp(domain = self,
|    |1664                                    ignore_devices = ignore_store)
|    | > XendConfig.py:get_sxp
|    |  683         sxpr = ['domain']
|    |  688         if domain.getDomid() != None:
|    |  > XendDomainInfo.py:getDomid
|    |   789         return self.domid
|    |  < XendDomainInfo.py:getDomid
|    |  689             sxpr.append(['domid', domain.getDomid()])
|    |  > XendDomainInfo.py:getDomid
|    |   789         return self.domid
|    |  < XendDomainInfo.py:getDomid
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  692             if cfg in self:
|    |  693                 if self[cfg] != None:
|    |  694                     sxpr.append([cfg, self[cfg]])
|    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |  696         if 'image' in self and self['image'] != None:
|    |  697             sxpr.append(['image', self['image']])
|    |  698         if 'security' in self and self['security']:
|    |  700         if 'shutdown_reason' in self:
|    |  701             sxpr.append(['shutdown_reason', 
self['shutdown_reason']])
|    |  702         if 'cpu_time' in self:
|    |  703             sxpr.append(['cpu_time', self['cpu_time']/1e9])
|    |  705         sxpr.append(['online_vcpus', self['online_vcpus']])
|    |  707         if 'start_time' in self:
|    |  708             uptime = time.time() - self['start_time']
|    |  709             sxpr.append(['up_time', str(uptime)])
|    |  710             sxpr.append(['start_time', str(self['start_time'])])
|    |  712         if domain:
|    |  713             sxpr.append(['status', str(domain.state)])
|    |  717         sxpr.append(['state', self._get_old_state_string()])
|    |  > XendConfig.py:_get_old_state_string
|    |   662         state_string = ''
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   664             on_off = self.get(state_name, 0)
|    |   665             if on_off:
|    |   666                 state_string += state_name[0]
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   664             on_off = self.get(state_name, 0)
|    |   665             if on_off:
|    |   668                 state_string += '-'
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   664             on_off = self.get(state_name, 0)
|    |   665             if on_off:
|    |   668                 state_string += '-'
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   664             on_off = self.get(state_name, 0)
|    |   665             if on_off:
|    |   668                 state_string += '-'
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   664             on_off = self.get(state_name, 0)
|    |   665             if on_off:
|    |   668                 state_string += '-'
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   664             on_off = self.get(state_name, 0)
|    |   665             if on_off:
|    |   668                 state_string += '-'
|    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |   670         return state_string
|    |  < XendConfig.py:_get_old_state_string
|    |  718         sxpr.append(['memory_dynamic_max', 
self.get('memory_dynamic_max',
|    |  719                                                     
self['memory'])])
|    |  722         if domain:
|    |  723             if domain.store_mfn:
|    |  724                 sxpr.append(['store_mfn', domain.store_mfn])
|    |  725             if domain.console_mfn:
|    |  726                 sxpr.append(['console_mfn', domain.console_mfn])
|    |  729         if not ignore_devices:
|    |  752         return sxpr
|    | < XendConfig.py:get_sxp
|    |1666         if not ignore_store:
|    |1672         return result
|    |< XendDomainInfo.py:sxpr
|    |> server/XMLRPCServer.py:fixup_sxpr
|    |  33     ret = []
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  39             ret.append(k)
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |   37                 ret.append(fixup_sxpr(k))
|    |  > server/XMLRPCServer.py:fixup_sxpr
|    |    33     ret = []
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    39             ret.append(k)
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |    37                 ret.append(fixup_sxpr(k))
|    |   > server/XMLRPCServer.py:fixup_sxpr
|    |     33     ret = []
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     40     return ret
|    |   < server/XMLRPCServer.py:fixup_sxpr
|    |    34     for k in sexpr:
|    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |    37                 ret.append(fixup_sxpr(k))
|    |   > server/XMLRPCServer.py:fixup_sxpr
|    |     33     ret = []
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     35         if type(k) in (types.ListType, types.TupleType):
|    |     39             ret.append(k)
|    |     34     for k in sexpr:
|    |     40     return ret
|    |   < server/XMLRPCServer.py:fixup_sxpr
|    |    34     for k in sexpr:
|    |    40     return ret
|    |  < server/XMLRPCServer.py:fixup_sxpr
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  35         if type(k) in (types.ListType, types.TupleType):
|    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |  37                 ret.append(fixup_sxpr(k))
|    | > server/XMLRPCServer.py:fixup_sxpr
|    |   33     ret = []
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   35         if type(k) in (types.ListType, types.TupleType):
|    |   39             ret.append(k)
|    |   34     for k in sexpr:
|    |   40     return ret
|    | < server/XMLRPCServer.py:fixup_sxpr
|    |  34     for k in sexpr:
|    |  40     return ret
|    |< server/XMLRPCServer.py:fixup_sxpr
|    < server/XMLRPCServer.py:domain
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomain.py:_on_domains_changed
|     133         self.domains_lock.acquire()
|     134         try:
|     135             self._refresh()
|    |> XendDomain.py:_refresh
|    | 379         running = self._running_domains()
|    | > XendDomain.py:_running_domains
|    |  343         try:
|    |  344             return xc.domain_getinfo()
|    | < XendDomain.py:_running_domains
|    | 380         for dom in running:
|    | 381             domid = dom['domid']
|    | 382             if domid in self.domains and dom['dying'] != 1:
|    | 383                 self.domains[domid].update(dom)
|    | > XendDomainInfo.py:update
|    | 1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    | 1631                   str(self.domid))
|    |  > XendLogging.py:trace
|    |    36         self.log(logging.TRACE, *args, **kwargs)
|    |  < XendLogging.py:trace
|    | 1633         if not info:
|    | 1639         if security.on() and info.has_key('ssidref'):
|    | 1647         if 'ssidref' in info:
|    | 1648             info.pop('ssidref')
|    | 1653         self.info.update(info)
|    | 1654         self.info.validate()
|    |  > XendConfig.py:validate
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    202     ('bootloader',   lambda info: None),
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    203     ('bootloader_args', lambda info: None),            
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    206     ('image',        lambda info: None),
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   765         if 'image' in self and isinstance(self['image'], str):
|    |   767         if 'security' in self and isinstance(self['security'], 
str):
|    |   769         if self['memory'] == 0 and 'mem_kb' in self:
|    |   771         if self['memory'] <= 0:
|    |   775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |   778         if 'mem_kb' in self:
|    |   779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |   782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   793         if 'vif_refs' not in self:
|    |   795         if 'vbd_refs' not in self:
|    |   797         if 'vtpm_refs' not in self:
|    |  < XendConfig.py:validate
|    | 1656         if refresh:
|    | 1657             self.refreshShutdown(info)
|    |  > XendDomainInfo.py:refreshShutdown
|    |   856         restart_reason = None
|    |   858         self.refresh_shutdown_lock.acquire()
|    |   859         try:
|    |   860             if xeninfo is None:
|    |   874             if xeninfo['dying']:
|    |   886             elif xeninfo['crashed']:
|    |   901             elif xeninfo['shutdown']:
|    |   928             elif self.dompath is None:
|    |   936                 if xeninfo['paused']:
|    |   939                     self._stateSet(DOM_STATE_RUNNING)
|    |   > XendDomainInfo.py:_stateSet
|    |   1595         self.state_updated.acquire()
|    |   1596         try:
|    |   1597             if self.state != state:
|    |   1601             self.state_updated.release()
|    |   < XendDomainInfo.py:_stateSet
|    |   941                 if self.shutdownStartTime:
|    |   950             self.refresh_shutdown_lock.release()
|    |   952         if restart_reason:
|    |  < XendDomainInfo.py:refreshShutdown
|    | 1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    | 1660                   str(self.domid), self.info)
|    |  > XendLogging.py:trace
|    |    36         self.log(logging.TRACE, *args, **kwargs)
|    |  < XendLogging.py:trace
|    | < XendDomainInfo.py:update
|    | 380         for dom in running:
|    | 381             domid = dom['domid']
|    | 382             if domid in self.domains and dom['dying'] != 1:
|    | 383                 self.domains[domid].update(dom)
|    | > XendDomainInfo.py:update
|    | 1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    | 1631                   str(self.domid))
|    |  > XendLogging.py:trace
|    |    36         self.log(logging.TRACE, *args, **kwargs)
|    |  < XendLogging.py:trace
|    | 1633         if not info:
|    | 1639         if security.on() and info.has_key('ssidref'):
|    | 1647         if 'ssidref' in info:
|    | 1648             info.pop('ssidref')
|    | 1653         self.info.update(info)
|    | 1654         self.info.validate()
|    |  > XendConfig.py:validate
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    202     ('bootloader',   lambda info: None),
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    203     ('bootloader_args', lambda info: None),            
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   765         if 'image' in self and isinstance(self['image'], str):
|    |   767         if 'security' in self and isinstance(self['security'], 
str):
|    |   769         if self['memory'] == 0 and 'mem_kb' in self:
|    |   771         if self['memory'] <= 0:
|    |   775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |   778         if 'mem_kb' in self:
|    |   779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |   782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |   783             if d_type not in XendDevices.valid_devices():
|    |   > XendDevices.py:valid_devices
|    |     48         return cls.controllers.keys()
|    |   < XendDevices.py:valid_devices
|    |   782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   793         if 'vif_refs' not in self:
|    |   795         if 'vbd_refs' not in self:
|    |   797         if 'vtpm_refs' not in self:
|    |  < XendConfig.py:validate
|    | 1656         if refresh:
|    | 1657             self.refreshShutdown(info)
|    |  > XendDomainInfo.py:refreshShutdown
|    |   856         restart_reason = None
|    |   858         self.refresh_shutdown_lock.acquire()
|    |   859         try:
|    |   860             if xeninfo is None:
|    |   874             if xeninfo['dying']:
|    |   886             elif xeninfo['crashed']:
|    |   901             elif xeninfo['shutdown']:
|    |   902                 self._stateSet(DOM_STATE_SHUTDOWN)
|    |   > XendDomainInfo.py:_stateSet
|    |   1595         self.state_updated.acquire()
|    |   1596         try:
|    |   1597             if self.state != state:
|    |   1598                 self.state = state
|    |   1599                 self.state_updated.notifyAll()
|    |   1601             self.state_updated.release()
|    |   < XendDomainInfo.py:_stateSet
|    |   903                 if self._readDom('xend/shutdown_completed'):
|    |   > XendDomainInfo.py:_readDom
|    |    663         return xstransact.Read(self.dompath, *args)
|    |    > xenstore/xstransact.py:Read
|    |     297         return complete(path, lambda t: t.read(*args))
|    |    |> xenstore/xstransact.py:complete
|    |    | 350     while True:
|    |    | 351         t = xstransact(path)
|    |    | > xenstore/xstransact.py:__init__
|    |    |   14         assert path is not None
|    |    |   16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |   19         self.path = path.rstrip("/")
|    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |   21         self.in_transaction = True
|    |    | < xenstore/xstransact.py:__init__
|    |    | 352         try:
|    |    | 353             result = f(t)
|    |    | > xenstore/xstransact.py:<lambda>
|    |    |  297         return complete(path, lambda t: t.read(*args))
|    |    |  > xenstore/xstransact.py:read
|    |    |    59         if len(args) == 0:
|    |    |    61         if len(args) == 1:
|    |    |    62             return self._read(args[0])
|    |    |   > xenstore/xstransact.py:_read
|    |    |     44         path = self.prependPath(key)
|    |    |    > xenstore/xstransact.py:prependPath
|    |    |     283         if self.path:
|    |    |     284             return self.path + '/' + key
|    |    |    < xenstore/xstransact.py:prependPath
|    |    |     45         try:
|    |    |     46             return xshandle().read(self.transaction, path)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |   < xenstore/xstransact.py:_read
|    |    |  < xenstore/xstransact.py:read
|    |    | < xenstore/xstransact.py:<lambda>
|    |    | 354             if t.commit():
|    |    | > xenstore/xstransact.py:commit
|    |    |   28         if not self.in_transaction:
|    |    |   30         self.in_transaction = False
|    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |   32         self.transaction = "0"
|    |    |   33         return rc
|    |    | < xenstore/xstransact.py:commit
|    |    | 355                 return result
|    |    |< xenstore/xstransact.py:complete
|    |    |> xenstore/xstransact.py:__del__
|    |    |  24         if self.in_transaction:
|    |    |< xenstore/xstransact.py:__del__
|    |    < xenstore/xstransact.py:Read
|    |   < XendDomainInfo.py:_readDom
|    |   909                     reason = 
shutdown_reason(xeninfo['shutdown_reason'])
|    |   > XendDomainInfo.py:shutdown_reason
|    |    296     return DOMAIN_SHUTDOWN_REASONS.get(code, "?")
|    |   < XendDomainInfo.py:shutdown_reason
|    |   911                     log.info('Domain has shutdown: name=%s id=%d 
reason=%s.',
|    |   912                              self.info['name'], self.domid, reason)
|    |   914                     self._clearRestart()
|    |   > XendDomainInfo.py:_clearRestart
|    |    961         self._removeDom("xend/shutdown_start_time")
|    |    > XendDomainInfo.py:_removeDom
|    |     669         return xstransact.Remove(self.dompath, *args)
|    |    |> xenstore/xstransact.py:Remove
|    |    | 309         complete(path, lambda t: t.remove(*args))
|    |    | > xenstore/xstransact.py:complete
|    |    |  350     while True:
|    |    |  351         t = xstransact(path)
|    |    |  > xenstore/xstransact.py:__init__
|    |    |    14         assert path is not None
|    |    |    16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |    19         self.path = path.rstrip("/")
|    |    |    20         self.transaction = xshandle().transaction_start()
|    |    |   > xenstore/xsutil.py:xshandle
|    |    |     15     if not xs_handle:
|    |    |     20     return xs_handle
|    |    |   < xenstore/xsutil.py:xshandle
|    |    |    21         self.in_transaction = True
|    |    |  < xenstore/xstransact.py:__init__
|    |    |  352         try:
|    |    |  353             result = f(t)
|    |    |  > xenstore/xstransact.py:<lambda>
|    |    |   309         complete(path, lambda t: t.remove(*args))
|    |    |   > xenstore/xstransact.py:remove
|    |    |    110         if len(args) == 0:
|    |    |    113             for key in args:
|    |    |    114                 self._remove(key)
|    |    |    > xenstore/xstransact.py:_remove
|    |    |     102         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 284             return self.path + '/' + key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     103         return xshandle().rm(self.transaction, path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    < xenstore/xstransact.py:_remove
|    |    |    113             for key in args:
|    |    |   < xenstore/xstransact.py:remove
|    |    |  < xenstore/xstransact.py:<lambda>
|    |    |  354             if t.commit():
|    |    |  > xenstore/xstransact.py:commit
|    |    |    28         if not self.in_transaction:
|    |    |    30         self.in_transaction = False
|    |    |    31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |   > xenstore/xsutil.py:xshandle
|    |    |     15     if not xs_handle:
|    |    |     20     return xs_handle
|    |    |   < xenstore/xsutil.py:xshandle
|    |    |    32         self.transaction = "0"
|    |    |    33         return rc
|    |    |  < xenstore/xstransact.py:commit
|    |    |  355                 return result
|    |    | < xenstore/xstransact.py:complete
|    |    | > xenstore/xstransact.py:__del__
|    |    |   24         if self.in_transaction:
|    |    | < xenstore/xstransact.py:__del__
|    |    |< xenstore/xstransact.py:Remove
|    |    < XendDomainInfo.py:_removeDom
|    |   < XendDomainInfo.py:_clearRestart
|    |   916                     if reason == 'suspend':
|    |   923                     elif reason in ['poweroff', 'reboot']:
|    |   924                         restart_reason = reason
|    |   950             self.refresh_shutdown_lock.release()
|    |   952         if restart_reason:
|    |   953             self._maybeRestart(restart_reason)
|    |   > XendDomainInfo.py:_maybeRestart
|    |    967         {"destroy"        : self.destroy,
|    |    > XendDomainInfo.py:_restart
|    |     982         from xen.xend import XendDomain
|    |     984         self._configureBootloader()
|    |    |> XendDomainInfo.py:_configureBootloader
|    |    |1457         if not self.info['bootloader']:
|    |    |1458             return
|    |    |< XendDomainInfo.py:_configureBootloader
|    |     985         config = self.sxpr()
|    |    |> XendDomainInfo.py:sxpr
|    |    |1663         result = self.info.get_sxp(domain = self,
|    |    |1664                                    ignore_devices = 
ignore_store)
|    |    | > XendConfig.py:get_sxp
|    |    |  683         sxpr = ['domain']
|    |    |  688         if domain.getDomid() != None:
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    |  689             sxpr.append(['domid', domain.getDomid()])
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  692             if cfg in self:
|    |    |  693                 if self[cfg] != None:
|    |    |  694                     sxpr.append([cfg, self[cfg]])
|    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |  696         if 'image' in self and self['image'] != None:
|    |    |  697             sxpr.append(['image', self['image']])
|    |    |  698         if 'security' in self and self['security']:
|    |    |  700         if 'shutdown_reason' in self:
|    |    |  701             sxpr.append(['shutdown_reason', 
self['shutdown_reason']])
|    |    |  702         if 'cpu_time' in self:
|    |    |  703             sxpr.append(['cpu_time', self['cpu_time']/1e9])
|    |    |  705         sxpr.append(['online_vcpus', self['online_vcpus']])
|    |    |  707         if 'start_time' in self:
|    |    |  708             uptime = time.time() - self['start_time']
|    |    |  709             sxpr.append(['up_time', str(uptime)])
|    |    |  710             sxpr.append(['start_time', 
str(self['start_time'])])
|    |    |  712         if domain:
|    |    |  713             sxpr.append(['status', str(domain.state)])
|    |    |  717         sxpr.append(['state', self._get_old_state_string()])
|    |    |  > XendConfig.py:_get_old_state_string
|    |    |   662         state_string = ''
|    |    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |   664             on_off = self.get(state_name, 0)
|    |    |   665             if on_off:
|    |    |   668                 state_string += '-'
|    |    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |   664             on_off = self.get(state_name, 0)
|    |    |   665             if on_off:
|    |    |   668                 state_string += '-'
|    |    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |   664             on_off = self.get(state_name, 0)
|    |    |   665             if on_off:
|    |    |   668                 state_string += '-'
|    |    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |   664             on_off = self.get(state_name, 0)
|    |    |   665             if on_off:
|    |    |   666                 state_string += state_name[0]
|    |    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |   664             on_off = self.get(state_name, 0)
|    |    |   665             if on_off:
|    |    |   668                 state_string += '-'
|    |    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |   664             on_off = self.get(state_name, 0)
|    |    |   665             if on_off:
|    |    |   668                 state_string += '-'
|    |    |   663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |   670         return state_string
|    |    |  < XendConfig.py:_get_old_state_string
|    |    |  718         sxpr.append(['memory_dynamic_max', 
self.get('memory_dynamic_max',
|    |    |  719                                                     
self['memory'])])
|    |    |  722         if domain:
|    |    |  723             if domain.store_mfn:
|    |    |  724                 sxpr.append(['store_mfn', domain.store_mfn])
|    |    |  725             if domain.console_mfn:
|    |    |  726                 sxpr.append(['console_mfn', 
domain.console_mfn])
|    |    |  729         if not ignore_devices:
|    |    |  730             for cls in XendDevices.valid_devices():
|    |    |  > XendDevices.py:valid_devices
|    |    |    48         return cls.controllers.keys()
|    |    |  < XendDevices.py:valid_devices
|    |    |  731                 found = False
|    |    |  734                 if domain:
|    |    |  735                     try:
|    |    |  736                         controller = 
domain.getDeviceController(cls)
|    |    |  > XendDomainInfo.py:getDeviceController
|    |    |  1152         if name not in self._deviceControllers:
|    |    |  1158         return self._deviceControllers[name]
|    |    |  < XendDomainInfo.py:getDeviceController
|    |    |  737                         configs = controller.configurations()
|    |    |  > server/DevController.py:configurations
|    |    |   216         return map(self.configuration, self.deviceIDs())
|    |    |   > server/DevController.py:deviceIDs
|    |    |    368         fe = self.backendRoot()
|    |    |    > server/DevController.py:backendRoot
|    |    |     476         from xen.xend.XendDomain import DOM0_ID
|    |    |     477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |     478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |    |> xenstore/xsutil.py:GetDomainPath
|    |    |    |  26     return xshandle().get_domain_path(domid)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xsutil.py:GetDomainPath
|    |    |    |> XendDomainInfo.py:getDomid
|    |    |    | 789         return self.domid
|    |    |    |< XendDomainInfo.py:getDomid
|    |    |    < server/DevController.py:backendRoot
|    |    |    369         if transaction:
|    |    |    372             return map(int, xstransact.List(fe))
|    |    |    > xenstore/xstransact.py:List
|    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |> xenstore/xstransact.py:complete
|    |    |    | 350     while True:
|    |    |    | 351         t = xstransact(path)
|    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |   14         assert path is not None
|    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|    |    |    | < xenstore/xstransact.py:__init__
|    |    |    | 352         try:
|    |    |    | 353             result = f(t)
|    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |    |  > xenstore/xstransact.py:list
|    |    |    |   129         if len(args) == 0:
|    |    |    |   130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |   131             if ret is None:
|    |    |    |   132                 return []
|    |    |    |  < xenstore/xstransact.py:list
|    |    |    | < xenstore/xstransact.py:<lambda>
|    |    |    | 354             if t.commit():
|    |    |    | > xenstore/xstransact.py:commit
|    |    |    |   28         if not self.in_transaction:
|    |    |    |   30         self.in_transaction = False
|    |    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   32         self.transaction = "0"
|    |    |    |   33         return rc
|    |    |    | < xenstore/xstransact.py:commit
|    |    |    | 355                 return result
|    |    |    |< xenstore/xstransact.py:complete
|    |    |    |> xenstore/xstransact.py:__del__
|    |    |    |  24         if self.in_transaction:
|    |    |    |< xenstore/xstransact.py:__del__
|    |    |    < xenstore/xstransact.py:List
|    |    |   < server/DevController.py:deviceIDs
|    |    |  < server/DevController.py:configurations
|    |    |  738                         for config in configs:
|    |    |  747                 if not found:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  > XendConfig.py:all_devices_sxpr
|    |    |   914         sxprs = []
|    |    |   915         pci_devs = []
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   917             if dev_type == 'pci': # special case for pci 
devices
|    |    |   920                 sxpr =  self.device_sxpr(dev_type = dev_type,
|    |    |   921                                          dev_info = dev_info)
|    |    |   > XendConfig.py:device_sxpr
|    |    |    898         sxpr = []
|    |    |    899         if dev_uuid != None and dev_uuid in self['device']:
|    |    |    902         if dev_type == None or dev_info == None:
|    |    |    906         sxpr.append(dev_type)
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    908         sxpr += config
|    |    |    910         return sxpr
|    |    |   < XendConfig.py:device_sxpr
|    |    |   922                 sxprs.append((dev_type, sxpr))
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   926         if pci_devs:
|    |    |   934         return sxprs
|    |    |  < XendConfig.py:all_devices_sxpr
|    |    |  749                         if dev_type == cls:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  730             for cls in XendDevices.valid_devices():
|    |    |  731                 found = False
|    |    |  734                 if domain:
|    |    |  735                     try:
|    |    |  736                         controller = 
domain.getDeviceController(cls)
|    |    |  > XendDomainInfo.py:getDeviceController
|    |    |  1152         if name not in self._deviceControllers:
|    |    |  1158         return self._deviceControllers[name]
|    |    |  < XendDomainInfo.py:getDeviceController
|    |    |  737                         configs = controller.configurations()
|    |    |  > server/DevController.py:configurations
|    |    |   216         return map(self.configuration, self.deviceIDs())
|    |    |   > server/DevController.py:deviceIDs
|    |    |    368         fe = self.backendRoot()
|    |    |    > server/DevController.py:backendRoot
|    |    |     476         from xen.xend.XendDomain import DOM0_ID
|    |    |     477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |     478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |    |> xenstore/xsutil.py:GetDomainPath
|    |    |    |  26     return xshandle().get_domain_path(domid)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xsutil.py:GetDomainPath
|    |    |    |> XendDomainInfo.py:getDomid
|    |    |    | 789         return self.domid
|    |    |    |< XendDomainInfo.py:getDomid
|    |    |    < server/DevController.py:backendRoot
|    |    |    369         if transaction:
|    |    |    372             return map(int, xstransact.List(fe))
|    |    |    > xenstore/xstransact.py:List
|    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |> xenstore/xstransact.py:complete
|    |    |    | 350     while True:
|    |    |    | 351         t = xstransact(path)
|    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |   14         assert path is not None
|    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|    |    |    | < xenstore/xstransact.py:__init__
|    |    |    | 352         try:
|    |    |    | 353             result = f(t)
|    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |    |  > xenstore/xstransact.py:list
|    |    |    |   129         if len(args) == 0:
|    |    |    |   130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |   131             if ret is None:
|    |    |    |   132                 return []
|    |    |    |  < xenstore/xstransact.py:list
|    |    |    | < xenstore/xstransact.py:<lambda>
|    |    |    | 354             if t.commit():
|    |    |    | > xenstore/xstransact.py:commit
|    |    |    |   28         if not self.in_transaction:
|    |    |    |   30         self.in_transaction = False
|    |    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   32         self.transaction = "0"
|    |    |    |   33         return rc
|    |    |    | < xenstore/xstransact.py:commit
|    |    |    | 355                 return result
|    |    |    |< xenstore/xstransact.py:complete
|    |    |    |> xenstore/xstransact.py:__del__
|    |    |    |  24         if self.in_transaction:
|    |    |    |< xenstore/xstransact.py:__del__
|    |    |    < xenstore/xstransact.py:List
|    |    |   < server/DevController.py:deviceIDs
|    |    |  < server/DevController.py:configurations
|    |    |  738                         for config in configs:
|    |    |  747                 if not found:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  > XendConfig.py:all_devices_sxpr
|    |    |   914         sxprs = []
|    |    |   915         pci_devs = []
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   917             if dev_type == 'pci': # special case for pci 
devices
|    |    |   920                 sxpr =  self.device_sxpr(dev_type = dev_type,
|    |    |   921                                          dev_info = dev_info)
|    |    |   > XendConfig.py:device_sxpr
|    |    |    898         sxpr = []
|    |    |    899         if dev_uuid != None and dev_uuid in self['device']:
|    |    |    902         if dev_type == None or dev_info == None:
|    |    |    906         sxpr.append(dev_type)
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    908         sxpr += config
|    |    |    910         return sxpr
|    |    |   < XendConfig.py:device_sxpr
|    |    |   922                 sxprs.append((dev_type, sxpr))
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   926         if pci_devs:
|    |    |   934         return sxprs
|    |    |  < XendConfig.py:all_devices_sxpr
|    |    |  749                         if dev_type == cls:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  730             for cls in XendDevices.valid_devices():
|    |    |  731                 found = False
|    |    |  734                 if domain:
|    |    |  735                     try:
|    |    |  736                         controller = 
domain.getDeviceController(cls)
|    |    |  > XendDomainInfo.py:getDeviceController
|    |    |  1152         if name not in self._deviceControllers:
|    |    |  1158         return self._deviceControllers[name]
|    |    |  < XendDomainInfo.py:getDeviceController
|    |    |  737                         configs = controller.configurations()
|    |    |  > server/DevController.py:configurations
|    |    |   216         return map(self.configuration, self.deviceIDs())
|    |    |   > server/DevController.py:deviceIDs
|    |    |    368         fe = self.backendRoot()
|    |    |    > server/DevController.py:backendRoot
|    |    |     476         from xen.xend.XendDomain import DOM0_ID
|    |    |     477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |     478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |    |> xenstore/xsutil.py:GetDomainPath
|    |    |    |  26     return xshandle().get_domain_path(domid)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xsutil.py:GetDomainPath
|    |    |    |> XendDomainInfo.py:getDomid
|    |    |    | 789         return self.domid
|    |    |    |< XendDomainInfo.py:getDomid
|    |    |    < server/DevController.py:backendRoot
|    |    |    369         if transaction:
|    |    |    372             return map(int, xstransact.List(fe))
|    |    |    > xenstore/xstransact.py:List
|    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |> xenstore/xstransact.py:complete
|    |    |    | 350     while True:
|    |    |    | 351         t = xstransact(path)
|    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |   14         assert path is not None
|    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|    |    |    | < xenstore/xstransact.py:__init__
|    |    |    | 352         try:
|    |    |    | 353             result = f(t)
|    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |    |  > xenstore/xstransact.py:list
|    |    |    |   129         if len(args) == 0:
|    |    |    |   130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |   131             if ret is None:
|    |    |    |   134                 return ret
|    |    |    |  < xenstore/xstransact.py:list
|    |    |    | < xenstore/xstransact.py:<lambda>
|    |    |    | 354             if t.commit():
|    |    |    | > xenstore/xstransact.py:commit
|    |    |    |   28         if not self.in_transaction:
|    |    |    |   30         self.in_transaction = False
|    |    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   32         self.transaction = "0"
|    |    |    |   33         return rc
|    |    |    | < xenstore/xstransact.py:commit
|    |    |    | 355                 return result
|    |    |    |< xenstore/xstransact.py:complete
|    |    |    |> xenstore/xstransact.py:__del__
|    |    |    |  24         if self.in_transaction:
|    |    |    |< xenstore/xstransact.py:__del__
|    |    |    < xenstore/xstransact.py:List
|    |    |   < server/DevController.py:deviceIDs
|    |    |   > server/DevController.py:configuration
|    |    |    223         configDict = self.getDeviceConfiguration(devid)
|    |    |    > server/blkif.py:getDeviceConfiguration
|    |    |     116         config = DevController.getDeviceConfiguration(self, 
devid)
|    |    |    |> server/DevController.py:getDeviceConfiguration
|    |    |    | 253         backdomid = 
xstransact.Read(self.frontendPath(devid), "backend-id")
|    |    |    | > server/DevController.py:frontendPath
|    |    |    |  468         return "%s/%d" % (self.frontendRoot(), devid)
|    |    |    |  > server/DevController.py:frontendRoot
|    |    |    |   472         return "%s/device/%s" % 
(self.vm.getDomainPath(), self.deviceClass)
|    |    |    |   > XendDomainInfo.py:getDomainPath
|    |    |    |    800         return self.dompath
|    |    |    |   < XendDomainInfo.py:getDomainPath
|    |    |    |  < server/DevController.py:frontendRoot
|    |    |    | < server/DevController.py:frontendPath
|    |    |    | > xenstore/xstransact.py:Read
|    |    |    |  297         return complete(path, lambda t: t.read(*args))
|    |    |    |  > xenstore/xstransact.py:complete
|    |    |    |   350     while True:
|    |    |    |   351         t = xstransact(path)
|    |    |    |   > xenstore/xstransact.py:__init__
|    |    |    |     14         assert path is not None
|    |    |    |     16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |     19         self.path = path.rstrip("/")
|    |    |    |     20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |     21         self.in_transaction = True
|    |    |    |   < xenstore/xstransact.py:__init__
|    |    |    |   352         try:
|    |    |    |   353             result = f(t)
|    |    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    |    297         return complete(path, lambda t: t.read(*args))
|    |    |    |    > xenstore/xstransact.py:read
|    |    |    |      59         if len(args) == 0:
|    |    |    |      61         if len(args) == 1:
|    |    |    |      62             return self._read(args[0])
|    |    |    |    |> xenstore/xstransact.py:_read
|    |    |    |    |  44         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  45         try:
|    |    |    |    |  46             return xshandle().read(self.transaction, 
path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_read
|    |    |    |    < xenstore/xstransact.py:read
|    |    |    |   < xenstore/xstransact.py:<lambda>
|    |    |    |   354             if t.commit():
|    |    |    |   > xenstore/xstransact.py:commit
|    |    |    |     28         if not self.in_transaction:
|    |    |    |     30         self.in_transaction = False
|    |    |    |     31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |     32         self.transaction = "0"
|    |    |    |     33         return rc
|    |    |    |   < xenstore/xstransact.py:commit
|    |    |    |   355                 return result
|    |    |    |  < xenstore/xstransact.py:complete
|    |    |    |  > xenstore/xstransact.py:__del__
|    |    |    |    24         if self.in_transaction:
|    |    |    |  < xenstore/xstransact.py:__del__
|    |    |    | < xenstore/xstransact.py:Read
|    |    |    | 254         if backdomid is None:
|    |    |    | 257         return {'backend': int(backdomid)}
|    |    |    |< server/DevController.py:getDeviceConfiguration
|    |    |     117         devinfo = self.readBackend(devid, 'dev', 'type', 
'params', 'mode',
|    |    |     118                                    'uuid')
|    |    |    |> server/DevController.py:readBackend
|    |    |    | 354         frontpath = self.frontendPath(devid)
|    |    |    | > server/DevController.py:frontendPath
|    |    |    |  468         return "%s/%d" % (self.frontendRoot(), devid)
|    |    |    |  > server/DevController.py:frontendRoot
|    |    |    |   472         return "%s/device/%s" % 
(self.vm.getDomainPath(), self.deviceClass)
|    |    |    |   > XendDomainInfo.py:getDomainPath
|    |    |    |    800         return self.dompath
|    |    |    |   < XendDomainInfo.py:getDomainPath
|    |    |    |  < server/DevController.py:frontendRoot
|    |    |    | < server/DevController.py:frontendPath
|    |    |    | 355         backpath = xstransact.Read(frontpath, "backend")
|    |    |    | > xenstore/xstransact.py:Read
|    |    |    |  297         return complete(path, lambda t: t.read(*args))
|    |    |    |  > xenstore/xstransact.py:complete
|    |    |    |   350     while True:
|    |    |    |   351         t = xstransact(path)
|    |    |    |   > xenstore/xstransact.py:__init__
|    |    |    |     14         assert path is not None
|    |    |    |     16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |     19         self.path = path.rstrip("/")
|    |    |    |     20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |     21         self.in_transaction = True
|    |    |    |   < xenstore/xstransact.py:__init__
|    |    |    |   352         try:
|    |    |    |   353             result = f(t)
|    |    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    |    297         return complete(path, lambda t: t.read(*args))
|    |    |    |    > xenstore/xstransact.py:read
|    |    |    |      59         if len(args) == 0:
|    |    |    |      61         if len(args) == 1:
|    |    |    |      62             return self._read(args[0])
|    |    |    |    |> xenstore/xstransact.py:_read
|    |    |    |    |  44         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  45         try:
|    |    |    |    |  46             return xshandle().read(self.transaction, 
path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_read
|    |    |    |    < xenstore/xstransact.py:read
|    |    |    |   < xenstore/xstransact.py:<lambda>
|    |    |    |   354             if t.commit():
|    |    |    |   > xenstore/xstransact.py:commit
|    |    |    |     28         if not self.in_transaction:
|    |    |    |     30         self.in_transaction = False
|    |    |    |     31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |     32         self.transaction = "0"
|    |    |    |     33         return rc
|    |    |    |   < xenstore/xstransact.py:commit
|    |    |    |   355                 return result
|    |    |    |  < xenstore/xstransact.py:complete
|    |    |    |  > xenstore/xstransact.py:__del__
|    |    |    |    24         if self.in_transaction:
|    |    |    |  < xenstore/xstransact.py:__del__
|    |    |    | < xenstore/xstransact.py:Read
|    |    |    | 356         if backpath:
|    |    |    | 357             return xstransact.Read(backpath, *args)
|    |    |    | > xenstore/xstransact.py:Read
|    |    |    |  297         return complete(path, lambda t: t.read(*args))
|    |    |    |  > xenstore/xstransact.py:complete
|    |    |    |   350     while True:
|    |    |    |   351         t = xstransact(path)
|    |    |    |   > xenstore/xstransact.py:__init__
|    |    |    |     14         assert path is not None
|    |    |    |     16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |     19         self.path = path.rstrip("/")
|    |    |    |     20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |     21         self.in_transaction = True
|    |    |    |   < xenstore/xstransact.py:__init__
|    |    |    |   352         try:
|    |    |    |   353             result = f(t)
|    |    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    |    297         return complete(path, lambda t: t.read(*args))
|    |    |    |    > xenstore/xstransact.py:read
|    |    |    |      59         if len(args) == 0:
|    |    |    |      61         if len(args) == 1:
|    |    |    |      63         ret = []
|    |    |    |      64         for key in args:
|    |    |    |      65             ret.append(self._read(key))
|    |    |    |    |> xenstore/xstransact.py:_read
|    |    |    |    |  44         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  45         try:
|    |    |    |    |  46             return xshandle().read(self.transaction, 
path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_read
|    |    |    |      64         for key in args:
|    |    |    |      65             ret.append(self._read(key))
|    |    |    |    |> xenstore/xstransact.py:_read
|    |    |    |    |  44         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  45         try:
|    |    |    |    |  46             return xshandle().read(self.transaction, 
path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_read
|    |    |    |      64         for key in args:
|    |    |    |      65             ret.append(self._read(key))
|    |    |    |    |> xenstore/xstransact.py:_read
|    |    |    |    |  44         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  45         try:
|    |    |    |    |  46             return xshandle().read(self.transaction, 
path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_read
|    |    |    |      64         for key in args:
|    |    |    |      65             ret.append(self._read(key))
|    |    |    |    |> xenstore/xstransact.py:_read
|    |    |    |    |  44         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  45         try:
|    |    |    |    |  46             return xshandle().read(self.transaction, 
path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_read
|    |    |    |      64         for key in args:
|    |    |    |      65             ret.append(self._read(key))
|    |    |    |    |> xenstore/xstransact.py:_read
|    |    |    |    |  44         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  45         try:
|    |    |    |    |  46             return xshandle().read(self.transaction, 
path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_read
|    |    |    |      64         for key in args:
|    |    |    |      66         return ret
|    |    |    |    < xenstore/xstransact.py:read
|    |    |    |   < xenstore/xstransact.py:<lambda>
|    |    |    |   354             if t.commit():
|    |    |    |   > xenstore/xstransact.py:commit
|    |    |    |     28         if not self.in_transaction:
|    |    |    |     30         self.in_transaction = False
|    |    |    |     31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |     32         self.transaction = "0"
|    |    |    |     33         return rc
|    |    |    |   < xenstore/xstransact.py:commit
|    |    |    |   355                 return result
|    |    |    |  < xenstore/xstransact.py:complete
|    |    |    |  > xenstore/xstransact.py:__del__
|    |    |    |    24         if self.in_transaction:
|    |    |    |  < xenstore/xstransact.py:__del__
|    |    |    | < xenstore/xstransact.py:Read
|    |    |    |< server/DevController.py:readBackend
|    |    |     119         dev, typ, params, mode, uuid = devinfo
|    |    |     121         if dev:
|    |    |     122             dev_type = self.readFrontend(devid, 
'device-type')
|    |    |    |> server/DevController.py:readFrontend
|    |    |    | 362         return xstransact.Read(self.frontendPath(devid), 
*args)
|    |    |    | > server/DevController.py:frontendPath
|    |    |    |  468         return "%s/%d" % (self.frontendRoot(), devid)
|    |    |    |  > server/DevController.py:frontendRoot
|    |    |    |   472         return "%s/device/%s" % 
(self.vm.getDomainPath(), self.deviceClass)
|    |    |    |   > XendDomainInfo.py:getDomainPath
|    |    |    |    800         return self.dompath
|    |    |    |   < XendDomainInfo.py:getDomainPath
|    |    |    |  < server/DevController.py:frontendRoot
|    |    |    | < server/DevController.py:frontendPath
|    |    |    | > xenstore/xstransact.py:Read
|    |    |    |  297         return complete(path, lambda t: t.read(*args))
|    |    |    |  > xenstore/xstransact.py:complete
|    |    |    |   350     while True:
|    |    |    |   351         t = xstransact(path)
|    |    |    |   > xenstore/xstransact.py:__init__
|    |    |    |     14         assert path is not None
|    |    |    |     16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |     19         self.path = path.rstrip("/")
|    |    |    |     20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |     21         self.in_transaction = True
|    |    |    |   < xenstore/xstransact.py:__init__
|    |    |    |   352         try:
|    |    |    |   353             result = f(t)
|    |    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    |    297         return complete(path, lambda t: t.read(*args))
|    |    |    |    > xenstore/xstransact.py:read
|    |    |    |      59         if len(args) == 0:
|    |    |    |      61         if len(args) == 1:
|    |    |    |      62             return self._read(args[0])
|    |    |    |    |> xenstore/xstransact.py:_read
|    |    |    |    |  44         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  45         try:
|    |    |    |    |  46             return xshandle().read(self.transaction, 
path)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_read
|    |    |    |    < xenstore/xstransact.py:read
|    |    |    |   < xenstore/xstransact.py:<lambda>
|    |    |    |   354             if t.commit():
|    |    |    |   > xenstore/xstransact.py:commit
|    |    |    |     28         if not self.in_transaction:
|    |    |    |     30         self.in_transaction = False
|    |    |    |     31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |     32         self.transaction = "0"
|    |    |    |     33         return rc
|    |    |    |   < xenstore/xstransact.py:commit
|    |    |    |   355                 return result
|    |    |    |  < xenstore/xstransact.py:complete
|    |    |    |  > xenstore/xstransact.py:__del__
|    |    |    |    24         if self.in_transaction:
|    |    |    |  < xenstore/xstransact.py:__del__
|    |    |    | < xenstore/xstransact.py:Read
|    |    |    |< server/DevController.py:readFrontend
|    |    |     123             if dev_type:
|    |    |     124                 dev += ':' + dev_type
|    |    |     125             config['dev'] = dev
|    |    |     126         if typ and params:
|    |    |     127             config['uname'] = typ +':' + params
|    |    |     128         if mode:
|    |    |     129             config['mode'] = mode
|    |    |     130         if uuid:
|    |    |     131             config['uuid'] = uuid
|    |    |     133         return config
|    |    |    < server/blkif.py:getDeviceConfiguration
|    |    |    224         sxpr = [self.deviceClass]
|    |    |    225         for key, val in configDict.items():
|    |    |    226             if type(val) == type(list()):
|    |    |    230                 sxpr.append([key, val])
|    |    |    225         for key, val in configDict.items():
|    |    |    226             if type(val) == type(list()):
|    |    |    230                 sxpr.append([key, val])
|    |    |    225         for key, val in configDict.items():
|    |    |    226             if type(val) == type(list()):
|    |    |    230                 sxpr.append([key, val])
|    |    |    225         for key, val in configDict.items():
|    |    |    226             if type(val) == type(list()):
|    |    |    230                 sxpr.append([key, val])
|    |    |    225         for key, val in configDict.items():
|    |    |    226             if type(val) == type(list()):
|    |    |    230                 sxpr.append([key, val])
|    |    |    225         for key, val in configDict.items():
|    |    |    231         return sxpr
|    |    |   < server/DevController.py:configuration
|    |    |  < server/DevController.py:configurations
|    |    |  738                         for config in configs:
|    |    |  739                             sxpr.append(['device', config])
|    |    |  740                             found = True
|    |    |  738                         for config in configs:
|    |    |  747                 if not found:
|    |    |  730             for cls in XendDevices.valid_devices():
|    |    |  731                 found = False
|    |    |  734                 if domain:
|    |    |  735                     try:
|    |    |  736                         controller = 
domain.getDeviceController(cls)
|    |    |  > XendDomainInfo.py:getDeviceController
|    |    |  1152         if name not in self._deviceControllers:
|    |    |  1158         return self._deviceControllers[name]
|    |    |  < XendDomainInfo.py:getDeviceController
|    |    |  737                         configs = controller.configurations()
|    |    |  > server/DevController.py:configurations
|    |    |   216         return map(self.configuration, self.deviceIDs())
|    |    |   > server/DevController.py:deviceIDs
|    |    |    368         fe = self.backendRoot()
|    |    |    > server/DevController.py:backendRoot
|    |    |     476         from xen.xend.XendDomain import DOM0_ID
|    |    |     477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |     478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |    |> xenstore/xsutil.py:GetDomainPath
|    |    |    |  26     return xshandle().get_domain_path(domid)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xsutil.py:GetDomainPath
|    |    |    |> XendDomainInfo.py:getDomid
|    |    |    | 789         return self.domid
|    |    |    |< XendDomainInfo.py:getDomid
|    |    |    < server/DevController.py:backendRoot
|    |    |    369         if transaction:
|    |    |    372             return map(int, xstransact.List(fe))
|    |    |    > xenstore/xstransact.py:List
|    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |> xenstore/xstransact.py:complete
|    |    |    | 350     while True:
|    |    |    | 351         t = xstransact(path)
|    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |   14         assert path is not None
|    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|    |    |    | < xenstore/xstransact.py:__init__
|    |    |    | 352         try:
|    |    |    | 353             result = f(t)
|    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |    |  > xenstore/xstransact.py:list
|    |    |    |   129         if len(args) == 0:
|    |    |    |   130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |   131             if ret is None:
|    |    |    |   132                 return []
|    |    |    |  < xenstore/xstransact.py:list
|    |    |    | < xenstore/xstransact.py:<lambda>
|    |    |    | 354             if t.commit():
|    |    |    | > xenstore/xstransact.py:commit
|    |    |    |   28         if not self.in_transaction:
|    |    |    |   30         self.in_transaction = False
|    |    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   32         self.transaction = "0"
|    |    |    |   33         return rc
|    |    |    | < xenstore/xstransact.py:commit
|    |    |    | 355                 return result
|    |    |    |< xenstore/xstransact.py:complete
|    |    |    |> xenstore/xstransact.py:__del__
|    |    |    |  24         if self.in_transaction:
|    |    |    |< xenstore/xstransact.py:__del__
|    |    |    < xenstore/xstransact.py:List
|    |    |   < server/DevController.py:deviceIDs
|    |    |  < server/DevController.py:configurations
|    |    |  738                         for config in configs:
|    |    |  747                 if not found:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  > XendConfig.py:all_devices_sxpr
|    |    |   914         sxprs = []
|    |    |   915         pci_devs = []
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   917             if dev_type == 'pci': # special case for pci 
devices
|    |    |   920                 sxpr =  self.device_sxpr(dev_type = dev_type,
|    |    |   921                                          dev_info = dev_info)
|    |    |   > XendConfig.py:device_sxpr
|    |    |    898         sxpr = []
|    |    |    899         if dev_uuid != None and dev_uuid in self['device']:
|    |    |    902         if dev_type == None or dev_info == None:
|    |    |    906         sxpr.append(dev_type)
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    908         sxpr += config
|    |    |    910         return sxpr
|    |    |   < XendConfig.py:device_sxpr
|    |    |   922                 sxprs.append((dev_type, sxpr))
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   926         if pci_devs:
|    |    |   934         return sxprs
|    |    |  < XendConfig.py:all_devices_sxpr
|    |    |  749                         if dev_type == cls:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  730             for cls in XendDevices.valid_devices():
|    |    |  731                 found = False
|    |    |  734                 if domain:
|    |    |  735                     try:
|    |    |  736                         controller = 
domain.getDeviceController(cls)
|    |    |  > XendDomainInfo.py:getDeviceController
|    |    |  1152         if name not in self._deviceControllers:
|    |    |  1158         return self._deviceControllers[name]
|    |    |  < XendDomainInfo.py:getDeviceController
|    |    |  737                         configs = controller.configurations()
|    |    |  > server/DevController.py:configurations
|    |    |   216         return map(self.configuration, self.deviceIDs())
|    |    |   > server/DevController.py:deviceIDs
|    |    |    368         fe = self.backendRoot()
|    |    |    > server/DevController.py:backendRoot
|    |    |     476         from xen.xend.XendDomain import DOM0_ID
|    |    |     477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |     478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |    |> xenstore/xsutil.py:GetDomainPath
|    |    |    |  26     return xshandle().get_domain_path(domid)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xsutil.py:GetDomainPath
|    |    |    |> XendDomainInfo.py:getDomid
|    |    |    | 789         return self.domid
|    |    |    |< XendDomainInfo.py:getDomid
|    |    |    < server/DevController.py:backendRoot
|    |    |    369         if transaction:
|    |    |    372             return map(int, xstransact.List(fe))
|    |    |    > xenstore/xstransact.py:List
|    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |> xenstore/xstransact.py:complete
|    |    |    | 350     while True:
|    |    |    | 351         t = xstransact(path)
|    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |   14         assert path is not None
|    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|    |    |    | < xenstore/xstransact.py:__init__
|    |    |    | 352         try:
|    |    |    | 353             result = f(t)
|    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |    |  > xenstore/xstransact.py:list
|    |    |    |   129         if len(args) == 0:
|    |    |    |   130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |   131             if ret is None:
|    |    |    |   132                 return []
|    |    |    |  < xenstore/xstransact.py:list
|    |    |    | < xenstore/xstransact.py:<lambda>
|    |    |    | 354             if t.commit():
|    |    |    | > xenstore/xstransact.py:commit
|    |    |    |   28         if not self.in_transaction:
|    |    |    |   30         self.in_transaction = False
|    |    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   32         self.transaction = "0"
|    |    |    |   33         return rc
|    |    |    | < xenstore/xstransact.py:commit
|    |    |    | 355                 return result
|    |    |    |< xenstore/xstransact.py:complete
|    |    |    |> xenstore/xstransact.py:__del__
|    |    |    |  24         if self.in_transaction:
|    |    |    |< xenstore/xstransact.py:__del__
|    |    |    < xenstore/xstransact.py:List
|    |    |   < server/DevController.py:deviceIDs
|    |    |  < server/DevController.py:configurations
|    |    |  738                         for config in configs:
|    |    |  747                 if not found:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  > XendConfig.py:all_devices_sxpr
|    |    |   914         sxprs = []
|    |    |   915         pci_devs = []
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   917             if dev_type == 'pci': # special case for pci 
devices
|    |    |   920                 sxpr =  self.device_sxpr(dev_type = dev_type,
|    |    |   921                                          dev_info = dev_info)
|    |    |   > XendConfig.py:device_sxpr
|    |    |    898         sxpr = []
|    |    |    899         if dev_uuid != None and dev_uuid in self['device']:
|    |    |    902         if dev_type == None or dev_info == None:
|    |    |    906         sxpr.append(dev_type)
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    908         sxpr += config
|    |    |    910         return sxpr
|    |    |   < XendConfig.py:device_sxpr
|    |    |   922                 sxprs.append((dev_type, sxpr))
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   926         if pci_devs:
|    |    |   934         return sxprs
|    |    |  < XendConfig.py:all_devices_sxpr
|    |    |  749                         if dev_type == cls:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  730             for cls in XendDevices.valid_devices():
|    |    |  731                 found = False
|    |    |  734                 if domain:
|    |    |  735                     try:
|    |    |  736                         controller = 
domain.getDeviceController(cls)
|    |    |  > XendDomainInfo.py:getDeviceController
|    |    |  1152         if name not in self._deviceControllers:
|    |    |  1158         return self._deviceControllers[name]
|    |    |  < XendDomainInfo.py:getDeviceController
|    |    |  737                         configs = controller.configurations()
|    |    |  > server/DevController.py:configurations
|    |    |   216         return map(self.configuration, self.deviceIDs())
|    |    |   > server/DevController.py:deviceIDs
|    |    |    368         fe = self.backendRoot()
|    |    |    > server/DevController.py:backendRoot
|    |    |     476         from xen.xend.XendDomain import DOM0_ID
|    |    |     477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |     478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |    |> xenstore/xsutil.py:GetDomainPath
|    |    |    |  26     return xshandle().get_domain_path(domid)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xsutil.py:GetDomainPath
|    |    |    |> XendDomainInfo.py:getDomid
|    |    |    | 789         return self.domid
|    |    |    |< XendDomainInfo.py:getDomid
|    |    |    < server/DevController.py:backendRoot
|    |    |    369         if transaction:
|    |    |    372             return map(int, xstransact.List(fe))
|    |    |    > xenstore/xstransact.py:List
|    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |> xenstore/xstransact.py:complete
|    |    |    | 350     while True:
|    |    |    | 351         t = xstransact(path)
|    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |   14         assert path is not None
|    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|    |    |    | < xenstore/xstransact.py:__init__
|    |    |    | 352         try:
|    |    |    | 353             result = f(t)
|    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |    |  > xenstore/xstransact.py:list
|    |    |    |   129         if len(args) == 0:
|    |    |    |   130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |   131             if ret is None:
|    |    |    |   132                 return []
|    |    |    |  < xenstore/xstransact.py:list
|    |    |    | < xenstore/xstransact.py:<lambda>
|    |    |    | 354             if t.commit():
|    |    |    | > xenstore/xstransact.py:commit
|    |    |    |   28         if not self.in_transaction:
|    |    |    |   30         self.in_transaction = False
|    |    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   32         self.transaction = "0"
|    |    |    |   33         return rc
|    |    |    | < xenstore/xstransact.py:commit
|    |    |    | 355                 return result
|    |    |    |< xenstore/xstransact.py:complete
|    |    |    |> xenstore/xstransact.py:__del__
|    |    |    |  24         if self.in_transaction:
|    |    |    |< xenstore/xstransact.py:__del__
|    |    |    < xenstore/xstransact.py:List
|    |    |   < server/DevController.py:deviceIDs
|    |    |  < server/DevController.py:configurations
|    |    |  738                         for config in configs:
|    |    |  747                 if not found:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  > XendConfig.py:all_devices_sxpr
|    |    |   914         sxprs = []
|    |    |   915         pci_devs = []
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   917             if dev_type == 'pci': # special case for pci 
devices
|    |    |   920                 sxpr =  self.device_sxpr(dev_type = dev_type,
|    |    |   921                                          dev_info = dev_info)
|    |    |   > XendConfig.py:device_sxpr
|    |    |    898         sxpr = []
|    |    |    899         if dev_uuid != None and dev_uuid in self['device']:
|    |    |    902         if dev_type == None or dev_info == None:
|    |    |    906         sxpr.append(dev_type)
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    908         sxpr += config
|    |    |    910         return sxpr
|    |    |   < XendConfig.py:device_sxpr
|    |    |   922                 sxprs.append((dev_type, sxpr))
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   926         if pci_devs:
|    |    |   934         return sxprs
|    |    |  < XendConfig.py:all_devices_sxpr
|    |    |  749                         if dev_type == cls:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  730             for cls in XendDevices.valid_devices():
|    |    |  731                 found = False
|    |    |  734                 if domain:
|    |    |  735                     try:
|    |    |  736                         controller = 
domain.getDeviceController(cls)
|    |    |  > XendDomainInfo.py:getDeviceController
|    |    |  1152         if name not in self._deviceControllers:
|    |    |  1158         return self._deviceControllers[name]
|    |    |  < XendDomainInfo.py:getDeviceController
|    |    |  737                         configs = controller.configurations()
|    |    |  > server/DevController.py:configurations
|    |    |   216         return map(self.configuration, self.deviceIDs())
|    |    |   > server/DevController.py:deviceIDs
|    |    |    368         fe = self.backendRoot()
|    |    |    > server/DevController.py:backendRoot
|    |    |     476         from xen.xend.XendDomain import DOM0_ID
|    |    |     477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |     478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |    |> xenstore/xsutil.py:GetDomainPath
|    |    |    |  26     return xshandle().get_domain_path(domid)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xsutil.py:GetDomainPath
|    |    |    |> XendDomainInfo.py:getDomid
|    |    |    | 789         return self.domid
|    |    |    |< XendDomainInfo.py:getDomid
|    |    |    < server/DevController.py:backendRoot
|    |    |    369         if transaction:
|    |    |    372             return map(int, xstransact.List(fe))
|    |    |    > xenstore/xstransact.py:List
|    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |> xenstore/xstransact.py:complete
|    |    |    | 350     while True:
|    |    |    | 351         t = xstransact(path)
|    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |   14         assert path is not None
|    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|    |    |    | < xenstore/xstransact.py:__init__
|    |    |    | 352         try:
|    |    |    | 353             result = f(t)
|    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |    |  > xenstore/xstransact.py:list
|    |    |    |   129         if len(args) == 0:
|    |    |    |   130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |   131             if ret is None:
|    |    |    |   132                 return []
|    |    |    |  < xenstore/xstransact.py:list
|    |    |    | < xenstore/xstransact.py:<lambda>
|    |    |    | 354             if t.commit():
|    |    |    | > xenstore/xstransact.py:commit
|    |    |    |   28         if not self.in_transaction:
|    |    |    |   30         self.in_transaction = False
|    |    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   32         self.transaction = "0"
|    |    |    |   33         return rc
|    |    |    | < xenstore/xstransact.py:commit
|    |    |    | 355                 return result
|    |    |    |< xenstore/xstransact.py:complete
|    |    |    |> xenstore/xstransact.py:__del__
|    |    |    |  24         if self.in_transaction:
|    |    |    |< xenstore/xstransact.py:__del__
|    |    |    < xenstore/xstransact.py:List
|    |    |   < server/DevController.py:deviceIDs
|    |    |  < server/DevController.py:configurations
|    |    |  738                         for config in configs:
|    |    |  747                 if not found:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  > XendConfig.py:all_devices_sxpr
|    |    |   914         sxprs = []
|    |    |   915         pci_devs = []
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   917             if dev_type == 'pci': # special case for pci 
devices
|    |    |   920                 sxpr =  self.device_sxpr(dev_type = dev_type,
|    |    |   921                                          dev_info = dev_info)
|    |    |   > XendConfig.py:device_sxpr
|    |    |    898         sxpr = []
|    |    |    899         if dev_uuid != None and dev_uuid in self['device']:
|    |    |    902         if dev_type == None or dev_info == None:
|    |    |    906         sxpr.append(dev_type)
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    908         sxpr += config
|    |    |    910         return sxpr
|    |    |   < XendConfig.py:device_sxpr
|    |    |   922                 sxprs.append((dev_type, sxpr))
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   926         if pci_devs:
|    |    |   934         return sxprs
|    |    |  < XendConfig.py:all_devices_sxpr
|    |    |  749                         if dev_type == cls:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  730             for cls in XendDevices.valid_devices():
|    |    |  731                 found = False
|    |    |  734                 if domain:
|    |    |  735                     try:
|    |    |  736                         controller = 
domain.getDeviceController(cls)
|    |    |  > XendDomainInfo.py:getDeviceController
|    |    |  1152         if name not in self._deviceControllers:
|    |    |  1158         return self._deviceControllers[name]
|    |    |  < XendDomainInfo.py:getDeviceController
|    |    |  737                         configs = controller.configurations()
|    |    |  > server/DevController.py:configurations
|    |    |   216         return map(self.configuration, self.deviceIDs())
|    |    |   > server/DevController.py:deviceIDs
|    |    |    368         fe = self.backendRoot()
|    |    |    > server/DevController.py:backendRoot
|    |    |     476         from xen.xend.XendDomain import DOM0_ID
|    |    |     477         from xen.xend.xenstore.xsutil import GetDomainPath
|    |    |     478         return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
|    |    |    |> xenstore/xsutil.py:GetDomainPath
|    |    |    |  26     return xshandle().get_domain_path(domid)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xsutil.py:GetDomainPath
|    |    |    |> XendDomainInfo.py:getDomid
|    |    |    | 789         return self.domid
|    |    |    |< XendDomainInfo.py:getDomid
|    |    |    < server/DevController.py:backendRoot
|    |    |    369         if transaction:
|    |    |    372             return map(int, xstransact.List(fe))
|    |    |    > xenstore/xstransact.py:List
|    |    |     319         return complete(path, lambda t: t.list(*args))
|    |    |    |> xenstore/xstransact.py:complete
|    |    |    | 350     while True:
|    |    |    | 351         t = xstransact(path)
|    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |   14         assert path is not None
|    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|    |    |    | < xenstore/xstransact.py:__init__
|    |    |    | 352         try:
|    |    |    | 353             result = f(t)
|    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    |  319         return complete(path, lambda t: t.list(*args))
|    |    |    |  > xenstore/xstransact.py:list
|    |    |    |   129         if len(args) == 0:
|    |    |    |   130             ret = xshandle().ls(self.transaction, 
self.path)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |   131             if ret is None:
|    |    |    |   132                 return []
|    |    |    |  < xenstore/xstransact.py:list
|    |    |    | < xenstore/xstransact.py:<lambda>
|    |    |    | 354             if t.commit():
|    |    |    | > xenstore/xstransact.py:commit
|    |    |    |   28         if not self.in_transaction:
|    |    |    |   30         self.in_transaction = False
|    |    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   32         self.transaction = "0"
|    |    |    |   33         return rc
|    |    |    | < xenstore/xstransact.py:commit
|    |    |    | 355                 return result
|    |    |    |< xenstore/xstransact.py:complete
|    |    |    |> xenstore/xstransact.py:__del__
|    |    |    |  24         if self.in_transaction:
|    |    |    |< xenstore/xstransact.py:__del__
|    |    |    < xenstore/xstransact.py:List
|    |    |   < server/DevController.py:deviceIDs
|    |    |  < server/DevController.py:configurations
|    |    |  738                         for config in configs:
|    |    |  747                 if not found:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  > XendConfig.py:all_devices_sxpr
|    |    |   914         sxprs = []
|    |    |   915         pci_devs = []
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   917             if dev_type == 'pci': # special case for pci 
devices
|    |    |   920                 sxpr =  self.device_sxpr(dev_type = dev_type,
|    |    |   921                                          dev_info = dev_info)
|    |    |   > XendConfig.py:device_sxpr
|    |    |    898         sxpr = []
|    |    |    899         if dev_uuid != None and dev_uuid in self['device']:
|    |    |    902         if dev_type == None or dev_info == None:
|    |    |    906         sxpr.append(dev_type)
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    908         sxpr += config
|    |    |    910         return sxpr
|    |    |   < XendConfig.py:device_sxpr
|    |    |   922                 sxprs.append((dev_type, sxpr))
|    |    |   916         for dev_type, dev_info in self['device'].values():
|    |    |   926         if pci_devs:
|    |    |   934         return sxprs
|    |    |  < XendConfig.py:all_devices_sxpr
|    |    |  749                         if dev_type == cls:
|    |    |  748                     for dev_type, dev_info in 
self.all_devices_sxpr():
|    |    |  730             for cls in XendDevices.valid_devices():
|    |    |  752         return sxpr
|    |    | < XendConfig.py:get_sxp
|    |    |1666         if not ignore_store:
|    |    |1667             vnc_port = self._readDom('console/vnc-port')
|    |    | > XendDomainInfo.py:_readDom
|    |    |  663         return xstransact.Read(self.dompath, *args)
|    |    |  > xenstore/xstransact.py:Read
|    |    |   297         return complete(path, lambda t: t.read(*args))
|    |    |   > xenstore/xstransact.py:complete
|    |    |    350     while True:
|    |    |    351         t = xstransact(path)
|    |    |    > xenstore/xstransact.py:__init__
|    |    |      14         assert path is not None
|    |    |      16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |      19         self.path = path.rstrip("/")
|    |    |      20         self.transaction = xshandle().transaction_start()
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |      21         self.in_transaction = True
|    |    |    < xenstore/xstransact.py:__init__
|    |    |    352         try:
|    |    |    353             result = f(t)
|    |    |    > xenstore/xstransact.py:<lambda>
|    |    |     297         return complete(path, lambda t: t.read(*args))
|    |    |    |> xenstore/xstransact.py:read
|    |    |    |  59         if len(args) == 0:
|    |    |    |  61         if len(args) == 1:
|    |    |    |  62             return self._read(args[0])
|    |    |    | > xenstore/xstransact.py:_read
|    |    |    |   44         path = self.prependPath(key)
|    |    |    |  > xenstore/xstransact.py:prependPath
|    |    |    |   283         if self.path:
|    |    |    |   284             return self.path + '/' + key
|    |    |    |  < xenstore/xstransact.py:prependPath
|    |    |    |   45         try:
|    |    |    |   46             return xshandle().read(self.transaction, path)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:_read
|    |    |    |< xenstore/xstransact.py:read
|    |    |    < xenstore/xstransact.py:<lambda>
|    |    |    354             if t.commit():
|    |    |    > xenstore/xstransact.py:commit
|    |    |      28         if not self.in_transaction:
|    |    |      30         self.in_transaction = False
|    |    |      31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |      32         self.transaction = "0"
|    |    |      33         return rc
|    |    |    < xenstore/xstransact.py:commit
|    |    |    355                 return result
|    |    |   < xenstore/xstransact.py:complete
|    |    |   > xenstore/xstransact.py:__del__
|    |    |     24         if self.in_transaction:
|    |    |   < xenstore/xstransact.py:__del__
|    |    |  < xenstore/xstransact.py:Read
|    |    | < XendDomainInfo.py:_readDom
|    |    |1668             if vnc_port is not None:
|    |    |1672         return result
|    |    |< XendDomainInfo.py:sxpr
|    |     987         if self._infoIsSet('cpus') and len(self.info['cpus']) != 
0:
|    |    |> XendDomainInfo.py:_infoIsSet
|    |    |1604         return name in self.info and self.info[name] is not None
|    |    |< XendDomainInfo.py:_infoIsSet
|    |     991         if self._readVm(RESTART_IN_PROGRESS):
|    |    |> XendDomainInfo.py:_readVm
|    |    | 644         return xstransact.Read(self.vmpath, *args)
|    |    | > xenstore/xstransact.py:Read
|    |    |  297         return complete(path, lambda t: t.read(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    297         return complete(path, lambda t: t.read(*args))
|    |    |    > xenstore/xstransact.py:read
|    |    |      59         if len(args) == 0:
|    |    |      61         if len(args) == 1:
|    |    |      62             return self._read(args[0])
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |    < xenstore/xstransact.py:read
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:Read
|    |    |< XendDomainInfo.py:_readVm
|    |     998         old_domid = self.domid
|    |     999         self._writeVm(RESTART_IN_PROGRESS, 'True')
|    |    |> XendDomainInfo.py:_writeVm
|    |    | 647         return xstransact.Write(self.vmpath, *args)
|    |    | > xenstore/xstransact.py:Write
|    |    |  301         complete(path, lambda t: t.write(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    301         complete(path, lambda t: t.write(*args))
|    |    |    > xenstore/xstransact.py:write
|    |    |      78         if len(args) == 0:
|    |    |      80         if isinstance(args[0], dict):
|    |    |      90         elif isinstance(args[0], list):
|    |    |      95         elif len(args) % 2 == 0:
|    |    |      96             for i in range(len(args) / 2):
|    |    |      97                 self._write(args[i * 2], args[i * 2 + 1])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      96             for i in range(len(args) / 2):
|    |    |    < xenstore/xstransact.py:write
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:Write
|    |    |< XendDomainInfo.py:_writeVm
|    |    1001         now = time.time()
|    |    1002         rst = self._readVm('xend/previous_restart_time')
|    |    |> XendDomainInfo.py:_readVm
|    |    | 644         return xstransact.Read(self.vmpath, *args)
|    |    | > xenstore/xstransact.py:Read
|    |    |  297         return complete(path, lambda t: t.read(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    297         return complete(path, lambda t: t.read(*args))
|    |    |    > xenstore/xstransact.py:read
|    |    |      59         if len(args) == 0:
|    |    |      61         if len(args) == 1:
|    |    |      62             return self._read(args[0])
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |    < xenstore/xstransact.py:read
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:Read
|    |    |< XendDomainInfo.py:_readVm
|    |    1003         if rst:
|    |    1014         self._writeVm('xend/previous_restart_time', str(now))
|    |    |> XendDomainInfo.py:_writeVm
|    |    | 647         return xstransact.Write(self.vmpath, *args)
|    |    | > xenstore/xstransact.py:Write
|    |    |  301         complete(path, lambda t: t.write(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    301         complete(path, lambda t: t.write(*args))
|    |    |    > xenstore/xstransact.py:write
|    |    |      78         if len(args) == 0:
|    |    |      80         if isinstance(args[0], dict):
|    |    |      90         elif isinstance(args[0], list):
|    |    |      95         elif len(args) % 2 == 0:
|    |    |      96             for i in range(len(args) / 2):
|    |    |      97                 self._write(args[i * 2], args[i * 2 + 1])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      96             for i in range(len(args) / 2):
|    |    |    < xenstore/xstransact.py:write
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:Write
|    |    |< XendDomainInfo.py:_writeVm
|    |    1016         try:
|    |    1017             if rename:
|    |    1020                 self._unwatchVm()
|    |    |> XendDomainInfo.py:_unwatchVm
|    |    |1523         guarantee."""
|    |    |< XendDomainInfo.py:_unwatchVm
|    |    1021                 self.destroyDomain()
|    |    |> XendDomainInfo.py:destroyDomain
|    |    |1417         log.debug("XendDomainInfo.destroyDomain(%s)", 
str(self.domid))
|    |    |1419         try:
|    |    |1420             if self.domid is not None:
|    |    |1421                 xc.domain_destroy(self.domid)
|    |    |1422                 self.domid = None
|    |    |1423                 for state in DOM_STATES_OLD:
|    |    |1424                     self.info[state] = 0
|    |    |1423                 for state in DOM_STATES_OLD:
|    |    |1424                     self.info[state] = 0
|    |    |1423                 for state in DOM_STATES_OLD:
|    |    |1424                     self.info[state] = 0
|    |    |1423                 for state in DOM_STATES_OLD:
|    |    |1424                     self.info[state] = 0
|    |    |1423                 for state in DOM_STATES_OLD:
|    |    |1424                     self.info[state] = 0
|    |    |1423                 for state in DOM_STATES_OLD:
|    |    |1424                     self.info[state] = 0
|    |    |1423                 for state in DOM_STATES_OLD:
|    |    |1428         self.cleanupDomain()
|    |    | > XendDomainInfo.py:cleanupDomain
|    |    | 1333         self.refresh_shutdown_lock.acquire()
|    |    | 1334         try:
|    |    | 1335             self.unwatchShutdown()
|    |    |  > XendDomainInfo.py:unwatchShutdown
|    |    |  1362         try:
|    |    |  1363             try:
|    |    |  1364                 if self.shutdownWatch:
|    |    |  1365                     self.shutdownWatch.unwatch()
|    |    |   > xenstore/xswatch.py:unwatch
|    |    |     38         xs.unwatch(self.path, self)
|    |    |   < xenstore/xswatch.py:unwatch
|    |    |  1367                 self.shutdownWatch = None
|    |    |  < XendDomainInfo.py:unwatchShutdown
|    |    | 1337             self._releaseDevices()
|    |    |  > XendDomainInfo.py:_releaseDevices
|    |    |  1129         while True:
|    |    |  1130             t = xstransact("%s/device" % self.dompath)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |  1131             for devclass in XendDevices.valid_devices():
|    |    |   > XendDevices.py:valid_devices
|    |    |     48         return cls.controllers.keys()
|    |    |   < XendDevices.py:valid_devices
|    |    |  1132                 for dev in t.list(devclass):
|    |    |   > xenstore/xstransact.py:list
|    |    |    129         if len(args) == 0:
|    |    |    136             ret = []
|    |    |    137             for key in args:
|    |    |    138                 ret.extend(self._list(key))
|    |    |    > xenstore/xstransact.py:_list
|    |    |     117         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 284             return self.path + '/' + key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     118         l = xshandle().ls(self.transaction, path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     119         if l:
|    |    |     121         return []
|    |    |    < xenstore/xstransact.py:_list
|    |    |    137             for key in args:
|    |    |    139             return ret
|    |    |   < xenstore/xstransact.py:list
|    |    |  1131             for devclass in XendDevices.valid_devices():
|    |    |  1132                 for dev in t.list(devclass):
|    |    |   > xenstore/xstransact.py:list
|    |    |    129         if len(args) == 0:
|    |    |    136             ret = []
|    |    |    137             for key in args:
|    |    |    138                 ret.extend(self._list(key))
|    |    |    > xenstore/xstransact.py:_list
|    |    |     117         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 284             return self.path + '/' + key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     118         l = xshandle().ls(self.transaction, path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     119         if l:
|    |    |     121         return []
|    |    |    < xenstore/xstransact.py:_list
|    |    |    137             for key in args:
|    |    |    139             return ret
|    |    |   < xenstore/xstransact.py:list
|    |    |  1131             for devclass in XendDevices.valid_devices():
|    |    |  1132                 for dev in t.list(devclass):
|    |    |   > xenstore/xstransact.py:list
|    |    |    129         if len(args) == 0:
|    |    |    136             ret = []
|    |    |    137             for key in args:
|    |    |    138                 ret.extend(self._list(key))
|    |    |    > xenstore/xstransact.py:_list
|    |    |     117         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 284             return self.path + '/' + key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     118         l = xshandle().ls(self.transaction, path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     119         if l:
|    |    |     120             return map(lambda x: key + "/" + x, l)
|    |    |    |> xenstore/xstransact.py:<lambda>
|    |    |    | 120             return map(lambda x: key + "/" + x, l)
|    |    |    |< xenstore/xstransact.py:<lambda>
|    |    |    < xenstore/xstransact.py:_list
|    |    |    137             for key in args:
|    |    |    139             return ret
|    |    |   < xenstore/xstransact.py:list
|    |    |  1133                     try:
|    |    |  1134                         t.remove(dev)
|    |    |   > xenstore/xstransact.py:remove
|    |    |    110         if len(args) == 0:
|    |    |    113             for key in args:
|    |    |    114                 self._remove(key)
|    |    |    > xenstore/xstransact.py:_remove
|    |    |     102         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 284             return self.path + '/' + key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     103         return xshandle().rm(self.transaction, path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    < xenstore/xstransact.py:_remove
|    |    |    113             for key in args:
|    |    |   < xenstore/xstransact.py:remove
|    |    |  1132                 for dev in t.list(devclass):
|    |    |  1131             for devclass in XendDevices.valid_devices():
|    |    |  1132                 for dev in t.list(devclass):
|    |    |   > xenstore/xstransact.py:list
|    |    |    129         if len(args) == 0:
|    |    |    136             ret = []
|    |    |    137             for key in args:
|    |    |    138                 ret.extend(self._list(key))
|    |    |    > xenstore/xstransact.py:_list
|    |    |     117         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 284             return self.path + '/' + key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     118         l = xshandle().ls(self.transaction, path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     119         if l:
|    |    |     121         return []
|    |    |    < xenstore/xstransact.py:_list
|    |    |    137             for key in args:
|    |    |    139             return ret
|    |    |   < xenstore/xstransact.py:list
|    |    |  1131             for devclass in XendDevices.valid_devices():
|    |    |  1132                 for dev in t.list(devclass):
|    |    |   > xenstore/xstransact.py:list
|    |    |    129         if len(args) == 0:
|    |    |    136             ret = []
|    |    |    137             for key in args:
|    |    |    138                 ret.extend(self._list(key))
|    |    |    > xenstore/xstransact.py:_list
|    |    |     117         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 284             return self.path + '/' + key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     118         l = xshandle().ls(self.transaction, path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     119         if l:
|    |    |     121         return []
|    |    |    < xenstore/xstransact.py:_list
|    |    |    137             for key in args:
|    |    |    139             return ret
|    |    |   < xenstore/xstransact.py:list
|    |    |  1131             for devclass in XendDevices.valid_devices():
|    |    |  1132                 for dev in t.list(devclass):
|    |    |   > xenstore/xstransact.py:list
|    |    |    129         if len(args) == 0:
|    |    |    136             ret = []
|    |    |    137             for key in args:
|    |    |    138                 ret.extend(self._list(key))
|    |    |    > xenstore/xstransact.py:_list
|    |    |     117         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 284             return self.path + '/' + key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     118         l = xshandle().ls(self.transaction, path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     119         if l:
|    |    |     121         return []
|    |    |    < xenstore/xstransact.py:_list
|    |    |    137             for key in args:
|    |    |    139             return ret
|    |    |   < xenstore/xstransact.py:list
|    |    |  1131             for devclass in XendDevices.valid_devices():
|    |    |  1132                 for dev in t.list(devclass):
|    |    |   > xenstore/xstransact.py:list
|    |    |    129         if len(args) == 0:
|    |    |    136             ret = []
|    |    |    137             for key in args:
|    |    |    138                 ret.extend(self._list(key))
|    |    |    > xenstore/xstransact.py:_list
|    |    |     117         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 284             return self.path + '/' + key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     118         l = xshandle().ls(self.transaction, path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     119         if l:
|    |    |     121         return []
|    |    |    < xenstore/xstransact.py:_list
|    |    |    137             for key in args:
|    |    |    139             return ret
|    |    |   < xenstore/xstransact.py:list
|    |    |  1131             for devclass in XendDevices.valid_devices():
|    |    |  1132                 for dev in t.list(devclass):
|    |    |   > xenstore/xstransact.py:list
|    |    |    129         if len(args) == 0:
|    |    |    136             ret = []
|    |    |    137             for key in args:
|    |    |    138                 ret.extend(self._list(key))
|    |    |    > xenstore/xstransact.py:_list
|    |    |     117         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    | 283         if self.path:
|    |    |    | 284             return self.path + '/' + key
|    |    |    |< xenstore/xstransact.py:prependPath
|    |    |     118         l = xshandle().ls(self.transaction, path)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     119         if l:
|    |    |     121         return []
|    |    |    < xenstore/xstransact.py:_list
|    |    |    137             for key in args:
|    |    |    139             return ret
|    |    |   < xenstore/xstransact.py:list
|    |    |  1131             for devclass in XendDevices.valid_devices():
|    |    |  1141             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |  1142                 break
|    |    |  < XendDomainInfo.py:_releaseDevices
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | 1339             if self.image:
|    |    | 1340                 try:
|    |    | 1341                     self.image.destroy()
|    |    |  > image.py:destroy
|    |    |   180         """Extra cleanup on domain destroy (define in 
subclass if needed)."""
|    |    |  < image.py:destroy
|    |    | 1345                 self.image = None
|    |    | 1347             try:
|    |    | 1348                 self._removeDom()
|    |    |  > XendDomainInfo.py:_removeDom
|    |    |   669         return xstransact.Remove(self.dompath, *args)
|    |    |   > xenstore/xstransact.py:Remove
|    |    |    309         complete(path, lambda t: t.remove(*args))
|    |    |    > xenstore/xstransact.py:complete
|    |    |     350     while True:
|    |    |     351         t = xstransact(path)
|    |    |    |> xenstore/xstransact.py:__init__
|    |    |    |  14         assert path is not None
|    |    |    |  16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |    |  19         self.path = path.rstrip("/")
|    |    |    |  20         self.transaction = xshandle().transaction_start()
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |  21         self.in_transaction = True
|    |    |    |< xenstore/xstransact.py:__init__
|    |    |     352         try:
|    |    |     353             result = f(t)
|    |    |    |> xenstore/xstransact.py:<lambda>
|    |    |    | 309         complete(path, lambda t: t.remove(*args))
|    |    |    | > xenstore/xstransact.py:remove
|    |    |    |  110         if len(args) == 0:
|    |    |    |  111             xshandle().rm(self.transaction, self.path)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    | < xenstore/xstransact.py:remove
|    |    |    |< xenstore/xstransact.py:<lambda>
|    |    |     354             if t.commit():
|    |    |    |> xenstore/xstransact.py:commit
|    |    |    |  28         if not self.in_transaction:
|    |    |    |  30         self.in_transaction = False
|    |    |    |  31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |  32         self.transaction = "0"
|    |    |    |  33         return rc
|    |    |    |< xenstore/xstransact.py:commit
|    |    |     355                 return result
|    |    |    < xenstore/xstransact.py:complete
|    |    |    > xenstore/xstransact.py:__del__
|    |    |      24         if self.in_transaction:
|    |    |    < xenstore/xstransact.py:__del__
|    |    |   < xenstore/xstransact.py:Remove
|    |    |  < XendDomainInfo.py:_removeDom
|    |    | 1352             self._stateSet(DOM_STATE_HALTED)
|    |    |  > XendDomainInfo.py:_stateSet
|    |    |  1595         self.state_updated.acquire()
|    |    |  1596         try:
|    |    |  1597             if self.state != state:
|    |    |  1598                 self.state = state
|    |    |  1599                 self.state_updated.notifyAll()
|    |    |  1601             self.state_updated.release()
|    |    |  < XendDomainInfo.py:_stateSet
|    |    | 1354             self.refresh_shutdown_lock.release()
|    |    | < XendDomainInfo.py:cleanupDomain
|    |    |< XendDomainInfo.py:destroyDomain
|    |    1029             new_dom = None
|    |    1030             try:
|    |    1031                 new_dom = 
XendDomain.instance().domain_create(config)
|    |    |> XendDomain.py:instance
|    |    |1333     try:
|    |    |1334         inst
|    |    |1338     return inst
|    |    |< XendDomain.py:instance
|    |    |> XendDomain.py:domain_create
|    |    | 798         self.domains_lock.acquire()
|    |    | 799         try:
|    |    | 800             self._refresh()
|    |    | > XendDomain.py:_refresh
|    |    |  379         running = self._running_domains()
|    |    |  > XendDomain.py:_running_domains
|    |    |   343         try:
|    |    |   344             return xc.domain_getinfo()
|    |    |  < XendDomain.py:_running_domains
|    |    |  380         for dom in running:
|    |    |  381             domid = dom['domid']
|    |    |  382             if domid in self.domains and dom['dying'] != 1:
|    |    |  383                 self.domains[domid].update(dom)
|    |    |  > XendDomainInfo.py:update
|    |    |  1630         log.trace("XendDomainInfo.update(%s) on domain %s", 
info,
|    |    |  1631                   str(self.domid))
|    |    |   > XendLogging.py:trace
|    |    |     36         self.log(logging.TRACE, *args, **kwargs)
|    |    |   < XendLogging.py:trace
|    |    |  1633         if not info:
|    |    |  1639         if security.on() and info.has_key('ssidref'):
|    |    |  1647         if 'ssidref' in info:
|    |    |  1648             info.pop('ssidref')
|    |    |  1653         self.info.update(info)
|    |    |  1654         self.info.validate()
|    |    |   > XendConfig.py:validate
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    762                 self[key] = default_func(self)
|    |    |    > XendConfig.py:<lambda>
|    |    |     202     ('bootloader',   lambda info: None),
|    |    |    < XendConfig.py:<lambda>
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    762                 self[key] = default_func(self)
|    |    |    > XendConfig.py:<lambda>
|    |    |     203     ('bootloader_args', lambda info: None),            
|    |    |    < XendConfig.py:<lambda>
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    762                 self[key] = default_func(self)
|    |    |    > XendConfig.py:<lambda>
|    |    |     206     ('image',        lambda info: None),
|    |    |    < XendConfig.py:<lambda>
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    765         if 'image' in self and isinstance(self['image'], 
str):
|    |    |    767         if 'security' in self and 
isinstance(self['security'], str):
|    |    |    769         if self['memory'] == 0 and 'mem_kb' in self:
|    |    |    771         if self['memory'] <= 0:
|    |    |    775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |    |    778         if 'mem_kb' in self:
|    |    |    779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |    |    782         for d_uuid, (d_type, d_info) in 
self['device'].items():
|    |    |    787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    |    787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    |    787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    |    787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |    793         if 'vif_refs' not in self:
|    |    |    795         if 'vbd_refs' not in self:
|    |    |    797         if 'vtpm_refs' not in self:
|    |    |   < XendConfig.py:validate
|    |    |  1656         if refresh:
|    |    |  1657             self.refreshShutdown(info)
|    |    |   > XendDomainInfo.py:refreshShutdown
|    |    |    856         restart_reason = None
|    |    |    858         self.refresh_shutdown_lock.acquire()
|    |    |    859         try:
|    |    |    860             if xeninfo is None:
|    |    |    874             if xeninfo['dying']:
|    |    |    886             elif xeninfo['crashed']:
|    |    |    901             elif xeninfo['shutdown']:
|    |    |    928             elif self.dompath is None:
|    |    |    936                 if xeninfo['paused']:
|    |    |    939                     self._stateSet(DOM_STATE_RUNNING)
|    |    |    > XendDomainInfo.py:_stateSet
|    |    |    1595         self.state_updated.acquire()
|    |    |    1596         try:
|    |    |    1597             if self.state != state:
|    |    |    1601             self.state_updated.release()
|    |    |    < XendDomainInfo.py:_stateSet
|    |    |    941                 if self.shutdownStartTime:
|    |    |    950             self.refresh_shutdown_lock.release()
|    |    |    952         if restart_reason:
|    |    |   < XendDomainInfo.py:refreshShutdown
|    |    |  1659         log.trace("XendDomainInfo.update done on domain %s: 
%s",
|    |    |  1660                   str(self.domid), self.info)
|    |    |   > XendLogging.py:trace
|    |    |     36         self.log(logging.TRACE, *args, **kwargs)
|    |    |   < XendLogging.py:trace
|    |    |  < XendDomainInfo.py:update
|    |    |  380         for dom in running:
|    |    |  389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |    |  389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
|    |    |  390         for domid, dom in self.domains.items():
|    |    |  391             if domid not in running_domids and domid != 
DOM0_ID:
|    |    |  390         for domid, dom in self.domains.items():
|    |    |  391             if domid not in running_domids and domid != 
DOM0_ID:
|    |    |  392                 self._remove_domain(dom, domid)
|    |    |  > XendDomain.py:_remove_domain
|    |    |   413         if info:
|    |    |   414             if domid == None:
|    |    |   417             if info.state != DOM_STATE_HALTED:
|    |    |   420             if domid in self.domains:
|    |    |   421                 del self.domains[domid]
|    |    |  < XendDomain.py:_remove_domain
|    |    |  390         for domid, dom in self.domains.items():
|    |    | < XendDomain.py:_refresh
|    |    | 802             dominfo = XendDomainInfo.create(config)
|    |    | > XendDomainInfo.py:create
|    |    |  147     log.debug("XendDomainInfo.create(%s)", config)
|    |    |  148     vm = XendDomainInfo(XendConfig(sxp = config))
|    |    |  > XendConfig.py:__init__
|    |    |   265         format = 'unknown'
|    |    |   267         self.xenapi = {}
|    |    |   > XendConfig.py:__setattr__
|    |    |    322         try:
|    |    |    323             return dict.__setattr__(self, name, value)
|    |    |   < XendConfig.py:__setattr__
|    |    |   269         if filename and not fd:
|    |    |   272         if fd:
|    |    |   275         if fd:
|    |    |   288         if sxp:
|    |    |   289             cfg = self._populate_from_sxp(sxp)
|    |    |   > XendConfig.py:_populate_from_sxp
|    |    |    414         cfg = {}
|    |    |    419         restart = sxp.child_value(parsed, 'restart')
|    |    |    420         if restart:
|    |    |    436         all_params = VM_CONFIG_ENTRIES + 
ROUNDTRIPPING_CONFIG_ENTRIES + \
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    442                 try:
|    |    |    443                     cfg[key] = typeconv(val)
|    |    |    439         for key, typeconv in all_params:
|    |    |    440             val = sxp.child_value(parsed, key)
|    |    |    441             if val:
|    |    |    439         for key, typeconv in all_params:
|    |    |    450         cfg['backend'] = []
|    |    |    451         for c in sxp.children(parsed, 'backend'):
|    |    |    475         cfg['device'] = {}
|    |    |    476         for dev in sxp.children(parsed, 'device'):
|    |    |    477             config = sxp.child0(dev)
|    |    |    478             dev_type = sxp.name(config)
|    |    |    479             dev_info = {}
|    |    |    481             if dev_type == 'pci':
|    |    |    484             for opt, val in config[1:]:
|    |    |    485                 dev_info[opt] = val
|    |    |    484             for opt, val in config[1:]:
|    |    |    485                 dev_info[opt] = val
|    |    |    484             for opt, val in config[1:]:
|    |    |    485                 dev_info[opt] = val
|    |    |    484             for opt, val in config[1:]:
|    |    |    485                 dev_info[opt] = val
|    |    |    484             for opt, val in config[1:]:
|    |    |    485                 dev_info[opt] = val
|    |    |    484             for opt, val in config[1:]:
|    |    |    486             log.debug("XendConfig: reading device: %s" % 
dev_info)
|    |    |    488             dev_uuid = dev_info.get('uuid', 
uuid.createString())
|    |    |    > uuid.py:createString
|    |    |      69     return toString(create())
|    |    |    |> uuid.py:create
|    |    |    |  66     return uuidFactory()
|    |    |    | > uuid.py:getUuidRandom
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    |   50     return [ random.randint(0, 255) for _ in range(0, 16) 
]
|    |    |    | < uuid.py:getUuidRandom
|    |    |    |< uuid.py:create
|    |    |    |> uuid.py:toString
|    |    |    |  58     return "-".join(["%02x" * 4, "%02x" * 2, "%02x" * 2, 
"%02x" * 2,
|    |    |    |< uuid.py:toString
|    |    |    < uuid.py:createString
|    |    |    489             dev_info['uuid'] = dev_uuid
|    |    |    490             cfg['device'][dev_uuid] = (dev_type, dev_info)
|    |    |    476         for dev in sxp.children(parsed, 'device'):
|    |    |    493         for dev in sxp.children(parsed, 'device'):
|    |    |    494             config = sxp.child0(dev)
|    |    |    495             dev_type = sxp.name(config)
|    |    |    497             if dev_type != 'pci':
|    |    |    498                 continue
|    |    |    493         for dev in sxp.children(parsed, 'device'):
|    |    |    521         if 'image' in cfg:
|    |    |    522             image_vcpus = sxp.child_value(cfg['image'], 
'vcpus')
|    |    |    523             if image_vcpus is not None:
|    |    |    536         if 'cpu' in cfg:
|    |    |    548         try:
|    |    |    549             if 'cpus' in cfg:
|    |    |    569         if 'image' in cfg:
|    |    |    570             cfg['kernel_kernel'] = 
sxp.child_value(cfg['image'], 'kernel','')
|    |    |    571             cfg['kernel_initrd'] = 
sxp.child_value(cfg['image'], 'ramdisk','')
|    |    |    572             kernel_args = sxp.child_value(cfg['image'], 
'args', '')
|    |    |    575             arg_ip = sxp.child_value(cfg['image'], 'ip')
|    |    |    576             if arg_ip: kernel_args += ' ip=%s' % arg_ip
|    |    |    577             arg_root = sxp.child_value(cfg['image'], 'root')
|    |    |    578             if arg_root: kernel_args += ' root=%s' % arg_root
|    |    |    580             cfg['kernel_args'] = kernel_args
|    |    |    583         old_state = sxp.child_value(parsed, 'state')
|    |    |    584         if old_state:
|    |    |    585             for i in range(len(CONFIG_OLD_DOM_STATES)):
|    |    |    586                 cfg[CONFIG_OLD_DOM_STATES[i]] = 
(old_state[i] != '-')
|    |    |    585             for i in range(len(CONFIG_OLD_DOM_STATES)):
|    |    |    586                 cfg[CONFIG_OLD_DOM_STATES[i]] = 
(old_state[i] != '-')
|    |    |    585             for i in range(len(CONFIG_OLD_DOM_STATES)):
|    |    |    586                 cfg[CONFIG_OLD_DOM_STATES[i]] = 
(old_state[i] != '-')
|    |    |    585             for i in range(len(CONFIG_OLD_DOM_STATES)):
|    |    |    586                 cfg[CONFIG_OLD_DOM_STATES[i]] = 
(old_state[i] != '-')
|    |    |    585             for i in range(len(CONFIG_OLD_DOM_STATES)):
|    |    |    586                 cfg[CONFIG_OLD_DOM_STATES[i]] = 
(old_state[i] != '-')
|    |    |    585             for i in range(len(CONFIG_OLD_DOM_STATES)):
|    |    |    586                 cfg[CONFIG_OLD_DOM_STATES[i]] = 
(old_state[i] != '-')
|    |    |    585             for i in range(len(CONFIG_OLD_DOM_STATES)):
|    |    |    590         cfg['vif_refs'] = []
|    |    |    591         cfg['vbd_refs'] = []
|    |    |    592         cfg['vtpm_refs'] = []
|    |    |    593         for dev_uuid, (dev_type, dev_info) in 
cfg['device'].items():
|    |    |    594             if dev_type == 'vif':
|    |    |    596             elif dev_type in ('vbd','tap'):
|    |    |    597                 cfg['vbd_refs'].append(dev_uuid)
|    |    |    593         for dev_uuid, (dev_type, dev_info) in 
cfg['device'].items():
|    |    |    601         return cfg
|    |    |   < XendConfig.py:_populate_from_sxp
|    |    |   290         if xml:
|    |    |   292         if pycfg:
|    |    |   294         if xenapi_vm:
|    |    |   297         if cfg:
|    |    |   298             self.update(cfg)
|    |    |   300         if xenapi_vm:
|    |    |   303         log.debug('XendConfig: %s' % str(self))
|    |    |   304         self.validate()
|    |    |   > XendConfig.py:validate
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    762                 self[key] = default_func(self)
|    |    |    > XendConfig.py:<lambda>
|    |    |     196     ('features',     lambda info: ''),
|    |    |    < XendConfig.py:<lambda>
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    762                 self[key] = default_func(self)
|    |    |    > XendConfig.py:<lambda>
|    |    |     200     ('shadow_memory',lambda info: 0),
|    |    |    < XendConfig.py:<lambda>
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    762                 self[key] = default_func(self)
|    |    |    > XendConfig.py:<lambda>
|    |    |     202     ('bootloader',   lambda info: None),
|    |    |    < XendConfig.py:<lambda>
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    762                 self[key] = default_func(self)
|    |    |    > XendConfig.py:<lambda>
|    |    |     203     ('bootloader_args', lambda info: None),            
|    |    |    < XendConfig.py:<lambda>
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    762                 self[key] = default_func(self)
|    |    |    > XendConfig.py:<lambda>
|    |    |     207     ('security',     lambda info: []),
|    |    |    < XendConfig.py:<lambda>
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    762                 self[key] = default_func(self)
|    |    |    > XendConfig.py:<lambda>
|    |    |     211     ('cpus',         lambda info: []),
|    |    |    < XendConfig.py:<lambda>
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    762                 self[key] = default_func(self)
|    |    |    > XendConfig.py:<lambda>
|    |    |     212     ('cpu_cap',      lambda info: 0),
|    |    |    < XendConfig.py:<lambda>
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    762                 self[key] = default_func(self)
|    |    |    > XendConfig.py:<lambda>
|    |    |     215     ('online_vcpus', lambda info: info['vcpus']),
|    |    |    < XendConfig.py:<lambda>
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    762                 self[key] = default_func(self)
|    |    |    > XendConfig.py:<lambda>
|    |    |     216     ('max_vcpu_id',  lambda info: info['vcpus']-1),
|    |    |    < XendConfig.py:<lambda>
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    761             if key not in self or self[key] == None:
|    |    |    760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    765         if 'image' in self and isinstance(self['image'], 
str):
|    |    |    767         if 'security' in self and 
isinstance(self['security'], str):
|    |    |    769         if self['memory'] == 0 and 'mem_kb' in self:
|    |    |    771         if self['memory'] <= 0:
|    |    |    775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |    |    778         if 'mem_kb' in self:
|    |    |    782         for d_uuid, (d_type, d_info) in 
self['device'].items():
|    |    |    783             if d_type not in XendDevices.valid_devices():
|    |    |    > XendDevices.py:valid_devices
|    |    |      48         return cls.controllers.keys()
|    |    |    < XendDevices.py:valid_devices
|    |    |    782         for d_uuid, (d_type, d_info) in 
self['device'].items():
|    |    |    787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    |    787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    |    787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |    788             if self[event] not in CONFIG_RESTART_MODES:
|    |    |    787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
|    |    |    793         if 'vif_refs' not in self:
|    |    |    795         if 'vbd_refs' not in self:
|    |    |    797         if 'vtpm_refs' not in self:
|    |    |   < XendConfig.py:validate
|    |    |  < XendConfig.py:__init__
|    |    |  > XendDomainInfo.py:__init__
|    |    |   376         self.info = info
|    |    |   377         if domid == None:
|    |    |   378             self.domid =  self.info.get('domid')
|    |    |   394         self.vmpath  = XS_VMROOT + self.info['uuid']
|    |    |   395         self.dompath = dompath
|    |    |   397         self.image = None
|    |    |   398         self.store_port = None
|    |    |   399         self.store_mfn = None
|    |    |   400         self.console_port = None
|    |    |   401         self.console_mfn = None
|    |    |   403         self.vmWatch = None
|    |    |   404         self.shutdownWatch = None
|    |    |   405         self.shutdownStartTime = None
|    |    |   407         self.state = DOM_STATE_HALTED
|    |    |   408         self.state_updated = threading.Condition()
|    |    |   409         self.refresh_shutdown_lock = threading.Condition()
|    |    |   411         self._deviceControllers = {}
|    |    |   413         for state in DOM_STATES_OLD:
|    |    |   414             self.info[state] = 0
|    |    |   413         for state in DOM_STATES_OLD:
|    |    |   414             self.info[state] = 0
|    |    |   413         for state in DOM_STATES_OLD:
|    |    |   414             self.info[state] = 0
|    |    |   413         for state in DOM_STATES_OLD:
|    |    |   414             self.info[state] = 0
|    |    |   413         for state in DOM_STATES_OLD:
|    |    |   414             self.info[state] = 0
|    |    |   413         for state in DOM_STATES_OLD:
|    |    |   414             self.info[state] = 0
|    |    |   413         for state in DOM_STATES_OLD:
|    |    |   416         if augment:
|    |    |   419         self._checkName(self.info['name'])
|    |    |   > XendDomainInfo.py:_checkName
|    |    |   1614         from xen.xend import XendDomain
|    |    |   1616         if name is None or name == '':
|    |    |   1619         if not re.search(r'^[A-Za-z0-9_\-\.\:\/\+]+$', name):
|    |    |   1622         dom =  XendDomain.instance().domain_lookup_nr(name)
|    |    |    > XendDomain.py:instance
|    |    |    1333     try:
|    |    |    1334         inst
|    |    |    1338     return inst
|    |    |    < XendDomain.py:instance
|    |    |    > XendDomain.py:domain_lookup_nr
|    |    |     485         self.domains_lock.acquire()
|    |    |     486         try:
|    |    |     488             match = [dom for dom in self.domains.values() \
|    |    |    |> XendDomainInfo.py:getName
|    |    |    | 797         return self.info['name']
|    |    |    |< XendDomainInfo.py:getName
|    |    |     488             match = [dom for dom in self.domains.values() \
|    |    |     490             if match:
|    |    |     493             match = [dom for dom in 
self.managed_domains.values() \
|    |    |     495             if match:
|    |    |     499             try:
|    |    |     500                 if int(domid) in self.domains:
|    |    |    ! Exception:
Traceback (most recent call last):
  File "//usr/lib/python/xen/xend/XendDomain.py", line 500, in domain_lookup_nr
    if int(domid) in self.domains:
ValueError: invalid literal for int(): fc5-1
|    |    |     502             except ValueError:
|    |    |     503                 pass
|    |    |     506             match = [dom for dom in self.domains.values() \
|    |    |    |> XendDomainInfo.py:get_uuid
|    |    |    |1678         dom_uuid = self.info.get('uuid')
|    |    |    |1679         if not dom_uuid: # if it doesn't exist, make one up
|    |    |    |1682         return dom_uuid
|    |    |    |< XendDomainInfo.py:get_uuid
|    |    |     506             match = [dom for dom in self.domains.values() \
|    |    |     508             if match:
|    |    |     512             if domid in self.managed_domains:
|    |    |     515             return None
|    |    |     517             self.domains_lock.release()
|    |    |    < XendDomain.py:domain_lookup_nr
|    |    |   1623         if dom and dom != self and not dom.info['dying']:
|    |    |   < XendDomainInfo.py:_checkName
|    |    |   420         self.setResume(resume)
|    |    |   > XendDomainInfo.py:setResume
|    |    |    842         self.info['resume'] = state
|    |    |   < XendDomainInfo.py:setResume
|    |    |  < XendDomainInfo.py:__init__
|    |    |  149     try:
|    |    |  150         vm.start()
|    |    |  > XendDomainInfo.py:start
|    |    |   432         from xen.xend import XendDomain
|    |    |   434         if self.state == DOM_STATE_HALTED:
|    |    |   435             try:
|    |    |   436                 self._constructDomain()
|    |    |   > XendDomainInfo.py:_constructDomain
|    |    |   1210         log.debug('XendDomainInfo.constructDomain')
|    |    |   1212         hvm = (self._infoIsSet('image') and
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1214         if hvm:
|    |    |   1221         self.domid = xc.domain_create(
|    |    |   1223             ssidref = security.get_security_info(self.info, 
'ssidref'),
|    |    |   1224             handle = uuid.fromString(self.info['uuid']),
|    |    |    > uuid.py:fromString
|    |    |      62     s = s.replace('-', '')
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |      63     return [ int(s[i : i + 2], 16) for i in range(0, 32, 2) 
]
|    |    |    < uuid.py:fromString
|    |    |   1225             hvm = int(hvm))
|    |    |   1227         if self.domid < 0:
|    |    |   1231         self.dompath = GetDomainPath(self.domid)
|    |    |    > xenstore/xsutil.py:GetDomainPath
|    |    |      26     return xshandle().get_domain_path(domid)
|    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
|    |    |    |  20     return xs_handle
|    |    |    |< xenstore/xsutil.py:xshandle
|    |    |     153             while self.running:
|    |    |     154                 self.server.handle_request()
|    |    |    < xenstore/xsutil.py:GetDomainPath
|    |    |   1233         self._recreateDom()
|    |    |    > XendDomainInfo.py:_recreateDom
|    |    |     675         complete(self.dompath, lambda t: 
self._recreateDomFunc(t))
|    |    |    |> xenstore/xstransact.py:complete
|    |    |    | 350     while True:
|    |    |    | 351         t = xstransact(path)
|    |    |    | > xenstore/xstransact.py:__init__
|    |    |    |   14         assert path is not None
|    |    |    |   16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |   19         self.path = path.rstrip("/")
|    |    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   21         self.in_transaction = True
|    |    |    | < xenstore/xstransact.py:__init__
|    |    |    | 352         try:
|    |    |    | 353             result = f(t)
|    |    |    | > XendDomainInfo.py:<lambda>
|    |    |    |  675         complete(self.dompath, lambda t: 
self._recreateDomFunc(t))
|    |    |    |  > XendDomainInfo.py:_recreateDomFunc
|    |    |    |   678         t.remove()
|    |    |    |   > xenstore/xstransact.py:remove
|    |    |    |    110         if len(args) == 0:
|    |    |    |    111             xshandle().rm(self.transaction, self.path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xstransact.py:remove
|    |    |    |   679         t.mkdir()
|    |    |    |   > xenstore/xstransact.py:mkdir
|    |    |    |    217         if len(args) == 0:
|    |    |    |    218             xshandle().mkdir(self.transaction, 
self.path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xstransact.py:mkdir
|    |    |    |   680         t.set_permissions({ 'dom' : self.domid })
|    |    |    |   > xenstore/xstransact.py:set_permissions
|    |    |    |    253         if len(args) == 0:
|    |    |    |    255         elif isinstance(args[0], str):
|    |    |    |    258             if not self.path:
|    |    |    |    261             
xshandle().set_permissions(self.transaction, self.path,
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |    262                                        list(args))
|    |    |    |   < xenstore/xstransact.py:set_permissions
|    |    |    |   681         t.write('vm', self.vmpath)
|    |    |    |   > xenstore/xstransact.py:write
|    |    |    |     78         if len(args) == 0:
|    |    |    |     80         if isinstance(args[0], dict):
|    |    |    |     90         elif isinstance(args[0], list):
|    |    |    |     95         elif len(args) % 2 == 0:
|    |    |    |     96             for i in range(len(args) / 2):
|    |    |    |     97                 self._write(args[i * 2], args[i * 2 + 
1])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     96             for i in range(len(args) / 2):
|    |    |    |   < xenstore/xstransact.py:write
|    |    |    |  < XendDomainInfo.py:_recreateDomFunc
|    |    |    | < XendDomainInfo.py:<lambda>
|    |    |    | 354             if t.commit():
|    |    |    | > xenstore/xstransact.py:commit
|    |    |    |   28         if not self.in_transaction:
|    |    |    |   30         self.in_transaction = False
|    |    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    |  > xenstore/xsutil.py:xshandle
|    |    |    |    15     if not xs_handle:
|    |    |    |    20     return xs_handle
|    |    |    |  < xenstore/xsutil.py:xshandle
|    |    |    |   32         self.transaction = "0"
|    |    |    |   33         return rc
|    |    |    | < xenstore/xstransact.py:commit
|    |    |    | 355                 return result
|    |    |    |< xenstore/xstransact.py:complete
|    |    |    |> xenstore/xstransact.py:__del__
|    |    |    |  24         if self.in_transaction:
|    |    |    |< xenstore/xstransact.py:__del__
|    |    |    < XendDomainInfo.py:_recreateDom
|    |    |   1236         xc.domain_max_vcpus(self.domid, 
int(self.info['vcpus']))
|    |    |   < XendDomainInfo.py:_constructDomain
|    |    |   437                 self._initDomain()
|    |    |   > XendDomainInfo.py:_initDomain
|    |    |   1251         log.debug('XendDomainInfo.initDomain: %s %s',
|    |    |   1252                   self.domid,
|    |    |   1253                   self.info['cpu_weight'])
|    |    |   1257         if self._infoIsSet('bootloader') and not 
self._infoIsSet('image'):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1260         if not self._infoIsSet('image'):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1263         try:
|    |    |   1264             self.image = image.create(self,
|    |    |   1265                                       self.info['image'],
|    |    |   1266                                       
self.info.all_devices_sxpr())
|    |    |    > XendConfig.py:all_devices_sxpr
|    |    |     914         sxprs = []
|    |    |     915         pci_devs = []
|    |    |     916         for dev_type, dev_info in self['device'].values():
|    |    |     917             if dev_type == 'pci': # special case for pci 
devices
|    |    |     920                 sxpr =  self.device_sxpr(dev_type = 
dev_type,
|    |    |     921                                          dev_info = 
dev_info)
|    |    |    |> XendConfig.py:device_sxpr
|    |    |    | 898         sxpr = []
|    |    |    | 899         if dev_uuid != None and dev_uuid in self['device']:
|    |    |    | 902         if dev_type == None or dev_info == None:
|    |    |    | 906         sxpr.append(dev_type)
|    |    |    | 907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    | 907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    | 907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    | 907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    | 907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    | 907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    | 908         sxpr += config
|    |    |    | 910         return sxpr
|    |    |    |< XendConfig.py:device_sxpr
|    |    |     922                 sxprs.append((dev_type, sxpr))
|    |    |     916         for dev_type, dev_info in self['device'].values():
|    |    |     926         if pci_devs:
|    |    |     934         return sxprs
|    |    |    < XendConfig.py:all_devices_sxpr
|    |    |    > image.py:create
|    |    |      46     return findImageHandlerClass(imageConfig)(vm, 
imageConfig, deviceConfig)
|    |    |    |> image.py:findImageHandlerClass
|    |    |    | 531     type = sxp.name(image)
|    |    |    | 532     if type is None:
|    |    |    | 534     try:
|    |    |    | 535         return _handlers[arch.type][type]
|    |    |    |< image.py:findImageHandlerClass
|    |    |    |> image.py:__init__
|    |    |    |  70         self.vm = vm
|    |    |    |  72         self.kernel = None
|    |    |    |  73         self.ramdisk = None
|    |    |    |  74         self.cmdline = None
|    |    |    |  76         self.configure(imageConfig, deviceConfig)
|    |    |    | > image.py:configure
|    |    |    |   81         def get_cfg(name, default = None):
|    |    |    |   84         self.kernel = get_cfg("kernel")
|    |    |    |  > image.py:get_cfg
|    |    |    |    82             return sxp.child_value(imageConfig, name, 
default)
|    |    |    |  < image.py:get_cfg
|    |    |    |   85         self.cmdline = ""
|    |    |    |   86         ip = get_cfg("ip")
|    |    |    |  > image.py:get_cfg
|    |    |    |    82             return sxp.child_value(imageConfig, name, 
default)
|    |    |    |  < image.py:get_cfg
|    |    |    |   87         if ip:
|    |    |    |   89         root = get_cfg("root")
|    |    |    |  > image.py:get_cfg
|    |    |    |    82             return sxp.child_value(imageConfig, name, 
default)
|    |    |    |  < image.py:get_cfg
|    |    |    |   90         if root:
|    |    |    |   91             self.cmdline += " root=" + root
|    |    |    |   92         args = get_cfg("args")
|    |    |    |  > image.py:get_cfg
|    |    |    |    82             return sxp.child_value(imageConfig, name, 
default)
|    |    |    |  < image.py:get_cfg
|    |    |    |   93         if args:
|    |    |    |   95         self.ramdisk = get_cfg("ramdisk", '')
|    |    |    |  > image.py:get_cfg
|    |    |    |    82             return sxp.child_value(imageConfig, name, 
default)
|    |    |    |  < image.py:get_cfg
|    |    |    |   97         self.vm.storeVm(("image/ostype", self.ostype),
|    |    |    |   98                         ("image/kernel", self.kernel),
|    |    |    |   99                         ("image/cmdline", self.cmdline),
|    |    |    |  100                         ("image/ramdisk", self.ramdisk))
|    |    |    |  > XendDomainInfo.py:storeVm
|    |    |    |   656         return xstransact.Store(self.vmpath, *args)
|    |    |    |   > xenstore/xstransact.py:Store
|    |    |    |    337         complete(path, lambda t: t.store(*args))
|    |    |    |    > xenstore/xstransact.py:complete
|    |    |    |     350     while True:
|    |    |    |     351         t = xstransact(path)
|    |    |    |    |> xenstore/xstransact.py:__init__
|    |    |    |    |  14         assert path is not None
|    |    |    |    |  16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    |  19         self.path = path.rstrip("/")
|    |    |    |    |  20         self.transaction = 
xshandle().transaction_start()
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |  21         self.in_transaction = True
|    |    |    |    |< xenstore/xstransact.py:__init__
|    |    |    |     352         try:
|    |    |    |     353             result = f(t)
|    |    |    |    |> xenstore/xstransact.py:<lambda>
|    |    |    |    | 337         complete(path, lambda t: t.store(*args))
|    |    |    |    | > xenstore/xstransact.py:store
|    |    |    |    |  195         if len(args) and type(args[0]) != tuple:
|    |    |    |    |  197         for tup in args:
|    |    |    |    |  198             if len(tup) == 2:
|    |    |    |    |  199                 (key, val) = tup
|    |    |    |    |  200                 try:
|    |    |    |    |  201                     fmt = { str        : "%s",
|    |    |    |    |  210             if val is None:
|    |    |    |    |  213                 self._write(key, fmt % val)
|    |    |    |    |  > xenstore/xstransact.py:_write
|    |    |    |    |    69         path = self.prependPath(key)
|    |    |    |    |   > xenstore/xstransact.py:prependPath
|    |    |    |    |    283         if self.path:
|    |    |    |    |    284             return self.path + '/' + key
|    |    |    |    |   < xenstore/xstransact.py:prependPath
|    |    |    |    |    70         try:
|    |    |    |    |    71             xshandle().write(self.transaction, 
path, data)
|    |    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |    |     15     if not xs_handle:
|    |    |    |    |     20     return xs_handle
|    |    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    |  < xenstore/xstransact.py:_write
|    |    |    |    |  197         for tup in args:
|    |    |    |    |  198             if len(tup) == 2:
|    |    |    |    |  199                 (key, val) = tup
|    |    |    |    |  200                 try:
|    |    |    |    |  201                     fmt = { str        : "%s",
|    |    |    |    |  210             if val is None:
|    |    |    |    |  213                 self._write(key, fmt % val)
|    |    |    |    |  > xenstore/xstransact.py:_write
|    |    |    |    |    69         path = self.prependPath(key)
|    |    |    |    |   > xenstore/xstransact.py:prependPath
|    |    |    |    |    283         if self.path:
|    |    |    |    |    284             return self.path + '/' + key
|    |    |    |    |   < xenstore/xstransact.py:prependPath
|    |    |    |    |    70         try:
|    |    |    |    |    71             xshandle().write(self.transaction, 
path, data)
|    |    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |    |     15     if not xs_handle:
|    |    |    |    |     20     return xs_handle
|    |    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    |  < xenstore/xstransact.py:_write
|    |    |    |    |  197         for tup in args:
|    |    |    |    |  198             if len(tup) == 2:
|    |    |    |    |  199                 (key, val) = tup
|    |    |    |    |  200                 try:
|    |    |    |    |  201                     fmt = { str        : "%s",
|    |    |    |    |  210             if val is None:
|    |    |    |    |  213                 self._write(key, fmt % val)
|    |    |    |    |  > xenstore/xstransact.py:_write
|    |    |    |    |    69         path = self.prependPath(key)
|    |    |    |    |   > xenstore/xstransact.py:prependPath
|    |    |    |    |    283         if self.path:
|    |    |    |    |    284             return self.path + '/' + key
|    |    |    |    |   < xenstore/xstransact.py:prependPath
|    |    |    |    |    70         try:
|    |    |    |    |    71             xshandle().write(self.transaction, 
path, data)
|    |    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |    |     15     if not xs_handle:
|    |    |    |    |     20     return xs_handle
|    |    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    |  < xenstore/xstransact.py:_write
|    |    |    |    |  197         for tup in args:
|    |    |    |    |  198             if len(tup) == 2:
|    |    |    |    |  199                 (key, val) = tup
|    |    |    |    |  200                 try:
|    |    |    |    |  201                     fmt = { str        : "%s",
|    |    |    |    |  210             if val is None:
|    |    |    |    |  213                 self._write(key, fmt % val)
|    |    |    |    |  > xenstore/xstransact.py:_write
|    |    |    |    |    69         path = self.prependPath(key)
|    |    |    |    |   > xenstore/xstransact.py:prependPath
|    |    |    |    |    283         if self.path:
|    |    |    |    |    284             return self.path + '/' + key
|    |    |    |    |   < xenstore/xstransact.py:prependPath
|    |    |    |    |    70         try:
|    |    |    |    |    71             xshandle().write(self.transaction, 
path, data)
|    |    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |    |     15     if not xs_handle:
|    |    |    |    |     20     return xs_handle
|    |    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    |  < xenstore/xstransact.py:_write
|    |    |    |    |  197         for tup in args:
|    |    |    |    | < xenstore/xstransact.py:store
|    |    |    |    |< xenstore/xstransact.py:<lambda>
|    |    |    |     354             if t.commit():
|    |    |    |    |> xenstore/xstransact.py:commit
|    |    |    |    |  28         if not self.in_transaction:
|    |    |    |    |  30         self.in_transaction = False
|    |    |    |    |  31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |  32         self.transaction = "0"
|    |    |    |    |  33         return rc
|    |    |    |    |< xenstore/xstransact.py:commit
|    |    |    |     355                 return result
|    |    |    |    < xenstore/xstransact.py:complete
|    |    |    |    > xenstore/xstransact.py:__del__
|    |    |    |      24         if self.in_transaction:
|    |    |    |    < xenstore/xstransact.py:__del__
|    |    |    |   < xenstore/xstransact.py:Store
|    |    |    |  < XendDomainInfo.py:storeVm
|    |    |    | < image.py:configure
|    |    |    |< image.py:__init__
|    |    |    < image.py:create
|    |    |   1268             localtime = self.info.get('localtime', 0)
|    |    |   1269             if localtime is not None and localtime == 1:
|    |    |   1272             xc.domain_setcpuweight(self.domid, 
self.info['cpu_weight'])
|    |    |   1277             if self.info['cpus'] is not None and 
len(self.info['cpus']) > 0:
|    |    |   1284             maxmem = self.image.getRequiredAvailableMemory(
|    |    |    > image.py:getRequiredAvailableMemory
|    |    |     153         return mem_kb
|    |    |    < image.py:getRequiredAvailableMemory
|    |    |   1286             memory = self.image.getRequiredAvailableMemory(
|    |    |    > image.py:getRequiredAvailableMemory
|    |    |     153         return mem_kb
|    |    |    < image.py:getRequiredAvailableMemory
|    |    |   1288             shadow = self.image.getRequiredShadowMemory(
|    |    |   1290                 self.info['maxmem'] * 1024)
|    |    |    > image.py:getRequiredShadowMemory
|    |    |     169         return 0
|    |    |    < image.py:getRequiredShadowMemory
|    |    |   1294             shadow = ((shadow + 1023) / 1024) * 1024
|    |    |   1297             xc.domain_setmaxmem(self.domid, maxmem)
|    |    |   1300             balloon.free(memory + shadow)
|    |    |    > balloon.py:free
|    |    |     110     xroot = XendRoot.instance()
|    |    |    |> XendRoot.py:instance
|    |    |    | 301     try:
|    |    |    | 302         inst
|    |    |    | 305     return inst
|    |    |    |< XendRoot.py:instance
|    |    |     111     xc = xen.lowlevel.xc.xc()
|    |    |     113     try:
|    |    |     114         dom0_min_mem = xroot.get_dom0_min_mem() * 1024
|    |    |    |> XendRoot.py:get_dom0_min_mem
|    |    |    | 281         return self.get_config_int('dom0-min-mem', 
self.dom0_min_mem_default)
|    |    |    | > XendRoot.py:get_config_int
|    |    |    |  186         v = self.get_config_value(name, val)
|    |    |    |  > XendRoot.py:get_config_value
|    |    |    |   175         return sxp.child_value(self.config, name, 
val=val)
|    |    |    |  < XendRoot.py:get_config_value
|    |    |    |  187         try:
|    |    |    |  188             return int(v)
|    |    |    | < XendRoot.py:get_config_int
|    |    |    |< XendRoot.py:get_dom0_min_mem
|    |    |     116         retries = 0
|    |    |     117         sleep_time = SLEEP_TIME_GROWTH
|    |    |     118         last_new_alloc = None
|    |    |     119         rlimit = RETRY_LIMIT
|    |    |     120         while retries < rlimit:
|    |    |     121             physinfo = xc.physinfo()
|    |    |     122             free_mem = physinfo['free_memory']
|    |    |     123             scrub_mem = physinfo['scrub_memory']
|    |    |     125             if free_mem >= need_mem:
|    |    |     126                 log.debug("Balloon: %d KiB free; need %d; 
done.",
|    |    |     127                           free_mem, need_mem)
|    |    |     128                 return
|    |    |     175         del xc
|    |    |    < balloon.py:free
|    |    |   1303             shadow_cur = xc.shadow_mem_control(self.domid, 
shadow / 1024)
|    |    |   1304             self.info['shadow_memory'] = shadow_cur
|    |    |   1306             self._createChannels()
|    |    |    > XendDomainInfo.py:_createChannels
|    |    |    1438         self.store_port = self._createChannel()
|    |    |    |> XendDomainInfo.py:_createChannel
|    |    |    |1445         try:
|    |    |    |1446             return 
xc.evtchn_alloc_unbound(domid=self.domid, remote_dom=0)
|    |    |    |< XendDomainInfo.py:_createChannel
|    |    |    1439         self.console_port = self._createChannel()
|    |    |    |> XendDomainInfo.py:_createChannel
|    |    |    |1445         try:
|    |    |    |1446             return 
xc.evtchn_alloc_unbound(domid=self.domid, remote_dom=0)
|    |    |    |< XendDomainInfo.py:_createChannel
|    |    |    < XendDomainInfo.py:_createChannels
|    |    |   1308             channel_details = self.image.createImage()
|    |    |    > image.py:createImage
|    |    |     120         return self.createDomain()
|    |    |    |> image.py:createDomain
|    |    |    | 128         if not os.path.isfile(self.kernel):
|    |    |    | 130         if self.ramdisk and not 
os.path.isfile(self.ramdisk):
|    |    |    | 132         if len(self.cmdline) >= MAX_GUEST_CMDLINE:
|    |    |    | 136         log.info("buildDomain os=%s dom=%d vcpus=%d", 
self.ostype,
|    |    |    | 137                  self.vm.getDomid(), 
self.vm.getVCpuCount())
|    |    |    | > XendDomainInfo.py:getDomid
|    |    |    |  789         return self.domid
|    |    |    | < XendDomainInfo.py:getDomid
|    |    |    | > XendDomainInfo.py:getVCpuCount
|    |    |    |  818         return self.info['vcpus']
|    |    |    | < XendDomainInfo.py:getVCpuCount
|    |    |    | 139         result = self.buildDomain()
|    |    |    | > image.py:buildDomain
|    |    |    |  189         store_evtchn = self.vm.getStorePort()
|    |    |    |  > XendDomainInfo.py:getStorePort
|    |    |    |   807         return self.store_port
|    |    |    |  < XendDomainInfo.py:getStorePort
|    |    |    |  190         console_evtchn = self.vm.getConsolePort()
|    |    |    |  > XendDomainInfo.py:getConsolePort
|    |    |    |   811         return self.console_port
|    |    |    |  < XendDomainInfo.py:getConsolePort
|    |    |    |  192         mem_mb = self.getRequiredInitialReservation() / 
1024
|    |    |    |  > image.py:getRequiredInitialReservation
|    |    |    |   161         return 
self.getRequiredAvailableMemory(self.vm.getMemoryTarget())
|    |    |    |   > XendDomainInfo.py:getMemoryTarget
|    |    |    |    830         return self.info['memory'] * 1024
|    |    |    |   < XendDomainInfo.py:getMemoryTarget
|    |    |    |   > image.py:getRequiredAvailableMemory
|    |    |    |    153         return mem_kb
|    |    |    |   < image.py:getRequiredAvailableMemory
|    |    |    |  < image.py:getRequiredInitialReservation
|    |    |    |  194         log.debug("domid          = %d", 
self.vm.getDomid())
|    |    |    |  > XendDomainInfo.py:getDomid
|    |    |    |   789         return self.domid
|    |    |    |  < XendDomainInfo.py:getDomid
|    |    |    |  195         log.debug("memsize        = %d", mem_mb)
|    |    |    |  196         log.debug("image          = %s", self.kernel)
|    |    |    |  197         log.debug("store_evtchn   = %d", store_evtchn)
|    |    |    |  198         log.debug("console_evtchn = %d", console_evtchn)
|    |    |    |  199         log.debug("cmdline        = %s", self.cmdline)
|    |    |    |  200         log.debug("ramdisk        = %s", self.ramdisk)
|    |    |    |  201         log.debug("vcpus          = %d", 
self.vm.getVCpuCount())
|    |    |    |  > XendDomainInfo.py:getVCpuCount
|    |    |    |   818         return self.info['vcpus']
|    |    |    |  < XendDomainInfo.py:getVCpuCount
|    |    |    |  202         log.debug("features       = %s", 
self.vm.getFeatures())
|    |    |    |  > XendDomainInfo.py:getFeatures
|    |    |    |   815         return self.info['features']
|    |    |    |  < XendDomainInfo.py:getFeatures
|    |    |    |  204         return xc.linux_build(domid          = 
self.vm.getDomid(),
|    |    |    |  > XendDomainInfo.py:getDomid
|    |    |    |   789         return self.domid
|    |    |    |  < XendDomainInfo.py:getDomid
|    |    |    |  205                               memsize        = mem_mb,
|    |    |    |  206                               image          = 
self.kernel,
|    |    |    |  207                               store_evtchn   = 
store_evtchn,
|    |    |    |  208                               console_evtchn = 
console_evtchn,
|    |    |    |  209                               cmdline        = 
self.cmdline,
|    |    |    |  210                               ramdisk        = 
self.ramdisk,
|    |    |    |  211                               features       = 
self.vm.getFeatures())
|    |    |    |  > XendDomainInfo.py:getFeatures
|    |    |    |   815         return self.info['features']
|    |    |    |  < XendDomainInfo.py:getFeatures
|    |    |    |  123                 for t in threads:
|    |    |    |  125                 runningThreads = len([t for t in threads 
if t.isAlive()])
|    |    |    |  125                 runningThreads = len([t for t in threads 
if t.isAlive()])
|    |    |    |  121         while runningThreads > 0:
|    |    |    |  122             try:
|    |    |    |  123                 for t in threads:
|    |    |    |  124                     t.join(1.0)
|    |    |    | < image.py:buildDomain
|    |    |    | 141         if isinstance(result, dict):
|    |    |    | 142             return result
|    |    |    |< image.py:createDomain
|    |    |    < image.py:createImage
|    |    |   1310             self.store_mfn = channel_details['store_mfn']
|    |    |   1311             if 'console_mfn' in channel_details:
|    |    |   1312                 self.console_mfn = 
channel_details['console_mfn']
|    |    |   1314             self._introduceDomain()
|    |    |    > XendDomainInfo.py:_introduceDomain
|    |    |    1240         assert self.domid is not None
|    |    |    1241         assert self.store_mfn is not None
|    |    |    1242         assert self.store_port is not None
|    |    |    1244         try:
|    |    |    1245             IntroduceDomain(self.domid, self.store_mfn, 
self.store_port)
|    |    |    |> xenstore/xsutil.py:IntroduceDomain
|    |    |    |  23     return xshandle().introduce_domain(domid, page, port)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xsutil.py:IntroduceDomain
|    |    |    < XendDomainInfo.py:_introduceDomain
|    |    |   1316             self._createDevices()
|    |    |    > XendDomainInfo.py:_createDevices
|    |    |    1119         for (devclass, config) in 
self.info.all_devices_sxpr():
|    |    |    |> XendConfig.py:all_devices_sxpr
|    |    |    | 914         sxprs = []
|    |    |    | 915         pci_devs = []
|    |    |    | 916         for dev_type, dev_info in self['device'].values():
|    |    |    | 917             if dev_type == 'pci': # special case for pci 
devices
|    |    |    | 920                 sxpr =  self.device_sxpr(dev_type = 
dev_type,
|    |    |    | 921                                          dev_info = 
dev_info)
|    |    |    | > XendConfig.py:device_sxpr
|    |    |    |  898         sxpr = []
|    |    |    |  899         if dev_uuid != None and dev_uuid in 
self['device']:
|    |    |    |  902         if dev_type == None or dev_info == None:
|    |    |    |  906         sxpr.append(dev_type)
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  907         config = [(opt, val) for opt, val in 
dev_info.items()]
|    |    |    |  908         sxpr += config
|    |    |    |  910         return sxpr
|    |    |    | < XendConfig.py:device_sxpr
|    |    |    | 922                 sxprs.append((dev_type, sxpr))
|    |    |    | 916         for dev_type, dev_info in self['device'].values():
|    |    |    | 926         if pci_devs:
|    |    |    | 934         return sxprs
|    |    |    |< XendConfig.py:all_devices_sxpr
|    |    |    1120             log.info("createDevice: %s : %s" % (devclass, 
config))
|    |    |    1121             self._createDevice(devclass, config)
|    |    |    |> XendDomainInfo.py:_createDevice
|    |    |    |1105         return 
self.getDeviceController(deviceClass).createDevice(devConfig)
|    |    |    | > XendDomainInfo.py:getDeviceController
|    |    |    | 1152         if name not in self._deviceControllers:
|    |    |    | 1153             devController = 
XendDevices.make_controller(name, self)
|    |    |    |  > XendDevices.py:make_controller
|    |    |    |    62         if name in cls.controllers.keys():
|    |    |    |    63             cls.controllers[name].deviceClass = name
|    |    |    |    64             return cls.controllers[name](domain)
|    |    |    |   > server/blkif.py:__init__
|    |    |    |     36         DevController.__init__(self, vm)
|    |    |    |    > server/DevController.py:__init__
|    |    |    |      72         self.vm = vm
|    |    |    |    < server/DevController.py:__init__
|    |    |    |   < server/blkif.py:__init__
|    |    |    |  < XendDevices.py:make_controller
|    |    |    | 1154             if not devController:
|    |    |    | 1156             self._deviceControllers[name] = devController
|    |    |    | 1158         return self._deviceControllers[name]
|    |    |    | < XendDomainInfo.py:getDeviceController
|    |    |    | > server/DevController.py:createDevice
|    |    |    |   80         (devid, back, front) = 
self.getDeviceDetails(config)
|    |    |    |  > server/blkif.py:getDeviceDetails
|    |    |    |    40         uname = sxp.child_value(config, 'uname', '')
|    |    |    |    41         dev = sxp.child_value(config, 'dev', '')
|    |    |    |    43         if 'ioemu:' in dev:
|    |    |    |    45         try:
|    |    |    |    46             (dev, dev_type) = string.split(dev, ':', 1)
|    |    |    |    50         if uname is None:
|    |    |    |    57             try:
|    |    |    |    58                 (typ, params) = string.split(uname, ':', 
1)
|    |    |    |    62         mode = sxp.child_value(config, 'mode', 'r')
|    |    |    |    63         if mode not in ('r', 'w', 'w!'):
|    |    |    |    66         back = { 'dev'    : dev,
|    |    |    |    72         uuid = sxp.child_value(config, 'uuid')
|    |    |    |    73         if uuid:
|    |    |    |    74             back['uuid'] = uuid
|    |    |    |    76         if security.on():
|    |    |    |    82         devid = blkif.blkdev_name_to_number(dev)
|    |    |    |    83         if devid is None:
|    |    |    |    86         front = { 'virtual-device' : "%i" % devid,
|    |    |    |    90         return (devid, back, front)
|    |    |    |  < server/blkif.py:getDeviceDetails
|    |    |    |   81         if devid is None:
|    |    |    |   84         (backpath, frontpath) = 
self.addStoreEntries(config, devid, back,
|    |    |    |   85                                                      
front)
|    |    |    |  > server/DevController.py:addStoreEntries
|    |    |    |   405         import xen.xend.XendDomain
|    |    |    |   406         xd = xen.xend.XendDomain.instance()
|    |    |    |   > XendDomain.py:instance
|    |    |    |   1333     try:
|    |    |    |   1334         inst
|    |    |    |   1338     return inst
|    |    |    |   < XendDomain.py:instance
|    |    |    |   408         backdom_name = sxp.child_value(config, 'backend')
|    |    |    |   409         if backdom_name:
|    |    |    |   412             backdom = xd.privilegedDomain()
|    |    |    |   > XendDomain.py:privilegedDomain
|    |    |    |    524         self.domains_lock.acquire()
|    |    |    |    525         try:
|    |    |    |    526             return self.domains[DOM0_ID]
|    |    |    |    528             self.domains_lock.release()
|    |    |    |   < XendDomain.py:privilegedDomain
|    |    |    |   414         if not backdom:
|    |    |    |   418         frontpath = self.frontendPath(devid)
|    |    |    |   > server/DevController.py:frontendPath
|    |    |    |    468         return "%s/%d" % (self.frontendRoot(), devid)
|    |    |    |    > server/DevController.py:frontendRoot
|    |    |    |     472         return "%s/device/%s" % 
(self.vm.getDomainPath(), self.deviceClass)
|    |    |    |    |> XendDomainInfo.py:getDomainPath
|    |    |    |    | 800         return self.dompath
|    |    |    |    |< XendDomainInfo.py:getDomainPath
|    |    |    |    < server/DevController.py:frontendRoot
|    |    |    |   < server/DevController.py:frontendPath
|    |    |    |   419         backpath  = self.backendPath(backdom, devid)
|    |    |    |   > server/DevController.py:backendPath
|    |    |    |    462         return "%s/backend/%s/%s/%d" % 
(backdom.getDomainPath(),
|    |    |    |    > XendDomainInfo.py:getDomainPath
|    |    |    |     800         return self.dompath
|    |    |    |    < XendDomainInfo.py:getDomainPath
|    |    |    |    > XendDomainInfo.py:getDomid
|    |    |    |     789         return self.domid
|    |    |    |    < XendDomainInfo.py:getDomid
|    |    |    |   < server/DevController.py:backendPath
|    |    |    |   421         frontDetails.update({
|    |    |    |   > XendDomainInfo.py:getDomid
|    |    |    |    789         return self.domid
|    |    |    |   < XendDomainInfo.py:getDomid
|    |    |    |   428         backDetails.update({
|    |    |    |   > XendDomainInfo.py:getName
|    |    |    |    797         return self.info['name']
|    |    |    |   < XendDomainInfo.py:getName
|    |    |    |   > XendDomainInfo.py:getDomid
|    |    |    |    789         return self.domid
|    |    |    |   < XendDomainInfo.py:getDomid
|    |    |    |   436         return (backpath, frontpath)
|    |    |    |  < server/DevController.py:addStoreEntries
|    |    |    |   87         import xen.xend.XendDomain
|    |    |    |   88         xd = xen.xend.XendDomain.instance()
|    |    |    |  > XendDomain.py:instance
|    |    |    |  1333     try:
|    |    |    |  1334         inst
|    |    |    |  1338     return inst
|    |    |    |  < XendDomain.py:instance
|    |    |    |   89         backdom_name = sxp.child_value(config, 'backend')
|    |    |    |   90         if backdom_name is None:
|    |    |    |   93             bd = xd.domain_lookup_nr(backdom_name)
|    |    |    |  > XendDomain.py:domain_lookup_nr
|    |    |    |   485         self.domains_lock.acquire()
|    |    |    |   486         try:
|    |    |    |   488             match = [dom for dom in 
self.domains.values() \
|    |    |    |   > XendDomainInfo.py:getName
|    |    |    |    797         return self.info['name']
|    |    |    |   < XendDomainInfo.py:getName
|    |    |    |   488             match = [dom for dom in 
self.domains.values() \
|    |    |    |   490             if match:
|    |    |    |   493             match = [dom for dom in 
self.managed_domains.values() \
|    |    |    |   495             if match:
|    |    |    |   499             try:
|    |    |    |   500                 if int(domid) in self.domains:
|    |    |    |   501                     return self.domains[int(domid)]
|    |    |    |   517             self.domains_lock.release()
|    |    |    |  < XendDomain.py:domain_lookup_nr
|    |    |    |   94             backdom = bd.getDomid()
|    |    |    |  > XendDomainInfo.py:getDomid
|    |    |    |   789         return self.domid
|    |    |    |  < XendDomainInfo.py:getDomid
|    |    |    |   95         count = 0
|    |    |    |   96         while True:
|    |    |    |   97             t = xstransact()
|    |    |    |  > xenstore/xstransact.py:__init__
|    |    |    |    14         assert path is not None
|    |    |    |    16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    19         self.path = path.rstrip("/")
|    |    |    |    20         self.transaction = xshandle().transaction_start()
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    21         self.in_transaction = True
|    |    |    |  < xenstore/xstransact.py:__init__
|    |    |    |   98             try:
|    |    |    |   99                 if devid in self.deviceIDs(t):
|    |    |    |  > server/DevController.py:deviceIDs
|    |    |    |   368         fe = self.backendRoot()
|    |    |    |   > server/DevController.py:backendRoot
|    |    |    |    476         from xen.xend.XendDomain import DOM0_ID
|    |    |    |    477         from xen.xend.xenstore.xsutil import 
GetDomainPath
|    |    |    |    478         return "%s/backend/%s/%s" % 
(GetDomainPath(DOM0_ID),
|    |    |    |    > xenstore/xsutil.py:GetDomainPath
|    |    |    |      26     return xshandle().get_domain_path(domid)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xsutil.py:GetDomainPath
|    |    |    |    > XendDomainInfo.py:getDomid
|    |    |    |     789         return self.domid
|    |    |    |    < XendDomainInfo.py:getDomid
|    |    |    |   < server/DevController.py:backendRoot
|    |    |    |   369         if transaction:
|    |    |    |   370             return map(lambda x: int(x.split('/')[-1]), 
transaction.list(fe))
|    |    |    |   > xenstore/xstransact.py:list
|    |    |    |    129         if len(args) == 0:
|    |    |    |    136             ret = []
|    |    |    |    137             for key in args:
|    |    |    |    138                 ret.extend(self._list(key))
|    |    |    |    > xenstore/xstransact.py:_list
|    |    |    |     117         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 286             return key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |     118         l = xshandle().ls(self.transaction, path)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |     119         if l:
|    |    |    |     121         return []
|    |    |    |    < xenstore/xstransact.py:_list
|    |    |    |    137             for key in args:
|    |    |    |    139             return ret
|    |    |    |   < xenstore/xstransact.py:list
|    |    |    |  < server/DevController.py:deviceIDs
|    |    |    |  108                 if count == 0:
|    |    |    |  109                     log.debug('DevController: writing %s 
to %s.', str(front),
|    |    |    |  110                               frontpath)
|    |    |    |  111                     log.debug('DevController: writing %s 
to %s.', str(back),
|    |    |    |  112                               backpath)
|    |    |    |  117                 t.remove(frontpath)
|    |    |    |  > xenstore/xstransact.py:remove
|    |    |    |   110         if len(args) == 0:
|    |    |    |   113             for key in args:
|    |    |    |   114                 self._remove(key)
|    |    |    |   > xenstore/xstransact.py:_remove
|    |    |    |    102         path = self.prependPath(key)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     286             return key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |    103         return xshandle().rm(self.transaction, path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xstransact.py:_remove
|    |    |    |   113             for key in args:
|    |    |    |  < xenstore/xstransact.py:remove
|    |    |    |  118                 t.remove(backpath)
|    |    |    |  > xenstore/xstransact.py:remove
|    |    |    |   110         if len(args) == 0:
|    |    |    |   113             for key in args:
|    |    |    |   114                 self._remove(key)
|    |    |    |   > xenstore/xstransact.py:_remove
|    |    |    |    102         path = self.prependPath(key)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     286             return key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |    103         return xshandle().rm(self.transaction, path)
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |   < xenstore/xstransact.py:_remove
|    |    |    |   113             for key in args:
|    |    |    |  < xenstore/xstransact.py:remove
|    |    |    |  120                 t.mkdir(backpath)
|    |    |    |  > xenstore/xstransact.py:mkdir
|    |    |    |   217         if len(args) == 0:
|    |    |    |   220             for key in args:
|    |    |    |   221                 xshandle().mkdir(self.transaction, 
self.prependPath(key))
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |   > xenstore/xstransact.py:prependPath
|    |    |    |    283         if self.path:
|    |    |    |    286             return key
|    |    |    |   < xenstore/xstransact.py:prependPath
|    |    |    |   220             for key in args:
|    |    |    |  < xenstore/xstransact.py:mkdir
|    |    |    |  121                 t.set_permissions(backpath,
|    |    |    |  122                                   {'dom': backdom },
|    |    |    |  123                                   {'dom'  : 
self.vm.getDomid(),
|    |    |    |  > XendDomainInfo.py:getDomid
|    |    |    |   789         return self.domid
|    |    |    |  < XendDomainInfo.py:getDomid
|    |    |    |  > xenstore/xstransact.py:set_permissions
|    |    |    |   253         if len(args) == 0:
|    |    |    |   255         elif isinstance(args[0], str):
|    |    |    |   256             self.callRebased(args[0], 
self.set_permissions, *args[1:])
|    |    |    |   > xenstore/xstransact.py:callRebased
|    |    |    |    274         oldpath = self.path
|    |    |    |    275         self.path = self.prependPath(middlePath)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     286             return key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |    276         try:
|    |    |    |    277             func(*args)
|    |    |    |    > xenstore/xstransact.py:set_permissions
|    |    |    |     253         if len(args) == 0:
|    |    |    |     255         elif isinstance(args[0], str):
|    |    |    |     258             if not self.path:
|    |    |    |     261             
xshandle().set_permissions(self.transaction, self.path,
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |     262                                        list(args))
|    |    |    |    < xenstore/xstransact.py:set_permissions
|    |    |    |    279             self.path = oldpath
|    |    |    |   < xenstore/xstransact.py:callRebased
|    |    |    |  < xenstore/xstransact.py:set_permissions
|    |    |    |  125                 t.mkdir(frontpath)
|    |    |    |  > xenstore/xstransact.py:mkdir
|    |    |    |   217         if len(args) == 0:
|    |    |    |   220             for key in args:
|    |    |    |   221                 xshandle().mkdir(self.transaction, 
self.prependPath(key))
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |   > xenstore/xstransact.py:prependPath
|    |    |    |    283         if self.path:
|    |    |    |    286             return key
|    |    |    |   < xenstore/xstransact.py:prependPath
|    |    |    |   220             for key in args:
|    |    |    |  < xenstore/xstransact.py:mkdir
|    |    |    |  126                 t.set_permissions(frontpath,
|    |    |    |  127                                   {'dom': 
self.vm.getDomid()},
|    |    |    |  > XendDomainInfo.py:getDomid
|    |    |    |   789         return self.domid
|    |    |    |  < XendDomainInfo.py:getDomid
|    |    |    |  128                                   {'dom': backdom, 
'read': True})
|    |    |    |  > xenstore/xstransact.py:set_permissions
|    |    |    |   253         if len(args) == 0:
|    |    |    |   255         elif isinstance(args[0], str):
|    |    |    |   256             self.callRebased(args[0], 
self.set_permissions, *args[1:])
|    |    |    |   > xenstore/xstransact.py:callRebased
|    |    |    |    274         oldpath = self.path
|    |    |    |    275         self.path = self.prependPath(middlePath)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     286             return key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |    276         try:
|    |    |    |    277             func(*args)
|    |    |    |    > xenstore/xstransact.py:set_permissions
|    |    |    |     253         if len(args) == 0:
|    |    |    |     255         elif isinstance(args[0], str):
|    |    |    |     258             if not self.path:
|    |    |    |     261             
xshandle().set_permissions(self.transaction, self.path,
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |     262                                        list(args))
|    |    |    |    < xenstore/xstransact.py:set_permissions
|    |    |    |    279             self.path = oldpath
|    |    |    |   < xenstore/xstransact.py:callRebased
|    |    |    |  < xenstore/xstransact.py:set_permissions
|    |    |    |  130                 t.write2(frontpath, front)
|    |    |    |  > xenstore/xstransact.py:write2
|    |    |    |   270         self.callRebased(middlePath, self.write, *args)
|    |    |    |   > xenstore/xstransact.py:callRebased
|    |    |    |    274         oldpath = self.path
|    |    |    |    275         self.path = self.prependPath(middlePath)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     286             return key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |    276         try:
|    |    |    |    277             func(*args)
|    |    |    |    > xenstore/xstransact.py:write
|    |    |    |      78         if len(args) == 0:
|    |    |    |      80         if isinstance(args[0], dict):
|    |    |    |      81             for d in args:
|    |    |    |      82                 if not isinstance(d, dict):
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      81             for d in args:
|    |    |    |    < xenstore/xstransact.py:write
|    |    |    |    279             self.path = oldpath
|    |    |    |   < xenstore/xstransact.py:callRebased
|    |    |    |  < xenstore/xstransact.py:write2
|    |    |    |  131                 t.write2(backpath,  back)
|    |    |    |  > xenstore/xstransact.py:write2
|    |    |    |   270         self.callRebased(middlePath, self.write, *args)
|    |    |    |   > xenstore/xstransact.py:callRebased
|    |    |    |    274         oldpath = self.path
|    |    |    |    275         self.path = self.prependPath(middlePath)
|    |    |    |    > xenstore/xstransact.py:prependPath
|    |    |    |     283         if self.path:
|    |    |    |     286             return key
|    |    |    |    < xenstore/xstransact.py:prependPath
|    |    |    |    276         try:
|    |    |    |    277             func(*args)
|    |    |    |    > xenstore/xstransact.py:write
|    |    |    |      78         if len(args) == 0:
|    |    |    |      80         if isinstance(args[0], dict):
|    |    |    |      81             for d in args:
|    |    |    |      82                 if not isinstance(d, dict):
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      85                     try:
|    |    |    |      86                         self._write(key, d[key])
|    |    |    |    |> xenstore/xstransact.py:_write
|    |    |    |    |  69         path = self.prependPath(key)
|    |    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |    |  283         if self.path:
|    |    |    |    |  284             return self.path + '/' + key
|    |    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |    |  70         try:
|    |    |    |    |  71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |    |   15     if not xs_handle:
|    |    |    |    |   20     return xs_handle
|    |    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |    |< xenstore/xstransact.py:_write
|    |    |    |      84                 for key in d.keys():
|    |    |    |      81             for d in args:
|    |    |    |    < xenstore/xstransact.py:write
|    |    |    |    279             self.path = oldpath
|    |    |    |   < xenstore/xstransact.py:callRebased
|    |    |    |  < xenstore/xstransact.py:write2
|    |    |    |  133                 if t.commit():
|    |    |    |  > xenstore/xstransact.py:commit
|    |    |    |    28         if not self.in_transaction:
|    |    |    |    30         self.in_transaction = False
|    |    |    |    31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    32         self.transaction = "0"
|    |    |    |    33         return rc
|    |    |    |  < xenstore/xstransact.py:commit
|    |    |    |  134                     return devid
|    |    |    | < server/DevController.py:createDevice
|    |    |    | > xenstore/xstransact.py:__del__
|    |    |    |   24         if self.in_transaction:
|    |    |    | < xenstore/xstransact.py:__del__
|    |    |    |< XendDomainInfo.py:_createDevice
|    |    |    1119         for (devclass, config) in 
self.info.all_devices_sxpr():
|    |    |    1123         if self.image:
|    |    |    1124             self.image.createDeviceModel()
|    |    |    |> image.py:createDeviceModel
|    |    |    | 176         """Create device model for the domain (define in 
subclass if needed)."""
|    |    |    |< image.py:createDeviceModel
|    |    |    < XendDomainInfo.py:_createDevices
|    |    |   1318             if self.info['bootloader']:
|    |    |   1321             self.info['start_time'] = time.time()
|    |    |   1323             self._stateSet(DOM_STATE_RUNNING)
|    |    |    > XendDomainInfo.py:_stateSet
|    |    |    1595         self.state_updated.acquire()
|    |    |    1596         try:
|    |    |    1597             if self.state != state:
|    |    |    1598                 self.state = state
|    |    |    1599                 self.state_updated.notifyAll()
|    |    |    1601             self.state_updated.release()
|    |    |    < XendDomainInfo.py:_stateSet
|    |    |   < XendDomainInfo.py:_initDomain
|    |    |   438                 self._storeVmDetails()
|    |    |   > XendDomainInfo.py:_storeVmDetails
|    |    |   1546         to_store = {}
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1549             if self._infoIsSet(k[0]):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1550                 to_store[k[0]] = str(self.info[k[0]])
|    |    |   1548         for k in VM_STORE_ENTRIES:
|    |    |   1552         if self._infoIsSet('image'):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1553             to_store['image'] = 
sxp.to_string(self.info['image'])
|    |    |   1555         if self._infoIsSet('security'):
|    |    |    > XendDomainInfo.py:_infoIsSet
|    |    |    1604         return name in self.info and self.info[name] is not 
None
|    |    |    < XendDomainInfo.py:_infoIsSet
|    |    |   1556             secinfo = self.info['security']
|    |    |   1557             to_store['security'] = sxp.to_string(secinfo)
|    |    |   1558             for idx in range(0, len(secinfo)):
|    |    |   1573         if not self._readVm('xend/restart_count'):
|    |    |    > XendDomainInfo.py:_readVm
|    |    |     644         return xstransact.Read(self.vmpath, *args)
|    |    |    |> xenstore/xstransact.py:Read
|    |    |    | 297         return complete(path, lambda t: t.read(*args))
|    |    |    | > xenstore/xstransact.py:complete
|    |    |    |  350     while True:
|    |    |    |  351         t = xstransact(path)
|    |    |    |  > xenstore/xstransact.py:__init__
|    |    |    |    14         assert path is not None
|    |    |    |    16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    19         self.path = path.rstrip("/")
|    |    |    |    20         self.transaction = xshandle().transaction_start()
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    21         self.in_transaction = True
|    |    |    |  < xenstore/xstransact.py:__init__
|    |    |    |  352         try:
|    |    |    |  353             result = f(t)
|    |    |    |  > xenstore/xstransact.py:<lambda>
|    |    |    |   297         return complete(path, lambda t: t.read(*args))
|    |    |    |   > xenstore/xstransact.py:read
|    |    |    |     59         if len(args) == 0:
|    |    |    |     61         if len(args) == 1:
|    |    |    |     62             return self._read(args[0])
|    |    |    |    > xenstore/xstransact.py:_read
|    |    |    |      44         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      45         try:
|    |    |    |      46             return xshandle().read(self.transaction, 
path)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_read
|    |    |    |   < xenstore/xstransact.py:read
|    |    |    |  < xenstore/xstransact.py:<lambda>
|    |    |    |  354             if t.commit():
|    |    |    |  > xenstore/xstransact.py:commit
|    |    |    |    28         if not self.in_transaction:
|    |    |    |    30         self.in_transaction = False
|    |    |    |    31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    32         self.transaction = "0"
|    |    |    |    33         return rc
|    |    |    |  < xenstore/xstransact.py:commit
|    |    |    |  355                 return result
|    |    |    | < xenstore/xstransact.py:complete
|    |    |    | > xenstore/xstransact.py:__del__
|    |    |    |   24         if self.in_transaction:
|    |    |    | < xenstore/xstransact.py:__del__
|    |    |    |< xenstore/xstransact.py:Read
|    |    |    < XendDomainInfo.py:_readVm
|    |    |   1576         log.debug("Storing VM details: %s", to_store)
|    |    |   1578         self._writeVm(to_store)
|    |    |    > XendDomainInfo.py:_writeVm
|    |    |     647         return xstransact.Write(self.vmpath, *args)
|    |    |    |> xenstore/xstransact.py:Write
|    |    |    | 301         complete(path, lambda t: t.write(*args))
|    |    |    | > xenstore/xstransact.py:complete
|    |    |    |  350     while True:
|    |    |    |  351         t = xstransact(path)
|    |    |    |  > xenstore/xstransact.py:__init__
|    |    |    |    14         assert path is not None
|    |    |    |    16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    19         self.path = path.rstrip("/")
|    |    |    |    20         self.transaction = xshandle().transaction_start()
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    21         self.in_transaction = True
|    |    |    |  < xenstore/xstransact.py:__init__
|    |    |    |  352         try:
|    |    |    |  353             result = f(t)
|    |    |    |  > xenstore/xstransact.py:<lambda>
|    |    |    |   301         complete(path, lambda t: t.write(*args))
|    |    |    |   > xenstore/xstransact.py:write
|    |    |    |     78         if len(args) == 0:
|    |    |    |     80         if isinstance(args[0], dict):
|    |    |    |     81             for d in args:
|    |    |    |     82                 if not isinstance(d, dict):
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     81             for d in args:
|    |    |    |   < xenstore/xstransact.py:write
|    |    |    |  < xenstore/xstransact.py:<lambda>
|    |    |    |  354             if t.commit():
|    |    |    |  > xenstore/xstransact.py:commit
|    |    |    |    28         if not self.in_transaction:
|    |    |    |    30         self.in_transaction = False
|    |    |    |    31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    32         self.transaction = "0"
|    |    |    |    33         return rc
|    |    |    |  < xenstore/xstransact.py:commit
|    |    |    |  355                 return result
|    |    |    | < xenstore/xstransact.py:complete
|    |    |    | > xenstore/xstransact.py:__del__
|    |    |    |   24         if self.in_transaction:
|    |    |    | < xenstore/xstransact.py:__del__
|    |    |    |< xenstore/xstransact.py:Write
|    |    |    < XendDomainInfo.py:_writeVm
|    |    |   1579         self._setVmPermissions()
|    |    |    > XendDomainInfo.py:_setVmPermissions
|    |    |    1585         xstransact.SetPermissions('%s/uuid' % self.vmpath,
|    |    |    1586                                   { 'dom' : self.domid,
|    |    |    |> xenstore/xstransact.py:SetPermissions
|    |    |    | 341         complete(path, lambda t: t.set_permissions(*args))
|    |    |    | > xenstore/xstransact.py:complete
|    |    |    |  350     while True:
|    |    |    |  351         t = xstransact(path)
|    |    |    |  > xenstore/xstransact.py:__init__
|    |    |    |    14         assert path is not None
|    |    |    |    16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    19         self.path = path.rstrip("/")
|    |    |    |    20         self.transaction = xshandle().transaction_start()
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    21         self.in_transaction = True
|    |    |    |  < xenstore/xstransact.py:__init__
|    |    |    |  352         try:
|    |    |    |  353             result = f(t)
|    |    |    |  > xenstore/xstransact.py:<lambda>
|    |    |    |   341         complete(path, lambda t: 
t.set_permissions(*args))
|    |    |    |   > xenstore/xstransact.py:set_permissions
|    |    |    |    253         if len(args) == 0:
|    |    |    |    255         elif isinstance(args[0], str):
|    |    |    |    258             if not self.path:
|    |    |    |    261             
xshandle().set_permissions(self.transaction, self.path,
|    |    |    |    > xenstore/xsutil.py:xshandle
|    |    |    |      15     if not xs_handle:
|    |    |    |      20     return xs_handle
|    |    |    |    < xenstore/xsutil.py:xshandle
|    |    |    |    262                                        list(args))
|    |    |    |   < xenstore/xstransact.py:set_permissions
|    |    |    |  < xenstore/xstransact.py:<lambda>
|    |    |    |  354             if t.commit():
|    |    |    |  > xenstore/xstransact.py:commit
|    |    |    |    28         if not self.in_transaction:
|    |    |    |    30         self.in_transaction = False
|    |    |    |    31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    32         self.transaction = "0"
|    |    |    |    33         return rc
|    |    |    |  < xenstore/xstransact.py:commit
|    |    |    |  355                 return result
|    |    |    | < xenstore/xstransact.py:complete
|    |    |    | > xenstore/xstransact.py:__del__
|    |    |    |   24         if self.in_transaction:
|    |    |    | < xenstore/xstransact.py:__del__
|    |    |    |< xenstore/xstransact.py:SetPermissions
|    |    |    < XendDomainInfo.py:_setVmPermissions
|    |    |   < XendDomainInfo.py:_storeVmDetails
|    |    |   439                 self._storeDomDetails()
|    |    |   > XendDomainInfo.py:_storeDomDetails
|    |    |    684         to_store = {
|    |    |    > XendRoot.py:get_console_limit
|    |    |     287         return self.get_config_int('console-limit', 1024)
|    |    |    |> XendRoot.py:get_config_int
|    |    |    | 186         v = self.get_config_value(name, val)
|    |    |    | > XendRoot.py:get_config_value
|    |    |    |  175         return sxp.child_value(self.config, name, val=val)
|    |    |    | < XendRoot.py:get_config_value
|    |    |    | 187         try:
|    |    |    | 188             return int(v)
|    |    |    |< XendRoot.py:get_config_int
|    |    |    < XendRoot.py:get_console_limit
|    |    |    692         def f(n, v):
|    |    |    696         f('console/port',     self.console_port)
|    |    |    > XendDomainInfo.py:f
|    |    |     693             if v is not None:
|    |    |     694                 to_store[n] = str(v)
|    |    |    < XendDomainInfo.py:f
|    |    |    697         f('console/ring-ref', self.console_mfn)
|    |    |    > XendDomainInfo.py:f
|    |    |     693             if v is not None:
|    |    |     694                 to_store[n] = str(v)
|    |    |    < XendDomainInfo.py:f
|    |    |    698         f('store/port',       self.store_port)
|    |    |    > XendDomainInfo.py:f
|    |    |     693             if v is not None:
|    |    |     694                 to_store[n] = str(v)
|    |    |    < XendDomainInfo.py:f
|    |    |    699         f('store/ring-ref',   self.store_mfn)
|    |    |    > XendDomainInfo.py:f
|    |    |     693             if v is not None:
|    |    |     694                 to_store[n] = str(v)
|    |    |    < XendDomainInfo.py:f
|    |    |    701         to_store.update(self._vcpuDomDetails())
|    |    |    > XendDomainInfo.py:_vcpuDomDetails
|    |    |     708         def availability(n):
|    |    |     714         result = {}
|    |    |     715         for v in range(0, self.info['vcpus']):
|    |    |     716             result["cpu/%d/availability" % v] = 
availability(v)
|    |    |    |> XendDomainInfo.py:availability
|    |    |    | 709             if self.info['vcpu_avail'] & (1 << n):
|    |    |    | 710                 return 'online'
|    |    |    |< XendDomainInfo.py:availability
|    |    |     715         for v in range(0, self.info['vcpus']):
|    |    |     717         return result
|    |    |    < XendDomainInfo.py:_vcpuDomDetails
|    |    |    703         log.debug("Storing domain details: %s", to_store)
|    |    |    705         self._writeDom(to_store)
|    |    |    > XendDomainInfo.py:_writeDom
|    |    |     666         return xstransact.Write(self.dompath, *args)
|    |    |    |> xenstore/xstransact.py:Write
|    |    |    | 301         complete(path, lambda t: t.write(*args))
|    |    |    | > xenstore/xstransact.py:complete
|    |    |    |  350     while True:
|    |    |    |  351         t = xstransact(path)
|    |    |    |  > xenstore/xstransact.py:__init__
|    |    |    |    14         assert path is not None
|    |    |    |    16         self.in_transaction = False # Set this 
temporarily -- if this
|    |    |    |    19         self.path = path.rstrip("/")
|    |    |    |    20         self.transaction = xshandle().transaction_start()
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    21         self.in_transaction = True
|    |    |    |  < xenstore/xstransact.py:__init__
|    |    |    |  352         try:
|    |    |    |  353             result = f(t)
|    |    |    |  > xenstore/xstransact.py:<lambda>
|    |    |    |   301         complete(path, lambda t: t.write(*args))
|    |    |    |   > xenstore/xstransact.py:write
|    |    |    |     78         if len(args) == 0:
|    |    |    |     80         if isinstance(args[0], dict):
|    |    |    |     81             for d in args:
|    |    |    |     82                 if not isinstance(d, dict):
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     85                     try:
|    |    |    |     86                         self._write(key, d[key])
|    |    |    |    > xenstore/xstransact.py:_write
|    |    |    |      69         path = self.prependPath(key)
|    |    |    |    |> xenstore/xstransact.py:prependPath
|    |    |    |    | 283         if self.path:
|    |    |    |    | 284             return self.path + '/' + key
|    |    |    |    |< xenstore/xstransact.py:prependPath
|    |    |    |      70         try:
|    |    |    |      71             xshandle().write(self.transaction, path, 
data)
|    |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |    |  15     if not xs_handle:
|    |    |    |    |  20     return xs_handle
|    |    |    |    |< xenstore/xsutil.py:xshandle
|    |    |    |    < xenstore/xstransact.py:_write
|    |    |    |     84                 for key in d.keys():
|    |    |    |     81             for d in args:
|    |    |    |   < xenstore/xstransact.py:write
|    |    |    |  < xenstore/xstransact.py:<lambda>
|    |    |    |  354             if t.commit():
|    |    |    |  > xenstore/xstransact.py:commit
|    |    |    |    28         if not self.in_transaction:
|    |    |    |    30         self.in_transaction = False
|    |    |    |    31         rc = 
xshandle().transaction_end(self.transaction, False)
|    |    |    |   > xenstore/xsutil.py:xshandle
|    |    |    |     15     if not xs_handle:
|    |    |    |     20     return xs_handle
|    |    |    |   < xenstore/xsutil.py:xshandle
|    |    |    |    32         self.transaction = "0"
|    |    |    |    33         return rc
|    |    |    |  < xenstore/xstransact.py:commit
|    |    |    |  355                 return result
|    |    |    | < xenstore/xstransact.py:complete
|    |    |    | > xenstore/xstransact.py:__del__
|    |    |    |   24         if self.in_transaction:
|    |    |    | < xenstore/xstransact.py:__del__
|    |    |    |< xenstore/xstransact.py:Write
|    |    |    < XendDomainInfo.py:_writeDom
|    |    |   < XendDomainInfo.py:_storeDomDetails
|    |    |   440                 self._registerWatches()
|    |    |   > XendDomainInfo.py:_registerWatches
|    |    |    729         self.vmWatch = xswatch(self.vmpath, 
self._storeChanged)
|    |    |    > xenstore/xswatch.py:__init__
|    |    |      29         self.path = path
|    |    |      30         self.fn = fn
|    |    |      31         self.args = args
|    |    |      32         self.kwargs = kwargs
|    |    |      33         watchStart()
|    |    |    |> xenstore/xswatch.py:watchStart
|    |    |    |  49     xslock.acquire()
|    |    |    |  50     try:
|    |    |    |  51         if watchThread:
|    |    |    |  52             return
|    |    |    |  58         xslock.release()
|    |    |    |< xenstore/xswatch.py:watchStart
|    |    |      34         xs.watch(path, self)
|    |    |    < xenstore/xswatch.py:__init__
|    |    |    730         self.shutdownWatch = xswatch(self.dompath + 
'/control/shutdown',
|    |    |    731                                      
self._handleShutdownWatch)
|    |    |    > xenstore/xswatch.py:__init__
|    |    |      29         self.path = path
|    |    |      30         self.fn = fn
|    |    |      31         self.args = args
|    |    |      32         self.kwargs = kwargs
|    |    |      33         watchStart()
|    |    |    |> xenstore/xswatch.py:watchStart
|    |    |    |  49     xslock.acquire()
|    |    |    |  50     try:
|    |    |    |  51         if watchThread:
|    |    |    |  52             return
|    |    |    |  58         xslock.release()
|    |    |    |< xenstore/xswatch.py:watchStart
|    |    |      34         xs.watch(path, self)
|    |    |    < xenstore/xswatch.py:__init__
|    |    |   < XendDomainInfo.py:_registerWatches
|    |    |   441                 self.refreshShutdown()
|    |    |   > XendDomainInfo.py:refreshShutdown
|    |    |    856         restart_reason = None
|    |    |    858         self.refresh_shutdown_lock.acquire()
|    |    |    859         try:
|    |    |    860             if xeninfo is None:
|    |    |    861                 xeninfo = dom_get(self.domid)
|    |    |    > XendDomainInfo.py:dom_get
|    |    |     306     try:
|    |    |     307         domlist = xc.domain_getinfo(dom, 1)
|    |    |     308         if domlist and dom == domlist[0]['domid']:
|    |    |     309             return domlist[0]
|    |    |    < XendDomainInfo.py:dom_get
|    |    |    862                 if xeninfo is None:
|    |    |    874             if xeninfo['dying']:
|    |    |    886             elif xeninfo['crashed']:
|    |    |    901             elif xeninfo['shutdown']:
|    |    |    928             elif self.dompath is None:
|    |    |    936                 if xeninfo['paused']:
|    |    |    937                     self._stateSet(DOM_STATE_PAUSED)
|    |    |    > XendDomainInfo.py:_stateSet
|    |    |    1595         self.state_updated.acquire()
|    |    |    1596         try:
|    |    |    1597             if self.state != state:
|    |    |    1598                 self.state = state
|    |    |    1599                 self.state_updated.notifyAll()
|    |    |    1601             self.state_updated.release()
|    |    |    < XendDomainInfo.py:_stateSet
|    |    |    941                 if self.shutdownStartTime:
|    |    |    950             self.refresh_shutdown_lock.release()
|    |    |    952         if restart_reason:
|    |    |   < XendDomainInfo.py:refreshShutdown
|    |    |   442                 self.unpause()
|    |    |   > XendDomainInfo.py:unpause
|    |    |    499         try:
|    |    |    500             xc.domain_unpause(self.domid)
|    |    |    501             self._stateSet(DOM_STATE_RUNNING)
|    |    |    > XendDomainInfo.py:_stateSet
|    |    |    1595         self.state_updated.acquire()
|    |    |    1596         try:
|    |    |    1597             if self.state != state:
|    |    |    1598                 self.state = state
|    |    |    1599                 self.state_updated.notifyAll()
|    |    |    1601             self.state_updated.release()
|    |    |    < XendDomainInfo.py:_stateSet
|    |    |   < XendDomainInfo.py:unpause
|    |    |   447                 if is_managed:
|    |    |  < XendDomainInfo.py:start
|    |    |  156     return vm
|    |    | < XendDomainInfo.py:create
|    |    | 803             self._add_domain(dominfo)
|    |    | > XendDomain.py:_add_domain
|    |    |  402         log.debug("Adding Domain: %s" % info.getDomid())
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    |  403         self.domains[info.getDomid()] = info
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    | < XendDomain.py:_add_domain
|    |    | 804             self.domain_sched_credit_set(dominfo.getDomid(),
|    |    | > XendDomainInfo.py:getDomid
|    |    |  789         return self.domid
|    |    | < XendDomainInfo.py:getDomid
|    |    | 805                                          dominfo.getWeight(),
|    |    | > XendDomainInfo.py:getWeight
|    |    |  839         return self.info['cpu_weight']
|    |    | < XendDomainInfo.py:getWeight
|    |    | 806                                          dominfo.getCap())
|    |    | > XendDomainInfo.py:getCap
|    |    |  836         return self.info['cpu_cap']
|    |    | < XendDomainInfo.py:getCap
|    |    | > XendDomain.py:domain_sched_credit_set
|    |    | 1247         dominfo = self.domain_lookup_nr(domid)
|    |    |  > XendDomain.py:domain_lookup_nr
|    |    |   485         self.domains_lock.acquire()
|    |    |   486         try:
|    |    |   488             match = [dom for dom in self.domains.values() \
|    |    |   > XendDomainInfo.py:getName
|    |    |    797         return self.info['name']
|    |    |   < XendDomainInfo.py:getName
|    |    |   488             match = [dom for dom in self.domains.values() \
|    |    |   > XendDomainInfo.py:getName
|    |    |    797         return self.info['name']
|    |    |   < XendDomainInfo.py:getName
|    |    |   488             match = [dom for dom in self.domains.values() \
|    |    |   490             if match:
|    |    |   493             match = [dom for dom in 
self.managed_domains.values() \
|    |    |   495             if match:
|    |    |   499             try:
|    |    |   500                 if int(domid) in self.domains:
|    |    |   501                     return self.domains[int(domid)]
|    |    |   517             self.domains_lock.release()
|    |    |  < XendDomain.py:domain_lookup_nr
|    |    | 1248         if not dominfo:
|    |    | 1250         try:
|    |    | 1251             if weight is None:
|    |    | 1253             elif weight < 1 or weight > 65535:
|    |    | 1256             if cap is None:
|    |    | 1258             elif cap < 0 or cap > dominfo.getVCpuCount() * 100:
|    |    |  > XendDomainInfo.py:getVCpuCount
|    |    |   818         return self.info['vcpus']
|    |    |  < XendDomainInfo.py:getVCpuCount
|    |    | 1261             assert type(weight) == int
|    |    | 1262             assert type(cap) == int
|    |    | 1264             return 
xc.sched_credit_domain_set(dominfo.getDomid(), weight, cap)
|    |    |  > XendDomainInfo.py:getDomid
|    |    |   789         return self.domid
|    |    |  < XendDomainInfo.py:getDomid
|    |    | < XendDomain.py:domain_sched_credit_set
|    |    | 807             return dominfo
|    |    | 809             self.domains_lock.release()
|    |    |< XendDomain.py:domain_create
|    |    1032                 new_dom.unpause()
|    |    |> XendDomainInfo.py:unpause
|    |    | 499         try:
|    |    | 500             xc.domain_unpause(self.domid)
|    |    | 501             self._stateSet(DOM_STATE_RUNNING)
|    |    | > XendDomainInfo.py:_stateSet
|    |    | 1595         self.state_updated.acquire()
|    |    | 1596         try:
|    |    | 1597             if self.state != state:
|    |    | 1601             self.state_updated.release()
|    |    | < XendDomainInfo.py:_stateSet
|    |    |< XendDomainInfo.py:unpause
|    |    1033                 rst_cnt = self._readVm('xend/restart_count')
|    |    |> XendDomainInfo.py:_readVm
|    |    | 644         return xstransact.Read(self.vmpath, *args)
|    |    | > xenstore/xstransact.py:Read
|    |    |  297         return complete(path, lambda t: t.read(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    297         return complete(path, lambda t: t.read(*args))
|    |    |    > xenstore/xstransact.py:read
|    |    |      59         if len(args) == 0:
|    |    |      61         if len(args) == 1:
|    |    |      62             return self._read(args[0])
|    |    |    |> xenstore/xstransact.py:_read
|    |    |    |  44         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  45         try:
|    |    |    |  46             return xshandle().read(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_read
|    |    |    < xenstore/xstransact.py:read
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:Read
|    |    |< XendDomainInfo.py:_readVm
|    |    1034                 rst_cnt = int(rst_cnt) + 1
|    |    1035                 self._writeVm('xend/restart_count', str(rst_cnt))
|    |    |> XendDomainInfo.py:_writeVm
|    |    | 647         return xstransact.Write(self.vmpath, *args)
|    |    | > xenstore/xstransact.py:Write
|    |    |  301         complete(path, lambda t: t.write(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    301         complete(path, lambda t: t.write(*args))
|    |    |    > xenstore/xstransact.py:write
|    |    |      78         if len(args) == 0:
|    |    |      80         if isinstance(args[0], dict):
|    |    |      90         elif isinstance(args[0], list):
|    |    |      95         elif len(args) % 2 == 0:
|    |    |      96             for i in range(len(args) / 2):
|    |    |      97                 self._write(args[i * 2], args[i * 2 + 1])
|    |    |    |> xenstore/xstransact.py:_write
|    |    |    |  69         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    |  70         try:
|    |    |    |  71             xshandle().write(self.transaction, path, data)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_write
|    |    |      96             for i in range(len(args) / 2):
|    |    |    < xenstore/xstransact.py:write
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:Write
|    |    |< XendDomainInfo.py:_writeVm
|    |    1036                 new_dom._removeVm(RESTART_IN_PROGRESS)
|    |    |> XendDomainInfo.py:_removeVm
|    |    | 650         return xstransact.Remove(self.vmpath, *args)
|    |    | > xenstore/xstransact.py:Remove
|    |    |  309         complete(path, lambda t: t.remove(*args))
|    |    |  > xenstore/xstransact.py:complete
|    |    |   350     while True:
|    |    |   351         t = xstransact(path)
|    |    |   > xenstore/xstransact.py:__init__
|    |    |     14         assert path is not None
|    |    |     16         self.in_transaction = False # Set this temporarily 
-- if this
|    |    |     19         self.path = path.rstrip("/")
|    |    |     20         self.transaction = xshandle().transaction_start()
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     21         self.in_transaction = True
|    |    |   < xenstore/xstransact.py:__init__
|    |    |   352         try:
|    |    |   353             result = f(t)
|    |    |   > xenstore/xstransact.py:<lambda>
|    |    |    309         complete(path, lambda t: t.remove(*args))
|    |    |    > xenstore/xstransact.py:remove
|    |    |     110         if len(args) == 0:
|    |    |     113             for key in args:
|    |    |     114                 self._remove(key)
|    |    |    |> xenstore/xstransact.py:_remove
|    |    |    | 102         path = self.prependPath(key)
|    |    |    | > xenstore/xstransact.py:prependPath
|    |    |    |  283         if self.path:
|    |    |    |  284             return self.path + '/' + key
|    |    |    | < xenstore/xstransact.py:prependPath
|    |    |    | 103         return xshandle().rm(self.transaction, path)
|    |    |    | > xenstore/xsutil.py:xshandle
|    |    |    |   15     if not xs_handle:
|    |    |    |   20     return xs_handle
|    |    |    | < xenstore/xsutil.py:xshandle
|    |    |    |< xenstore/xstransact.py:_remove
|    |    |     113             for key in args:
|    |    |    < xenstore/xstransact.py:remove
|    |    |   < xenstore/xstransact.py:<lambda>
|    |    |   354             if t.commit():
|    |    |   > xenstore/xstransact.py:commit
|    |    |     28         if not self.in_transaction:
|    |    |     30         self.in_transaction = False
|    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |    > xenstore/xsutil.py:xshandle
|    |    |      15     if not xs_handle:
|    |    |      20     return xs_handle
|    |    |    < xenstore/xsutil.py:xshandle
|    |    |     32         self.transaction = "0"
|    |    |     33         return rc
|    |    |   < xenstore/xstransact.py:commit
|    |    |   355                 return result
|    |    |  < xenstore/xstransact.py:complete
|    |    |  > xenstore/xstransact.py:__del__
|    |    |    24         if self.in_transaction:
|    |    |  < xenstore/xstransact.py:__del__
|    |    | < xenstore/xstransact.py:Remove
|    |    |< XendDomainInfo.py:_removeVm
|    |    < XendDomainInfo.py:_restart
|    |   < XendDomainInfo.py:_maybeRestart
|    |  < XendDomainInfo.py:refreshShutdown
|    | 1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    | 1660                   str(self.domid), self.info)
|    |  > XendLogging.py:trace
|    |    36         self.log(logging.TRACE, *args, **kwargs)
|    |  < XendLogging.py:trace
|    | < XendDomainInfo.py:update
|    | 380         for dom in running:
|    | 389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    | 389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    | 389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    | 390         for domid, dom in self.domains.items():
|    | 391             if domid not in running_domids and domid != DOM0_ID:
|    | 390         for domid, dom in self.domains.items():
|    | 391             if domid not in running_domids and domid != DOM0_ID:
|    | 392                 self._remove_domain(dom, domid)
|    | > XendDomain.py:_remove_domain
|    |  413         if info:
|    |  414             if domid == None:
|    |  417             if info.state != DOM_STATE_HALTED:
|    |  418                 info.cleanupDomain()
|    |  > XendDomainInfo.py:cleanupDomain
|    |  1333         self.refresh_shutdown_lock.acquire()
|    |  1334         try:
|    |  1335             self.unwatchShutdown()
|    |   > XendDomainInfo.py:unwatchShutdown
|    |   1362         try:
|    |   1363             try:
|    |   1364                 if self.shutdownWatch:
|    |   1365                     self.shutdownWatch.unwatch()
|    |    > xenstore/xswatch.py:unwatch
|    |      38         xs.unwatch(self.path, self)
|    |    < xenstore/xswatch.py:unwatch
|    |   1367                 self.shutdownWatch = None
|    |   < XendDomainInfo.py:unwatchShutdown
|    |  1337             self._releaseDevices()
|    |   > XendDomainInfo.py:_releaseDevices
|    |   1129         while True:
|    |   1130             t = xstransact("%s/device" % self.dompath)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |   1131             for devclass in XendDevices.valid_devices():
|    |    > XendDevices.py:valid_devices
|    |      48         return cls.controllers.keys()
|    |    < XendDevices.py:valid_devices
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 120             return map(lambda x: key + "/" + x, l)
|    |    | > xenstore/xstransact.py:<lambda>
|    |    |  120             return map(lambda x: key + "/" + x, l)
|    |    | < xenstore/xstransact.py:<lambda>
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1133                     try:
|    |   1134                         t.remove(dev)
|    |    > xenstore/xstransact.py:remove
|    |     110         if len(args) == 0:
|    |     113             for key in args:
|    |     114                 self._remove(key)
|    |    |> xenstore/xstransact.py:_remove
|    |    | 102         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 103         return xshandle().rm(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_remove
|    |     113             for key in args:
|    |    < xenstore/xstransact.py:remove
|    |   1132                 for dev in t.list(devclass):
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1141             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |   1129         while True:
|    |   1130             t = xstransact("%s/device" % self.dompath)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |   1131             for devclass in XendDevices.valid_devices():
|    |    > XendDevices.py:valid_devices
|    |      48         return cls.controllers.keys()
|    |    < XendDevices.py:valid_devices
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 120             return map(lambda x: key + "/" + x, l)
|    |    | > xenstore/xstransact.py:<lambda>
|    |    |  120             return map(lambda x: key + "/" + x, l)
|    |    | < xenstore/xstransact.py:<lambda>
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1133                     try:
|    |   1134                         t.remove(dev)
|    |    > xenstore/xstransact.py:remove
|    |     110         if len(args) == 0:
|    |     113             for key in args:
|    |     114                 self._remove(key)
|    |    |> xenstore/xstransact.py:_remove
|    |    | 102         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 103         return xshandle().rm(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_remove
|    |     113             for key in args:
|    |    < xenstore/xstransact.py:remove
|    |   1132                 for dev in t.list(devclass):
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1132                 for dev in t.list(devclass):
|    |    > xenstore/xstransact.py:list
|    |     129         if len(args) == 0:
|    |     136             ret = []
|    |     137             for key in args:
|    |     138                 ret.extend(self._list(key))
|    |    |> xenstore/xstransact.py:_list
|    |    | 117         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    | 118         l = xshandle().ls(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    | 119         if l:
|    |    | 121         return []
|    |    |< xenstore/xstransact.py:_list
|    |     137             for key in args:
|    |     139             return ret
|    |    < xenstore/xstransact.py:list
|    |   1131             for devclass in XendDevices.valid_devices():
|    |   1141             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |   1142                 break
|    |   < XendDomainInfo.py:_releaseDevices
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  1339             if self.image:
|    |  1340                 try:
|    |  1341                     self.image.destroy()
|    |   > image.py:destroy
|    |    180         """Extra cleanup on domain destroy (define in subclass if 
needed)."""
|    |   < image.py:destroy
|    |  1345                 self.image = None
|    |  1347             try:
|    |  1348                 self._removeDom()
|    |   > XendDomainInfo.py:_removeDom
|    |    669         return xstransact.Remove(self.dompath, *args)
|    |    > xenstore/xstransact.py:Remove
|    |     309         complete(path, lambda t: t.remove(*args))
|    |    |> xenstore/xstransact.py:complete
|    |    | 350     while True:
|    |    | 351         t = xstransact(path)
|    |    | > xenstore/xstransact.py:__init__
|    |    |   14         assert path is not None
|    |    |   16         self.in_transaction = False # Set this temporarily -- 
if this
|    |    |   19         self.path = path.rstrip("/")
|    |    |   20         self.transaction = xshandle().transaction_start()
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |   21         self.in_transaction = True
|    |    | < xenstore/xstransact.py:__init__
|    |    | 352         try:
|    |    | 353             result = f(t)
|    |    | > xenstore/xstransact.py:<lambda>
|    |    |  309         complete(path, lambda t: t.remove(*args))
|    |    |  > xenstore/xstransact.py:remove
|    |    |   110         if len(args) == 0:
|    |    |   111             xshandle().rm(self.transaction, self.path)
|    |    |   > xenstore/xsutil.py:xshandle
|    |    |     15     if not xs_handle:
|    |    |     20     return xs_handle
|    |    |   < xenstore/xsutil.py:xshandle
|    |    |  < xenstore/xstransact.py:remove
|    |    | < xenstore/xstransact.py:<lambda>
|    |    | 354             if t.commit():
|    |    | > xenstore/xstransact.py:commit
|    |    |   28         if not self.in_transaction:
|    |    |   30         self.in_transaction = False
|    |    |   31         rc = xshandle().transaction_end(self.transaction, 
False)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    |   32         self.transaction = "0"
|    |    |   33         return rc
|    |    | < xenstore/xstransact.py:commit
|    |    | 355                 return result
|    |    |< xenstore/xstransact.py:complete
|    |    |> xenstore/xstransact.py:__del__
|    |    |  24         if self.in_transaction:
|    |    |< xenstore/xstransact.py:__del__
|    |    < xenstore/xstransact.py:Remove
|    |   < XendDomainInfo.py:_removeDom
|    |  1352             self._stateSet(DOM_STATE_HALTED)
|    |   > XendDomainInfo.py:_stateSet
|    |   1595         self.state_updated.acquire()
|    |   1596         try:
|    |   1597             if self.state != state:
|    |   1598                 self.state = state
|    |   1599                 self.state_updated.notifyAll()
|    |   1601             self.state_updated.release()
|    |   < XendDomainInfo.py:_stateSet
|    |  1354             self.refresh_shutdown_lock.release()
|    |  < XendDomainInfo.py:cleanupDomain
|    |  420             if domid in self.domains:
|    |  421                 del self.domains[domid]
|    | < XendDomain.py:_remove_domain
|    | 390         for domid, dom in self.domains.items():
|    |< XendDomain.py:_refresh
|     137             self.domains_lock.release()
|     138         return 1
|    < XendDomain.py:_on_domains_changed
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomain.py:_on_domains_changed
|     133         self.domains_lock.acquire()
|     134         try:
|     135             self._refresh()
|    |> XendDomain.py:_refresh
|    | 379         running = self._running_domains()
|    | > XendDomain.py:_running_domains
|    |  343         try:
|    |  344             return xc.domain_getinfo()
|    | < XendDomain.py:_running_domains
|    | 380         for dom in running:
|    | 381             domid = dom['domid']
|    | 382             if domid in self.domains and dom['dying'] != 1:
|    | 383                 self.domains[domid].update(dom)
|    | > XendDomainInfo.py:update
|    | 1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    | 1631                   str(self.domid))
|    |  > XendLogging.py:trace
|    |    36         self.log(logging.TRACE, *args, **kwargs)
|    |  < XendLogging.py:trace
|    | 1633         if not info:
|    | 1639         if security.on() and info.has_key('ssidref'):
|    | 1647         if 'ssidref' in info:
|    | 1648             info.pop('ssidref')
|    | 1653         self.info.update(info)
|    | 1654         self.info.validate()
|    |  > XendConfig.py:validate
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    202     ('bootloader',   lambda info: None),
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    203     ('bootloader_args', lambda info: None),            
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    206     ('image',        lambda info: None),
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   765         if 'image' in self and isinstance(self['image'], str):
|    |   767         if 'security' in self and isinstance(self['security'], 
str):
|    |   769         if self['memory'] == 0 and 'mem_kb' in self:
|    |   771         if self['memory'] <= 0:
|    |   775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |   778         if 'mem_kb' in self:
|    |   779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |   782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   793         if 'vif_refs' not in self:
|    |   795         if 'vbd_refs' not in self:
|    |   797         if 'vtpm_refs' not in self:
|    |  < XendConfig.py:validate
|    | 1656         if refresh:
|    | 1657             self.refreshShutdown(info)
|    |  > XendDomainInfo.py:refreshShutdown
|    |   856         restart_reason = None
|    |   858         self.refresh_shutdown_lock.acquire()
|    |   859         try:
|    |   860             if xeninfo is None:
|    |   874             if xeninfo['dying']:
|    |   886             elif xeninfo['crashed']:
|    |   901             elif xeninfo['shutdown']:
|    |   928             elif self.dompath is None:
|    |   936                 if xeninfo['paused']:
|    |   939                     self._stateSet(DOM_STATE_RUNNING)
|    |   > XendDomainInfo.py:_stateSet
|    |   1595         self.state_updated.acquire()
|    |   1596         try:
|    |   1597             if self.state != state:
|    |   1601             self.state_updated.release()
|    |   < XendDomainInfo.py:_stateSet
|    |   941                 if self.shutdownStartTime:
|    |   950             self.refresh_shutdown_lock.release()
|    |   952         if restart_reason:
|    |  < XendDomainInfo.py:refreshShutdown
|    | 1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    | 1660                   str(self.domid), self.info)
|    |  > XendLogging.py:trace
|    |    36         self.log(logging.TRACE, *args, **kwargs)
|    |  < XendLogging.py:trace
|    | < XendDomainInfo.py:update
|    | 380         for dom in running:
|    | 381             domid = dom['domid']
|    | 382             if domid in self.domains and dom['dying'] != 1:
|    | 380         for dom in running:
|    | 389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    | 389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    | 389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    | 390         for domid, dom in self.domains.items():
|    | 391             if domid not in running_domids and domid != DOM0_ID:
|    | 390         for domid, dom in self.domains.items():
|    |< XendDomain.py:_refresh
|     137             self.domains_lock.release()
|     138         return 1
|    < XendDomain.py:_on_domains_changed
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomain.py:_on_domains_changed
|     133         self.domains_lock.acquire()
|     134         try:
|     135             self._refresh()
|    |> XendDomain.py:_refresh
|    | 379         running = self._running_domains()
|    | > XendDomain.py:_running_domains
|    |  343         try:
|    |  344             return xc.domain_getinfo()
|    | < XendDomain.py:_running_domains
|    | 380         for dom in running:
|    | 381             domid = dom['domid']
|    | 382             if domid in self.domains and dom['dying'] != 1:
|    | 383                 self.domains[domid].update(dom)
|    | > XendDomainInfo.py:update
|    | 1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    | 1631                   str(self.domid))
|    |  > XendLogging.py:trace
|    |    36         self.log(logging.TRACE, *args, **kwargs)
|    |  < XendLogging.py:trace
|    | 1633         if not info:
|    | 1639         if security.on() and info.has_key('ssidref'):
|    | 1647         if 'ssidref' in info:
|    | 1648             info.pop('ssidref')
|    | 1653         self.info.update(info)
|    | 1654         self.info.validate()
|    |  > XendConfig.py:validate
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    202     ('bootloader',   lambda info: None),
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    203     ('bootloader_args', lambda info: None),            
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    206     ('image',        lambda info: None),
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   765         if 'image' in self and isinstance(self['image'], str):
|    |   767         if 'security' in self and isinstance(self['security'], 
str):
|    |   769         if self['memory'] == 0 and 'mem_kb' in self:
|    |   771         if self['memory'] <= 0:
|    |   775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |   778         if 'mem_kb' in self:
|    |   779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |   782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   793         if 'vif_refs' not in self:
|    |   795         if 'vbd_refs' not in self:
|    |   797         if 'vtpm_refs' not in self:
|    |  < XendConfig.py:validate
|    | 1656         if refresh:
|    | 1657             self.refreshShutdown(info)
|    |  > XendDomainInfo.py:refreshShutdown
|    |   856         restart_reason = None
|    |   858         self.refresh_shutdown_lock.acquire()
|    |   859         try:
|    |   860             if xeninfo is None:
|    |   874             if xeninfo['dying']:
|    |   886             elif xeninfo['crashed']:
|    |   901             elif xeninfo['shutdown']:
|    |   928             elif self.dompath is None:
|    |   936                 if xeninfo['paused']:
|    |   939                     self._stateSet(DOM_STATE_RUNNING)
|    |   > XendDomainInfo.py:_stateSet
|    |   1595         self.state_updated.acquire()
|    |   1596         try:
|    |   1597             if self.state != state:
|    |   1601             self.state_updated.release()
|    |   < XendDomainInfo.py:_stateSet
|    |   941                 if self.shutdownStartTime:
|    |   950             self.refresh_shutdown_lock.release()
|    |   952         if restart_reason:
|    |  < XendDomainInfo.py:refreshShutdown
|    | 1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    | 1660                   str(self.domid), self.info)
|    |  > XendLogging.py:trace
|    |    36         self.log(logging.TRACE, *args, **kwargs)
|    |  < XendLogging.py:trace
|    | < XendDomainInfo.py:update
|    | 380         for dom in running:
|    | 381             domid = dom['domid']
|    | 382             if domid in self.domains and dom['dying'] != 1:
|    | 380         for dom in running:
|    | 389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    | 389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    | 389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    | 390         for domid, dom in self.domains.items():
|    | 391             if domid not in running_domids and domid != DOM0_ID:
|    | 390         for domid, dom in self.domains.items():
|    |< XendDomain.py:_refresh
|     137             self.domains_lock.release()
|     138         return 1
|    < XendDomain.py:_on_domains_changed
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |    153             while self.running:
|    |    154                 self.server.handle_request()
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |    153             while self.running:
|    |    154                 self.server.handle_request()
|    |    > server/XMLRPCServer.py:domains
|    |      57     if detail < 1:
|    |      60         domains = XendDomain.instance().list_sorted()
|    |    |> XendDomain.py:instance
|    |    |1333     try:
|    |    |1334         inst
|    |    |1338     return inst
|    |    |< XendDomain.py:instance
|    |    |> XendDomain.py:list_sorted
|    |    | 704         doms = self.list()
|    |    | > XendDomain.py:list
||    |       |     16         self.in_transaction = False # Set this 
temporarily -- if this
 |    |    |   19         self.path = path.rstrip("/")
||   679         self.domains_lock.acquire()
 |    |    |  680         try:
  |    |   20         self.transaction = xshandle().transaction_start()
| |    |    |  > xenstore/xsutil.py:xshandle
 |      |    |    15     if not xs_handle:
||    |    |    20     return xs_handle
 |    |    |  < xenstore/xsutil.py:xshandle
   | |  681             self._refresh()
 |    |      | |    > XendDomain.py:_refresh
 |    |    |   379         running = self._running_domains()
|   21         self.in_transaction = True
| |    |    |   < xenstore/xstransact.py:__init__
 |     |    |   > XendDomain.py:_running_domains
 |    |    |   343         try:
||    |    |   344             return xc.domain_getinfo()
    |   352         try:
| |    |    |   353             result = f(t)
 |      |    |   > xenstore/xstransact.py:<lambda>
||    |    |    297         return complete(path, lambda t: t.read(*args))
|     |  < XendDomain.py:_running_domains
 |     |    |    |    380         for dom in running:
 |    |    |    381             domid = dom['domid']
||        |    |    382             if domid in self.domains and dom['dying'] 
!= 1:
> xenstore/xstransact.py:read
|    |    |    383                 self.domains[domid].update(dom)
|    |    |  |    |     59         if len(args) == 0:
 |    |    |      61         if len(args) == 1:
 |    > XendDomainInfo.py:update
|    |    |      62             return self._read(args[0])
| |    |    |      |> xenstore/xstransact.py:_read
 |    |    |    |  44         path = self.prependPath(key)
||    |    |      | > xenstore/xstransact.py:prependPath
 |  |    1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
 |    |    |    | 1631                   str(self.domid))
  |  |      |    |    |  > XendLogging.py:trace
|    |    |    |    36         self.log(logging.TRACE, *args, **kwargs)
||      |    |    283         if self.path:
||      |    |      |   284             return self.path + '/' + key
||  < XendLogging.py:trace
 |      |    |    |  < xenstore/xstransact.py:prependPath
 |    |    |    |  45         try:
||    |    |    |  46             return xshandle().read(self.transaction, path)
 |    |     |    | 1633         if not info:
 |  |    | > xenstore/xsutil.py:xshandle
 |    |    |    |   15     if not xs_handle:
 |    |    |    |   20     return xs_handle
 | |    |    | 1639         if security.on() and info.has_key('ssidref'):
 |      |    |    | 1647         if 'ssidref' in info:
||    |    |    | 1648             info.pop('ssidref')
 |      |    |    | 1653         self.info.update(info)
 |    |    |    | 1654         self.info.validate()
||    |    |    |  > XendConfig.py:validate
 |      | |    |    |   760         for key, default_func in 
DEFAULT_CONFIGURATION:
 |    |    |  < xenstore/xsutil.py:xshandle
  |  |    |   761             if key not in self or self[key] == None:
 |     ||    |    |    760         for key, default_func in 
DEFAULT_CONFIGURATION:
 |  |   < xenstore/xstransact.py:_read
 |    |    |    |< xenstore/xstransact.py:read
||        | |    |  761             if key not in self or self[key] == None:
 |    |    |       760         for key, default_func in DEFAULT_CONFIGURATION:
||      |    |     761             if key not in self or self[key] == None:
 |    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
 |    |    |     761             if key not in self or self[key] == None:
< xenstore/xstransact.py:<lambda>
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    354             if t.commit():
| |     |    |     |    761             if key not in self or self[key] == None:
 |    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
||    |    |     761             if key not in self or self[key] == None:
    > xenstore/xstransact.py:commit
| |    |    |      28         if not self.in_transaction:
   |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |    |   30         self.in_transaction = False
   |    | |    |      |      31         rc = 
xshandle().transaction_end(self.transaction, False)
 |    |    |    |> xenstore/xsutil.py:xshandle
|    |    |    |  15     if not xs_handle:
 761             if key not in self or self[key] == None:
|    |    |    |  20     return xs_handle
|    |    |   |  | 760         for key, default_func in DEFAULT_CONFIGURATION:
 |    |    |    | 761             if key not in self or self[key] == None:
  |    |    |< xenstore/xsutil.py:xshandle
|    |    |    | 760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     762                 self[key] = default_func(self)
|    |    |    |> XendConfig.py:<lambda>
|    |    |    | 202     ('bootloader',   lambda info: None),
|    |    |    |< XendConfig.py:<lambda>
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     762                 self[key] = default_func(self)
|    |    |    |> XendConfig.py:<lambda>
|    |    |    | 203     ('bootloader_args', lambda info: None),            
|    |    |    |< XendConfig.py:<lambda>
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |     761             if key not in self or self[key] == None:
|    |    | |    |    |        760         for key, default_func in 
DEFAULT_CONFIGURATION:
  32         self.transaction = "0"
||    |    |      |    |     761             if key not in self or self[key] == 
None:
 |    |    |    33         return rc
 |    |      |    < xenstore/xstransact.py:commit
 762                 self[key] = default_func(self)
|    |    |    355                 return result
|    |    |    > XendConfig.py:<lambda>
| |    |    |       206     ('image',        lambda info: None),
 | |     |    |     |  < xenstore/xstransact.py:complete
 |    |    |    > xenstore/xstransact.py:__del__
 |    |    |      24         if self.in_transaction:
 |    |    |< XendConfig.py:<lambda>
 |      | < xenstore/xstransact.py:__del__
 |      |     760         for key, default_func in DEFAULT_CONFIGURATION:
||    |    |   761             if key not in self or self[key] == None:
 |     |    |   760         for key, default_func in DEFAULT_CONFIGURATION:
 |    |    |   761             if key not in self or self[key] == None:
|  |  < xenstore/xstransact.py:Read
 |    |    | < XendDomainInfo.py:_readVm
 |  |     |  |   760         for key, default_func in DEFAULT_CONFIGURATION:
 |    |    | 761             if key not in self or self[key] == None:
 |    |    | 760         for key, default_func in DEFAULT_CONFIGURATION:
 |  | 746         current_im = self.info['image']
 |    |    | 747         if (im is not None and
 |    |    | 752         if changed:
 |    |    | 757         return 1
| |    |    |< XendDomainInfo.py:_storeChanged
   | 761             if key not in self or self[key] == None:
| |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
 |    |     761             if key not in self or self[key] == None:
 |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
 |    |     761             if key not in self or self[key] == None:
||    |     760         for key, default_func in DEFAULT_CONFIGURATION:
 |    |     761             if key not in self or self[key] == None:
 |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
 |    |     761             if key not in self or self[key] == None:
 |   67             if not res:
 |      ||         760         for key, default_func in DEFAULT_CONFIGURATION:
  62     while True:
| |      |      63         try:
 ||     |      64             we = xs.read_watch()
    761             if key not in self or self[key] == None:
|    ||    |     760         for key, default_func in DEFAULT_CONFIGURATION:
 |    |     761             if key not in self or self[key] == None:
 |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
 |    |     761             if key not in self or self[key] == None:
 |    |     760         for key, default_func in DEFAULT_CONFIGURATION:
  65             watch = we[1]
|    |     761             if key not in self or self[key] == None:
|    |      66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    |     760         for key, default_func in DEFAULT_CONFIGURATION:
|    |    |> XendDomainInfo.py:_storeChanged
| |    |    | 761             if key not in self or self[key] == None:
 |    |    | 760         for key, default_func in DEFAULT_CONFIGURATION:
 |    |    | 765         if 'image' in self and isinstance(self['image'], str):
 |    |    | 767         if 'security' in self and isinstance(self['security'], 
str):
|    | 734         log.trace("XendDomainInfo.storeChanged");
| |    |    | > XendLogging.py:trace
 |     |  |     | 769         if self['memory'] == 0 and 'mem_kb' in self:
 |    |    |  771         if self['memory'] <= 0:
 |    |    |  775         self['maxmem'] = max(self['memory'], self['maxmem'])
||    |    |   36         self.log(logging.TRACE, *args, **kwargs)
 |    |    | < XendLogging.py:trace
 778         if 'mem_kb' in self:
| |      | |      | 779             self['memory_dynamic_max'] = 
(self['mem_kb'] + 1023)/1024
 |    |  |  736         changed = False
 |    |    | 738         def f(x, y):
 | | 782         for d_uuid, (d_type, d_info) in self['device'].items():
 |      |  |    | 743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
 |  | 787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
 |    |   |    | > XendDomainInfo.py:_readVMDetails
 |    |    | 1485         try:
  |    |    | 1486             return self._gatherVm(*params)
||    |     788             if self[event] not in CONFIG_RESTART_MODES:
 | |     |> XendDomainInfo.py:_gatherVm
 |    |       ||     653         return xstransact.Gather(self.vmpath, *args)
 787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
| |    |    |   > xenstore/xstransact.py:Gather
 |    |    |    333         return complete(path, lambda t: t.gather(*args))
  ||       |    788             if self[event] not in CONFIG_RESTART_MODES:
 |    |    |  |      787         for event in ('on_poweroff', 'on_reboot', 
'on_crash'):
 | |    |   > xenstore/xstransact.py:complete
 |    |      |     350     while True:
 |    |    |    |    | 351         t = xstransact(path)
 |    |    |       |> xenstore/xstransact.py:__init__
||  |         788             if self[event] not in CONFIG_RESTART_MODES:
|   123                 for t in threads:
 | |   |        |       |    ||    14         assert path is not None
 ||   |  787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
 |   |   |      |   |   |  793         if 'vif_refs' not in self:
 |    | |  16         self.in_transaction = False # Set this temporarily -- if 
this
 |        | 125                 runningThreads = len([t for t in threads if 
t.isAlive()])
||        |    |  19         self.path = path.rstrip("/")
  | |      ||  |          |  795         if 'vbd_refs' not in self:
|||      |   |  20         self.transaction = xshandle().transaction_start()
 125                 runningThreads = len([t for t in threads if t.isAlive()])
| |       |   |      |    |    | 797         if 'vtpm_refs' not in self:
||    |    > xenstore/xsutil.py:xshandle
  | |    |     | < XendConfig.py:validate
||       |    |   15     if not xs_handle:
 |   |   |       |    |    |  20     return xs_handle
|1656         if refresh:
| |   |    |    |     121         while runningThreads > 0:
|| < xenstore/xsutil.py:xshandle
   |     |    |1657             self.refreshShutdown(info)
|    |    |    |> XendDomainInfo.py:refreshShutdown
|    |    |    | 856         restart_reason = None
|    |    |    | 858         self.refresh_shutdown_lock.acquire()
|    |    |    | 859         try:
|    |    |    | 860             if xeninfo is None:
| |    |    |        |    |    | 122             try:
||     |  21         self.in_transaction = True
  |   |    |    | 123                 for t in threads:
 |    |    |    | 124                     t.join(1.0)
  ||    | 874             if xeninfo['dying']:
 |    |    |    | 886             elif xeninfo['crashed']:
 |    |    |    | 901             elif xeninfo['shutdown']:
 |  |       | |< xenstore/xstransact.py:__init__
 |   |    | 928             elif self.dompath is None:
 |    |    |     936                 if xeninfo['paused']:
 |    |    |     939                     self._stateSet(DOM_STATE_RUNNING)
 |    |     352         try:
|    |    |    |> XendDomainInfo.py:_stateSet
| |    |    |    |1595         self.state_updated.acquire()
 |    |    |    |1596         try:
 |    |  |     |    |      |1597             if self.state != state:
||    |    |    |1601             self.state_updated.release()
 353             result = f(t)
|    |    |    |< XendDomainInfo.py:_stateSet
|    |    |    | > xenstore/xstransact.py:<lambda>
|    |    |    | 941                 if self.shutdownStartTime:
| |    |    |    | 950             self.refresh_shutdown_lock.release()
   |    |    | 333         return complete(path, lambda t: t.gather(*args))
|    |    |    | 952         if restart_reason:
| |    |    |    | < XendDomainInfo.py:refreshShutdown
 |    |     |  |      | > xenstore/xstransact.py:gather
 |    |  |     |  |  1659         log.trace("XendDomainInfo.update done on 
domain %s: %s",
 |    |    |  | 169         if len(args) and type(args[0]) != tuple:
 |    |    |  |1660                   str(self.domid), self.info)
 |    |    |    | > XendLogging.py:trace
 |  |   171         ret = []
 |  |     |  |    |   36         self.log(logging.TRACE, *args, **kwargs)
 |     |    |    | < XendLogging.py:trace
 | |    |    |    |< XendDomainInfo.py:update
 |    |    |     380         for dom in running:
 |  |    172         for tup in args:
 | |    |    |       173             if len(tup) == 2:
 | |    |    381             domid = dom['domid']
 |    |    |     382             if domid in self.domains and dom['dying'] != 1:
 |    |    |     380         for dom in running:
 |  |       174                 (key, fn) = tup
 | |    |       ||         389         running_domids = [d['domid'] for d in 
running if d['dying'] != 1]
 175                 defval = None
| |    |     |      | |     389         running_domids = [d['domid'] for d in 
running if d['dying'] != 1]
 |    179             val = self._read(key)
 |    |    |    |> xenstore/xstransact.py:_read
 |    |    |    |  44         path = self.prependPath(key)
 | |   |    |    | > xenstore/xstransact.py:prependPath
 |    |    |    |  283         if self.path:
 |    |       389         running_domids = [d['domid'] for d in running if 
d['dying'] != 1]
||      |    |  284             return self.path + '/' + key
 |    |    |    | < xenstore/xstransact.py:prependPath
 | |       |    |    |  45         try:
||    |    |    |  46             return xshandle().read(self.transaction, path)
 |    |    |    |    > xenstore/xsutil.py:xshandle
||   390         for domid, dom in self.domains.items():
 |    |     |    |    |   15     if not xs_handle:
 |    |    |    |   20     return xs_handle
||    |    |    | < xenstore/xsutil.py:xshandle
    |  391             if domid not in running_domids and domid != DOM0_ID:
|    |    |    | 390         for domid, dom in self.domains.items():
| |    |   |    |    |< xenstore/xstransact.py:_read
 |    |    |     185             if val is None:
   |    | |< XendDomain.py:_refresh
 |   |      |   |     188                 val = fn(val)
 |    |    |    189             ret.append(val)
 ||     684             active_domains = self.domains.values()
 |    |      |    |    172         for tup in args:
||      |    |    173             if len(tup) == 2:
 |  685             active_uuids = [d.get_uuid() for d in active_domains]
 |      | |      |     |    174                 (key, fn) = tup
> XendDomainInfo.py:get_uuid
|    |    |     175                 defval = None
| |    |   |    |     179             val = self._read(key)
    | |    |    |    |> xenstore/xstransact.py:_read
 |    |     1678         dom_uuid = self.info.get('uuid')
 |   |   |    |  |    44         path = self.prependPath(key)
 |    |   |1679         if not dom_uuid: # if it doesn't exist, make one up
 |    |  |    | > xenstore/xstransact.py:prependPath
 |    |    |  |        | 1682         return dom_uuid
||   283         if self.path:
 |   |   |     |       |    | | < XendDomainInfo.py:get_uuid
 284             return self.path + '/' + key
| |    |      |  |       |< xenstore/xstransact.py:prependPath
||       | 685             active_uuids = [d.get_uuid() for d in active_domains]
 | |    |        45         try:
 |    | |      |     688             inactive_domains = []
 |   |      46             return xshandle().read(self.transaction, path)
 | |      | |         689             for dom_uuid, dom in 
self.managed_domains.items():
||        | |> xenstore/xsutil.py:xshandle
 |    |    |    |  15     if not xs_handle:
 |    |    |    |  20     return xs_handle
 | |     |    |    |< xenstore/xsutil.py:xshandle
  | 693             return active_domains + inactive_domains
|    |    |     695             self.domains_lock.release()
| |    |    |    < xenstore/xstransact.py:_read
 |    |    |    185             if val is None:
 |  |    |    |    188                 val = fn(val)
 |    |    |    189             ret.append(val)
 |    |    |    172         for tup in args:
 | |    < XendDomain.py:list
 |    |   |    |    173             if len(tup) == 2:
 |    |    |   174                 (key, fn) = tup
 |    |    |  |   705         doms.sort(lambda x, y: cmp(x.getName(), 
y.getName()))
 |    |  175                 defval = None
 |   |     |    |   179             val = self._read(key)
 706         return doms
|    |    | |   > xenstore/xstransact.py:_read
 |    |     |    |     44         path = self.prependPath(key)
 | |   < XendDomain.py:list_sorted
 |    |      ||    |    > xenstore/xstransact.py:prependPath
 |    |    |    283         if self.path:
 |    61         return map(lambda dom: fixup_sxpr(dom.sxpr(not full)), domains)
 |     |    |    284             return self.path + '/' + key
 |    |    |    < xenstore/xstransact.py:prependPath
| |      |    |     45         try:
 | |      > server/XMLRPCServer.py:<lambda>
 | |    |     46             return xshandle().read(self.transaction, path)
 |    |    |     |    > xenstore/xsutil.py:xshandle
 | |     61         return map(lambda dom: fixup_sxpr(dom.sxpr(not full)), 
domains)
 |      |    |      15     if not xs_handle:
||      |    |    |  20     return xs_handle
 |    |    |    |< xenstore/xsutil.py:xshandle
 |    |> XendDomainInfo.py:sxpr
|    |    |    1663         result = self.info.get_sxp(domain = self,
|    | |    |       |   |   1664                                    
ignore_devices = ignore_store)
 |  < xenstore/xstransact.py:_read
 |    |      |  |      | |> XendConfig.py:get_sxp
 |    185             if val is None:
 |      |  |   |     |      683         sxpr = ['domain']
 |    |   188                 val = fn(val)
 |    |     | 688         if domain.getDomid() != None:
 |       |     189             ret.append(val)
||      |     |   |    | 172         for tup in args:
  | |> XendDomainInfo.py:getDomid
 |    |    |     |  |       | 173             if len(tup) == 2:
||   789         return self.domid
 |  |      | |    |        |< XendDomainInfo.py:getDomid
||     174                 (key, fn) = tup
||      |       689             sxpr.append(['domid', domain.getDomid()])
||       |     175                 defval = None
 | |    |    |    | 179             val = self._read(key)
 |    |    |    | > xenstore/xstransact.py:_read
 |  |     |    |    |   44         path = self.prependPath(key)
 |    |    |    |  > xenstore/xstransact.py:prependPath
 ||    |    |    |   283         if self.path:
> XendDomainInfo.py:getDomid
| |      |  |   |    |    |   284             return self.path + '/' + key
 |    |    |    |  < xenstore/xstransact.py:prependPath
 |   |    |    |    |   45         try:
 |    |    |    |   46             return xshandle().read(self.transaction, 
path)
 789         return self.domid
||        |    |    |  > xenstore/xsutil.py:xshandle
||    |    |    |    15     if not xs_handle:
 |      |  |    |    |      20     return xs_handle
 | |  < XendDomainInfo.py:getDomid
 |   |    |    |  < xenstore/xsutil.py:xshandle
   |    |    |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|   |    |    |  |   | 692             if cfg in self:
 |      | |       |     || 693                 if self[cfg] != None:
< xenstore/xstransact.py:_read
|    | |    |    | 694                     sxpr.append([cfg, self[cfg]])
 |      | |      |  |    691         for cfg, typefunc in 
ROUNDTRIPPING_CONFIG_ENTRIES:
 |       |   185             if val is None:
 |  |     692             if cfg in self:
 |   |    |       188                 val = fn(val)
 ||       |  |      693                 if self[cfg] != None:
 |     |   |  189             ret.append(val)
 |    |     694                     sxpr.append([cfg, self[cfg]])
 |   |      | |      |      172         for tup in args:
 |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
 |    |     |    |    |  190         if len(ret) == 1:
 |       |   692             if cfg in self:
 |     ||        192         return ret
 |   |  |    693                 if self[cfg] != None:
 |      |    < xenstore/xstransact.py:gather
 |    |    |  |     |     694                     sxpr.append([cfg, self[cfg]])
< xenstore/xstransact.py:<lambda>
|    | |      |  |   |     354             if t.commit():
 |    | 691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
 |      |   > xenstore/xstransact.py:commit
 |    ||      |     28         if not self.in_transaction:
 |  |      |     692             if cfg in self:
||        30         self.in_transaction = False
 | |    |   |       |  693                 if self[cfg] != None:
 |    31         rc = xshandle().transaction_end(self.transaction, False)
 |     |  |    |      694                     sxpr.append([cfg, self[cfg]])
 |  |     |    |   > xenstore/xsutil.py:xshandle
 |     691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
 |   |    |  |    |        15     if not xs_handle:
 |     692             if cfg in self:
||     |      | |      693                 if self[cfg] != None:
 |     20     return xs_handle
 |      | |       ||         694                     sxpr.append([cfg, 
self[cfg]])
< xenstore/xsutil.py:xshandle
|    |    |     691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |    692             if cfg in self:
|    |    |    693                 if self[cfg] != None:
| |      | |        | |    694                     sxpr.append([cfg, self[cfg]])
 |    |    |    691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
 |   32         self.transaction = "0"
 |      |   |  |     33         return rc
 |    |    692             if cfg in self:
 |  |     |   < xenstore/xstransact.py:commit
 |    | |      |      693                 if self[cfg] != None:
||      355                 return result
 | |      | |   694                     sxpr.append([cfg, self[cfg]])
 |      |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
 |    |    |   692             if cfg in self:
| |    |    |   < xenstore/xstransact.py:complete
 693                 if self[cfg] != None:
|    |    |  > xenstore/xstransact.py:__del__
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |  |   24         if self.in_transaction:
 |    |    |  < xenstore/xstransact.py:__del__
 |    |    | < xenstore/xstransact.py:Gather
 |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |< XendDomainInfo.py:_gatherVm
|    |    | 692             if cfg in self:
|    |    < XendDomainInfo.py:_readVMDetails
|    |     693                 if self[cfg] != None:
|    |    > XendDomainInfo.py:f
|    |     691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |     739             if y is not None and self.info[x[0]] != y:
| |      |    < XendDomainInfo.py:f
 |    |    > XendDomainInfo.py:f
||    |     739             if y is not None and self.info[x[0]] != y:
 |    |    < XendDomainInfo.py:f
    692             if cfg in self:
| |    |     693                 if self[cfg] != None:
 |    |     691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
 |    |     692             if cfg in self:
 |    |     693                 if self[cfg] != None:
||    |     694                     sxpr.append([cfg, self[cfg]])
    > XendDomainInfo.py:f
| |    |     739             if y is not None and self.info[x[0]] != y:
 |    |    < XendDomainInfo.py:f
 |    |    > XendDomainInfo.py:f
 | |      |     739             if y is not None and self.info[x[0]] != y:
 |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
 |   |    < XendDomainInfo.py:f
 |      |  |     692             if cfg in self:
 |    |  745         im = self._readVm('image')
 |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
 |    |     692             if cfg in self:
  |    > XendDomainInfo.py:_readVm
| |    |     644         return xstransact.Read(self.vmpath, *args)
 |    |    |> xenstore/xstransact.py:Read
 |  |   |    | 297         return complete(path, lambda t: t.read(*args))
 |    |    | > xenstore/xstransact.py:complete
 |    |    |  350     while True:
   693                 if self[cfg] != None:
| |    |    |  694                     sxpr.append([cfg, self[cfg]])
 |     |  |      |  691         for cfg, typefunc in 
ROUNDTRIPPING_CONFIG_ENTRIES:
 | |     351         t = xstransact(path)
||     |  692             if cfg in self:
 |      |    |   693                 if self[cfg] != None:
||    |    |   694                     sxpr.append([cfg, self[cfg]])
 |    |    |     691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
 | |    > xenstore/xstransact.py:__init__
 |    |    |    14         assert path is not None
||      |    |    16         self.in_transaction = False # Set this temporarily 
-- if this
 |    |    |    19         self.path = path.rstrip("/")
 |    |    |    20         self.transaction = xshandle().transaction_start()
||    |    |   > xenstore/xsutil.py:xshandle
 |    |    |     15     if not xs_handle:
 |    |    |  692             if cfg in self:
 |    20     return xs_handle
 |    |    |   < xenstore/xsutil.py:xshandle
  |    |    693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |    |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
|    |    |   692             if cfg in self:
|    |    |   693                 if self[cfg] != None:
|    |    |   694                     sxpr.append([cfg, self[cfg]])
|    |  |   |   691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
 |      | |    |   692             if cfg in self:
 |    |    |   693                 if self[cfg] != None:
  |    21         self.in_transaction = True
| |    |    |  < xenstore/xstransact.py:__init__
   ||        ||   694                     sxpr.append([cfg, self[cfg]])
 |    |      |  691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
 | |   |  352         try:
 |    |    |     353             result = f(t)
||    |    |  > xenstore/xstransact.py:<lambda>
 |  692             if cfg in self:
 |    |    |   693                 if self[cfg] != None:
 |    |    |   694                     sxpr.append([cfg, self[cfg]])
 | |      |   297         return complete(path, lambda t: t.read(*args))
 |    |    |   > xenstore/xstransact.py:read
||    |    |     59         if len(args) == 0:
 |    |    |     61         if len(args) == 1:
 |    |    |     62             return self._read(args[0])
 |    |    |    > xenstore/xstransact.py:_read
 | |     | 691         for cfg, typefunc in ROUNDTRIPPING_CONFIG_ENTRIES:
 |    |      |     696         if 'image' in self and self['image'] != None:
 |    | |      44         path = self.prependPath(key)
|    |    |    |> xenstore/xstransact.py:prependPath
   |     698         if 'security' in self and self['security']:
|    |    | |    | 283         if self.path:
 |    |    |      | 284             return self.path + '/' + key
||       |   |    |      | 700         if 'shutdown_reason' in self:
||    |    |    | 701             sxpr.append(['shutdown_reason', 
self['shutdown_reason']])
< xenstore/xstransact.py:prependPath
|    |    |    | 702         if 'cpu_time' in self:
|    |    |      45         try:
| |    |    |      46             return xshandle().read(self.transaction, path)
 |     | |    |      |> xenstore/xsutil.py:xshandle
  ||    |     703             sxpr.append(['cpu_time', self['cpu_time']/1e9])
 |    |     |    |  15     if not xs_handle:
 |    |    |    |  20     return xs_handle
|    |    |  |     |  < xenstore/xsutil.py:xshandle
| 705         sxpr.append(['online_vcpus', self['online_vcpus']])
|    |    |     707         if 'start_time' in self:
|    |    |     712         if domain:
|    |    |    < xenstore/xstransact.py:_read
|    |    |     713             sxpr.append(['status', str(domain.state)])
|    |    |    ||     |    717         sxpr.append(['state', 
self._get_old_state_string()])
 |     |< xenstore/xstransact.py:read
 |    |    |   < xenstore/xstransact.py:<lambda>
 |    |    |     354             if t.commit():
||    |    |   > xenstore/xstransact.py:commit
 |    |    |       28         if not self.in_transaction:
 | > XendConfig.py:_get_old_state_string
 |    |    |    662         state_string = ''
 |  |     |  |     30         self.in_transaction = False
 |    |    |     31         rc = xshandle().transaction_end(self.transaction, 
False)
 |    |    |      > xenstore/xsutil.py:xshandle
||      |    |      15     if not xs_handle:
 |    |    |      20     return xs_handle
 663         for state_name in CONFIG_OLD_DOM_STATES:
| |    |    |     664             on_off = self.get(state_name, 0)
 |    |    |     |    |    < xenstore/xsutil.py:xshandle
  665             if on_off:
|    |    |    666                 state_string += state_name[0]
|    |    |    663         for state_name in CONFIG_OLD_DOM_STATES:
|    |    |    664             on_off = self.get(state_name, 0)
| |      | |    |     32         self.transaction = "0"
 |     |    |   665             if on_off:
 |    |    |    668                 state_string += '-'
 |  |       33         return rc
 |    |    |   < xenstore/xstransact.py:commit
||     |    |   355                 return result
 |    |    |  < xenstore/xstransact.py:complete
  | |    |    |  > xenstore/xstransact.py:__del__
 |  663         for state_name in CONFIG_OLD_DOM_STATES:
 |    |      |   664             on_off = self.get(state_name, 0)
 |    | |    |   665             if on_off:
 |    |    |    |    24         if self.in_transaction:
 668                 state_string += '-'
| |    |    |   663         for state_name in CONFIG_OLD_DOM_STATES:
 |      |    |   664             on_off = self.get(state_name, 0)
||    |    |   665             if on_off:
 |    |    |   668                 state_string += '-'
 |    |    |   663         for state_name in CONFIG_OLD_DOM_STATES:
  |  < xenstore/xstransact.py:__del__
| |    |    | < xenstore/xstransact.py:Read
 |     |  |       | |< XendDomainInfo.py:_readVm
 |    |     746         current_im = self.info['image']
 664             on_off = self.get(state_name, 0)
| |      | |     665             if on_off:
 |     747         if (im is not None and
 |    |     752         if changed:
 |  |     668                 state_string += '-'
 |    |     663         for state_name in CONFIG_OLD_DOM_STATES:
  |     757         return 1
|    |     664             on_off = self.get(state_name, 0)
|    |    < XendDomainInfo.py:_storeChanged
|    |    |    |     67             if not res:
 665             if on_off:
|    |     62     while True:
|    |    668                 state_string += '-'
|    |     63         try:
|    |    663         for state_name in CONFIG_OLD_DOM_STATES:
| |    |    670         return state_string
 |      ||     < XendConfig.py:_get_old_state_string
 |   64             we = xs.read_watch()
   |   718         sxpr.append(['memory_dynamic_max', 
self.get('memory_dynamic_max',
| |    |   719                                                     
self['memory'])])
 |    |   722         if domain:
 |  |    65             watch = we[1]
 |     |   723             if domain.store_mfn:
 |    | |   725             if domain.console_mfn:
 |   66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
 |      | |    > XendDomainInfo.py:_storeChanged
 729         if not ignore_devices:
| |    |    752         return sxpr
 |    |   < XendConfig.py:get_sxp
 |    |  1666         if not ignore_store:
 |    |  1672         return result
||    |  < XendDomainInfo.py:sxpr
 |    |  > server/XMLRPCServer.py:fixup_sxpr
 |    |    33     ret = []
 |    |    34     for k in sexpr:
 734         log.trace("XendDomainInfo.storeChanged");
||     |    35         if type(k) in (types.ListType, types.TupleType):
 |    |     39             ret.append(k)
 |  |    > XendLogging.py:trace
 |  |     |     34     for k in sexpr:
 |    |     35         if type(k) in (types.ListType, types.TupleType):
  36         self.log(logging.TRACE, *args, **kwargs)
| |      | |     < XendLogging.py:trace
 |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |    37                 ret.append(fixup_sxpr(k))
 |    |   > server/XMLRPCServer.py:fixup_sxpr
 |    |     33     ret = []
||    |     34     for k in sexpr:
 |    |     35         if type(k) in (types.ListType, types.TupleType):
 |    |     39             ret.append(k)
 736         changed = False
|    |     34     for k in sexpr:
|    | |    738         def f(x, y):
 |      |     35         if type(k) in (types.ListType, types.TupleType):
||     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
 |      |    > XendDomainInfo.py:_readVMDetails
||      39             ret.append(k)
 |    |   |      34     for k in sexpr:
 |    |      40     return ret
 |    |    < server/XMLRPCServer.py:fixup_sxpr
 |    |     34     for k in sexpr:
1485         try:
|    |     35         if type(k) in (types.ListType, types.TupleType):
| |    |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |     37                 ret.append(fixup_sxpr(k))
 |    |  |    > server/XMLRPCServer.py:fixup_sxpr
 |  1486             return self._gatherVm(*params)
 |      | |      |> XendDomainInfo.py:_gatherVm
 |      33     ret = []
||       |    |  34     for k in sexpr:
 |    |    |  35         if type(k) in (types.ListType, types.TupleType):
||    |    |  39             ret.append(k)
 653         return xstransact.Gather(self.vmpath, *args)
| |    |       || > xenstore/xstransact.py:Gather
 |      | |   34     for k in sexpr:
 |   |    333         return complete(path, lambda t: t.gather(*args))
 |  |   |      |  |   35         if type(k) in (types.ListType, 
types.TupleType):
 |    |    |> xenstore/xstransact.py:complete
 |    |   39             ret.append(k)
 |    |    |    34     for k in sexpr:
 |   |    350     while True:
 |     ||     |    40     return ret
 |   |   351         t = xstransact(path)
 |      | |       ||    < server/XMLRPCServer.py:fixup_sxpr
 | > xenstore/xstransact.py:__init__
 |   |    |    34     for k in sexpr:
  |  |    |      14         assert path is not None
 | |       | |    35         if type(k) in (types.ListType, types.TupleType):
 |      |   |  |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
  16         self.in_transaction = False # Set this temporarily -- if this
| |      |   |    |      37                 ret.append(fixup_sxpr(k))
||    |     19         self.path = path.rstrip("/")
 |     | |     > server/XMLRPCServer.py:fixup_sxpr
 |    |  |     20         self.transaction = xshandle().transaction_start()
 |      |   |   33     ret = []
 |    |      |   |  > xenstore/xsutil.py:xshandle
 |        34     for k in sexpr:
||    |        |      35         if type(k) in (types.ListType, 
types.TupleType):
||        |  15     if not xs_handle:
 |      |  |      39             ret.append(k)
 |    |   |    |         20     return xs_handle
  34     for k in sexpr:
|   |  |   |    |         35         if type(k) in (types.ListType, 
types.TupleType):
 |    |    < xenstore/xsutil.py:xshandle
|    |      39             ret.append(k)
|    |    |     34     for k in sexpr:
|    |    |     40     return ret
|    |    |   < server/XMLRPCServer.py:fixup_sxpr
|    |    |    34     for k in sexpr:
|    |    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |    | |    |    |    34     for k in sexpr:
 |    |  21         self.in_transaction = True
 |    |    |  < xenstore/xstransact.py:__init__
 |     |    35         if type(k) in (types.ListType, types.TupleType):
 |    ||     |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |    |   37                 ret.append(fixup_sxpr(k))
 |    |    |  > server/XMLRPCServer.py:fixup_sxpr
 | |  352         try:
 |     |  |      |   353             result = f(t)
 |    |    |   > xenstore/xstransact.py:<lambda>
||    |    |      333         return complete(path, lambda t: t.gather(*args))
  33     ret = []
||     |    |    > xenstore/xstransact.py:gather
 |    |    |     169         if len(args) and type(args[0]) != tuple:
 |    |    |     171         ret = []
 | |    |     |    |     172         for tup in args:
 |    |    |     173             if len(tup) == 2:
 |   34     for k in sexpr:
   | |    |     174                 (key, fn) = tup
 |    |    |     175                 defval = None
 |    |    |     179             val = self._read(key)
 |    |    |    |> xenstore/xstransact.py:_read
||    |      |    |  44         path = self.prependPath(key)
 |    |    |    | > xenstore/xstransact.py:prependPath
 | |      35         if type(k) in (types.ListType, types.TupleType):
 |      | |    |    |    |    |  283         if self.path:
  39             ret.append(k)
|    |    |    |    |    |    |   34     for k in sexpr:
||   284             return self.path + '/' + key
 |    |    |    | < xenstore/xstransact.py:prependPath
 |  |    |    |   35         if type(k) in (types.ListType, types.TupleType):
 |    |    |      |  39             ret.append(k)
||        | |      | |  45         try:
 |    |    |    |  46             return xshandle().read(self.transaction, path)
   |  34     for k in sexpr:
|    |    |    | > xenstore/xsutil.py:xshandle
| |    |    |    |   15     if not xs_handle:
 |     |    |    |   40     return ret
 |    |    |    | < server/XMLRPCServer.py:fixup_sxpr
||       |    |   20     return xs_handle
 ||        ||       | |    34     for k in sexpr:
 |  |< xenstore/xsutil.py:xshandle
   |    |    |  35         if type(k) in (types.ListType, types.TupleType):
|    |    |      36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |    |      37                 ret.append(fixup_sxpr(k))
|    |    |    < xenstore/xstransact.py:_read
| |    |    |     185             if val is None:
   |    |    |> server/XMLRPCServer.py:fixup_sxpr
|    |    |     188                 val = fn(val)
| |    |    |      33     ret = []
 |    |    |      34     for k in sexpr:
 |  |    |     189             ret.append(val)
 |    |    |     172         for tup in args:
 |    |    |     173             if len(tup) == 2:
 |    |    |     174                 (key, fn) = tup
||      |    |     175                 defval = None
 |    |    |   |   179             val = self._read(key)
 |    |    |    |> xenstore/xstransact.py:_read
 |    |    |      |  44         path = self.prependPath(key)
  35         if type(k) in (types.ListType, types.TupleType):
|    |    |    ||  > xenstore/xstransact.py:prependPath
 |    |    |    |    283         if self.path:
||    |    |    |  284             return self.path + '/' + key
 |    |    |    | < xenstore/xstransact.py:prependPath
   |    |   39             ret.append(k)
|    |    |    |  45         try:
| |    |    |    |  46             return xshandle().read(self.transaction, 
path)
 |    |    |    | > xenstore/xsutil.py:xshandle
 |    |    |    |   15     if not xs_handle:
 |    |    |  34     for k in sexpr:
|    |    | |    |   20     return xs_handle
 |    |    |    | < xenstore/xsutil.py:xshandle
  |    |    |   35         if type(k) in (types.ListType, types.TupleType):
|    |    |    |  39             ret.append(k)
||     |       | |    |  34     for k in sexpr:
 |    |    |      |  40     return ret
||    |      |    |< server/XMLRPCServer.py:fixup_sxpr
 |    |    |      34     for k in sexpr:
 | |< xenstore/xstransact.py:_read
 |    |    |      185             if val is None:
||        | |    |    188                 val = fn(val)
 |    |    |      189             ret.append(val)
  35         if type(k) in (types.ListType, types.TupleType):
|    | |    |       172         for tup in args:
||    |      |    173             if len(tup) == 2:
 |     |    | |      174                 (key, fn) = tup
  36             if len(k) != 2 or k[0] != 'vcpu_avail':
| |    |    |     37                 ret.append(fixup_sxpr(k))
 |    |    |    > server/XMLRPCServer.py:fixup_sxpr
  |  |    |    175                 defval = None
 |    |    |     179             val = self._read(key)
 |    |    |    |> xenstore/xstransact.py:_read
| |    |    |    |  44         path = self.prependPath(key)
  |  |   |    |    | > xenstore/xstransact.py:prependPath
 |    |    |    |  283         if self.path:
 |     33     ret = []
 |   |    |    |  284             return self.path + '/' + key
   |    |    |    | < xenstore/xstransact.py:prependPath
||        ||    |   34     for k in sexpr:
 |    |    |  45         try:
 |    |    |    |  46             return xshandle().read(self.transaction, path)
 |  |      |    |    | > xenstore/xsutil.py:xshandle
 | |     |    |    |   15     if not xs_handle:
 |    |    |    |   20     return xs_handle
 ||   35         if type(k) in (types.ListType, types.TupleType):
 |    |      | |    |    | < xenstore/xsutil.py:xshandle
   |   39             ret.append(k)
|    |    |    |  34     for k in sexpr:
| |    |    |   |    |    |< xenstore/xstransact.py:_read
 |    |    |     185             if val is None:
 |      ||  35         if type(k) in (types.ListType, types.TupleType):
 |    |     188                 val = fn(val)
 |    |    |     189             ret.append(val)
  |    |    |     172         for tup in args:
||    |    |     173             if len(tup) == 2:
 |    |      |    |     174                 (key, fn) = tup
   39             ret.append(k)
| |       |    |     175                 defval = None
||       |       34     for k in sexpr:
||     |     179             val = self._read(key)
 |      ||       |    |> xenstore/xstransact.py:_read
 | |      |    |    40     return ret
 |     | |      44         path = self.prependPath(key)
||     |       | |< server/XMLRPCServer.py:fixup_sxpr
 |    |    | > xenstore/xstransact.py:prependPath
 |    |  |   |  34     for k in sexpr:
 |      |   |  |    283         if self.path:
 |   |   |   |   |    35         if type(k) in (types.ListType, 
types.TupleType):
 |  | 284             return self.path + '/' + key
 |    |    |      | |    |  36             if len(k) != 2 or k[0] != 
'vcpu_avail':
 |    |< xenstore/xstransact.py:prependPath
 |    |   |    |    |      |  37                 ret.append(fixup_sxpr(k))
  45         try:
|    ||        | |    |> server/XMLRPCServer.py:fixup_sxpr
 |   |     |    |  46             return xshandle().read(self.transaction, path)
 |     ||        | |  33     ret = []
 |   | > xenstore/xsutil.py:xshandle
 |   |     |    |   |   |   34     for k in sexpr:
 |    |       |    | |   35         if type(k) in (types.ListType, 
types.TupleType):
  15     if not xs_handle:
|    |    | |      |    | |   20     return xs_handle
 |      |   39             ret.append(k)
 | |      |  |     |     |   34     for k in sexpr:
 | | < xenstore/xsutil.py:xshandle
   |    |    |   35         if type(k) in (types.ListType, types.TupleType):
|    |    |  |      ||    39             ret.append(k)
 |    |   |    |   |< xenstore/xstransact.py:_read
 |    |    |  34     for k in sexpr:
 |    | |     185             if val is None:
 |       |    |     188                 val = fn(val)
||    |        40     return ret
 |    |   |       189             ret.append(val)
||    |     < server/XMLRPCServer.py:fixup_sxpr
 |   |     172         for tup in args:
 |   |       |    |    190         if len(ret) == 1:
| |     34     for k in sexpr:
 |     |    |  |    |     35         if type(k) in (types.ListType, 
types.TupleType):
   192         return ret
|    | |    |       36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    | |      |   < xenstore/xstransact.py:gather
 | |     |    37                 ret.append(fixup_sxpr(k))
 |   |    |    < xenstore/xstransact.py:<lambda>
 |    | |    > server/XMLRPCServer.py:fixup_sxpr
 |  |     |  354             if t.commit():
 |     | |        33     ret = []
||      > xenstore/xstransact.py:commit
 | |    |    |     34     for k in sexpr:
 |   |       28         if not self.in_transaction:
 |   |  |   |     35         if type(k) in (types.ListType, types.TupleType):
 |       |   |  |       39             ret.append(k)
  30         self.in_transaction = False
| |    |     |      | |       34     for k in sexpr:
  31         rc = xshandle().transaction_end(self.transaction, False)
| |      | |    |      |   35         if type(k) in (types.ListType, 
types.TupleType):
 |    |    > xenstore/xsutil.py:xshandle
 |   |      39             ret.append(k)
 |      | |       |      34     for k in sexpr:
||       |       15     if not xs_handle:
||    |      |        20     return xs_handle
  40     return ret
|    |   |  |    |      < xenstore/xsutil.py:xshandle
 |    < server/XMLRPCServer.py:fixup_sxpr
|    |    |    34     for k in sexpr:
|    |    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    | |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |    |    37                 ret.append(fixup_sxpr(k))
 |    |    |   > server/XMLRPCServer.py:fixup_sxpr
|    ||      |    |     33     ret = []
  32         self.transaction = "0"
|    |    |     34     for k in sexpr:
| |    |      |    |     35         if type(k) in (types.ListType, 
types.TupleType):
 | |     33         return rc
 |    |    |     < xenstore/xstransact.py:commit
||       |     39             ret.append(k)
 ||     |    |    34     for k in sexpr:
 |      |    |    35         if type(k) in (types.ListType, types.TupleType):
||      355                 return result
 |    |    | |    < xenstore/xstransact.py:complete
 |    |    |  > xenstore/xstransact.py:__del__
|    39             ret.append(k)
| |    |    |    34     for k in sexpr:
 |    |    |      40     return ret
||       |    24         if self.in_transaction:
 | |    |    |  < xenstore/xstransact.py:__del__
 |    |    | < xenstore/xstransact.py:Gather
 |    |    |< XendDomainInfo.py:_gatherVm
 | |    < server/XMLRPCServer.py:fixup_sxpr
 | |      |   < XendDomainInfo.py:_readVMDetails
 |   34     for k in sexpr:
 |    |     35         if type(k) in (types.ListType, types.TupleType):
  |  |  > XendDomainInfo.py:f
 |    |    739             if y is not None and self.info[x[0]] != y:
 |  |   |     < XendDomainInfo.py:f
 |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |     |  |      37                 ret.append(fixup_sxpr(k))
 |> XendDomainInfo.py:f
 |    |     739             if y is not None and self.info[x[0]] != y:
 |     |    |  > server/XMLRPCServer.py:fixup_sxpr
 |    |      33     ret = []
 |   < XendDomainInfo.py:f
 |  |       34     for k in sexpr:
 |  |   |      35         if type(k) in (types.ListType, types.TupleType):
 |    |      39             ret.append(k)
 |    |      34     for k in sexpr:
 |    |      35         if type(k) in (types.ListType, types.TupleType):
 > XendDomainInfo.py:f
|    |      39             ret.append(k)
|    |     739             if y is not None and self.info[x[0]] != y:
|    |      34     for k in sexpr:
| |      |  |      < XendDomainInfo.py:f
 |     40     return ret
 |    |    | < server/XMLRPCServer.py:fixup_sxpr
 |    |   > XendDomainInfo.py:f
 |     34     for k in sexpr:
 |  |    739             if y is not None and self.info[x[0]] != y:
 |   |     |    35         if type(k) in (types.ListType, types.TupleType):
 |    |   < XendDomainInfo.py:f
 |      36             if len(k) != 2 or k[0] != 'vcpu_avail':
||    745         im = self._readVm('image')
 |      |  |   37                 ret.append(fixup_sxpr(k))
 |    | > XendDomainInfo.py:_readVm
 |      |   > server/XMLRPCServer.py:fixup_sxpr
   644         return xstransact.Read(self.vmpath, *args)
|    ||          33     ret = []
||    |      |  34     for k in sexpr:
 |  |> xenstore/xstransact.py:Read
 |    |      ||     35         if type(k) in (types.ListType, types.TupleType):
 |    | | 297         return complete(path, lambda t: t.read(*args))
 |    |      |  39             ret.append(k)
||    > xenstore/xstransact.py:complete
 |    |    |  350     while True:
||     |    |    |  351         t = xstransact(path)
  34     for k in sexpr:
| |    |    |  > xenstore/xstransact.py:__init__
 |    |    |    14         assert path is not None
  |    |    |    16         self.in_transaction = False # Set this temporarily 
-- if this
||        |    |    19         self.path = path.rstrip("/")
||    |    |    20         self.transaction = xshandle().transaction_start()
 |    |   35         if type(k) in (types.ListType, types.TupleType):
 |      | |    > xenstore/xsutil.py:xshandle
 |  |   |    |     15     if not xs_handle:
 |    |    |     20     return xs_handle
  |   39             ret.append(k)
 |      |    |     34     for k in sexpr:
||     |      < xenstore/xsutil.py:xshandle
|    |     40     return ret
|    |    |  < server/XMLRPCServer.py:fixup_sxpr
|    |    |   34     for k in sexpr:
|    |    |   35         if type(k) in (types.ListType, types.TupleType):
|    |    |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |    |   37                 ret.append(fixup_sxpr(k))
|    |    |    |    |    21         self.in_transaction = True
||    |    |  < xenstore/xstransact.py:__init__
 |    |    |  352         try:
 | > server/XMLRPCServer.py:fixup_sxpr
 |    |    |   33     ret = []
  |    |  353             result = f(t)
|    |    |   34     for k in sexpr:
|    |    |  > xenstore/xstransact.py:<lambda>
| |    |    |   297         return complete(path, lambda t: t.read(*args))
 |    |    |   > xenstore/xstransact.py:read
 |  |   |    |     59         if len(args) == 0:
 |    |    |     61         if len(args) == 1:
 |    |    |     62             return self._read(args[0])
 |  |    35         if type(k) in (types.ListType, types.TupleType):
 |    |    |      39             ret.append(k)
  |    |    |      34     for k in sexpr:
||     |    > xenstore/xstransact.py:_read
 |     |    |      35         if type(k) in (types.ListType, types.TupleType):
 |    |    |      39             ret.append(k)
|    |      44         path = self.prependPath(key)
|    |    |      34     for k in sexpr:
| |    |    |    |  40     return ret
 |    |    |    |< server/XMLRPCServer.py:fixup_sxpr
 |  |    |    |> xenstore/xstransact.py:prependPath
 |    |    |     283         if self.path:
 |  |     |  |      34     for k in sexpr:
 |    |    |      35         if type(k) in (types.ListType, types.TupleType):
   |     284             return self.path + '/' + key
| |    |    |      < xenstore/xstransact.py:prependPath
 |    |    |     45         try:
||    |    |     46             return xshandle().read(self.transaction, path)
 |      | |    |    > xenstore/xsutil.py:xshandle
 |    |    |      15     if not xs_handle:
     36             if len(k) != 2 or k[0] != 'vcpu_avail':
| |    |    |      37                 ret.append(fixup_sxpr(k))
 |    |    |    |> server/XMLRPCServer.py:fixup_sxpr
 |    |    |    |  33     ret = []
 |   |  |     |      20     return xs_handle
 |    |    |    |< xenstore/xsutil.py:xshandle
 |    |  34     for k in sexpr:
|    |    |      35         if type(k) in (types.ListType, types.TupleType):
|    |    |    < xenstore/xstransact.py:_read
|    |    | |      39             ret.append(k)
 |    |    |     34     for k in sexpr:
 |  |     |    |     35         if type(k) in (types.ListType, types.TupleType):
 |    |    |     39             ret.append(k)
 |   < xenstore/xstransact.py:read
| |      | |        ||    < xenstore/xstransact.py:<lambda>
 |    |    |  354             if t.commit():
  34     for k in sexpr:
|    |    |  > xenstore/xstransact.py:commit
| |    |    |    28         if not self.in_transaction:
 |    |    |    30         self.in_transaction = False
  |    |    40     return ret
|    | |      |   |  31         rc = 
xshandle().transaction_end(self.transaction, False)
 |       |  < server/XMLRPCServer.py:fixup_sxpr
|   |  |     > xenstore/xsutil.py:xshandle
 | |    |   |     34     for k in sexpr:
 |    |    |    35         if type(k) in (types.ListType, types.TupleType):
  |    |    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
||       15     if not xs_handle:
 | |    |    37                 ret.append(fixup_sxpr(k))
 |    |      |   > server/XMLRPCServer.py:fixup_sxpr
||     |   |    |       33     ret = []
  20     return xs_handle
| |    |       |  |     |   < xenstore/xsutil.py:xshandle
  34     for k in sexpr:
|    |    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    |    39             ret.append(k)
|    |    |    34     for k in sexpr:
| |    |    |    35         if type(k) in (types.ListType, types.TupleType):
 |     |  |    |   |    39             ret.append(k)
 |    |    |    34     for k in sexpr:
 |    |    |    40     return ret
  32         self.transaction = "0"
| |     |    |    33         return rc
 |    |    |  < xenstore/xstransact.py:commit
 |    |  < server/XMLRPCServer.py:fixup_sxpr
|    |    |  355                 return result
|    |    |  34     for k in sexpr:
|    |    |< xenstore/xstransact.py:complete
|    |    |  35         if type(k) in (types.ListType, types.TupleType):
|    |    |> xenstore/xstransact.py:__del__
| |    |    |  24         if self.in_transaction:
 |    |    |< xenstore/xstransact.py:__del__
 |  |     |   |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |      37                 ret.append(fixup_sxpr(k))
 |    < xenstore/xstransact.py:Read
 | |    |> server/XMLRPCServer.py:fixup_sxpr
 |    |        33     ret = []
||      |      34     for k in sexpr:
 |     |      35         if type(k) in (types.ListType, types.TupleType):
< XendDomainInfo.py:_readVm
|    |      39             ret.append(k)
|    |    746         current_im = self.info['image']
|    |     34     for k in sexpr:
| |    |     35         if type(k) in (types.ListType, types.TupleType):
 |    |     39             ret.append(k)
 |    |     34     for k in sexpr:
 |    |     40     return ret
||    |   < server/XMLRPCServer.py:fixup_sxpr
 |    |    34     for k in sexpr:
 |    |    35         if type(k) in (types.ListType, types.TupleType):
 |    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
 747         if (im is not None and
|    |    37                 ret.append(fixup_sxpr(k))
|    |   752         if changed:
|    |   > server/XMLRPCServer.py:fixup_sxpr
| |    |    757         return 1
 |    |   < XendDomainInfo.py:_storeChanged
 |  |   |    67             if not res:
 |     33     ret = []
 |    |    34     for k in sexpr:
 |    |    35         if type(k) in (types.ListType, types.TupleType):
 | |    62     while True:
 |    |    63         try:
 |    |    64             we = xs.read_watch()
 |    39             ret.append(k)
|    |    65             watch = we[1]
|    |    34     for k in sexpr:
|    | |      66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
 | |    |   35         if type(k) in (types.ListType, types.TupleType):
 |    |     39             ret.append(k)
 |  > XendDomainInfo.py:_storeChanged
 |      | |    734         log.trace("XendDomainInfo.storeChanged");
 |    34     for k in sexpr:
 |    |      40     return ret
 |  |    > XendLogging.py:trace
 |      | |       < server/XMLRPCServer.py:fixup_sxpr
  36         self.log(logging.TRACE, *args, **kwargs)
| |      |  |  < XendLogging.py:trace
 |       34     for k in sexpr:
 |    |    35         if type(k) in (types.ListType, types.TupleType):
||    736         changed = False
 |      | |   738         def f(x, y):
 |     36             if len(k) != 2 or k[0] != 'vcpu_avail':
 | |   743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
 |   |    37                 ret.append(fixup_sxpr(k))
 |    |    > server/XMLRPCServer.py:fixup_sxpr
 |    |      33     ret = []
 ||     > XendDomainInfo.py:_readVMDetails
 |     |      34     for k in sexpr:
| |   |       1485         try:
 |     35         if type(k) in (types.ListType, types.TupleType):
 | |      1486             return self._gatherVm(*params)
 |   |      39             ret.append(k)
 |    |  |     |> XendDomainInfo.py:_gatherVm
 | |  34     for k in sexpr:
 |    |     |  |   35         if type(k) in (types.ListType, types.TupleType):
 |    |  |   |  39             ret.append(k)
 653         return xstransact.Gather(self.vmpath, *args)
| |      |    |  34     for k in sexpr:
 | |    |   |    |  > xenstore/xstransact.py:Gather
  40     return ret
|   |  |   |        |  333         return complete(path, lambda t: 
t.gather(*args))
||     < server/XMLRPCServer.py:fixup_sxpr
||       |  > xenstore/xstransact.py:complete
 | |    |   34     for k in sexpr:
 |   |      |  | 350     while True:
 |    |   35         if type(k) in (types.ListType, types.TupleType):
 |   |       ||     351         t = xstransact(path)
 | |   36             if len(k) != 2 or k[0] != 'vcpu_avail':
 |    |    |   |      37                 ret.append(fixup_sxpr(k))
 |   |   |> xenstore/xstransact.py:__init__
 |     |     | > server/XMLRPCServer.py:fixup_sxpr
 |    |    |     |     33     ret = []
  14         assert path is not None
| |      |  |    |     |     34     for k in sexpr:
 |    |  16         self.in_transaction = False # Set this temporarily -- if 
this
 |       |    |     35         if type(k) in (types.ListType, types.TupleType):
||      19         self.path = path.rstrip("/")
 |      | |    |     39             ret.append(k)
 |     |  |     20         self.transaction = xshandle().transaction_start()
 |    |    |   |       34     for k in sexpr:
 | > xenstore/xsutil.py:xshandle
 |     |  |      |   |     15     if not xs_handle:
 |     35         if type(k) in (types.ListType, types.TupleType):
 |     |  |    |       20     return xs_handle
 |  |      39             ret.append(k)
 |   |    |      |  |      < xenstore/xsutil.py:xshandle
   34     for k in sexpr:
|    |    |     40     return ret
|    |    |   < server/XMLRPCServer.py:fixup_sxpr
|    |    |    34     for k in sexpr:
|    |    |    35         if type(k) in (types.ListType, types.TupleType):
|    |    |    36             if len(k) != 2 or k[0] != 'vcpu_avail':
|    |    |    37                 ret.append(fixup_sxpr(k))
|    |    |   > server/XMLRPCServer.py:fixup_sxpr
|    |    |     21         self.in_transaction = True
| |    |    |   < xenstore/xstransact.py:__init__
 |    |    |   352         try:
 |  |     |  |     33     ret = []
 |    |    |    34     for k in sexpr:
 |    |    |    35         if type(k) in (types.ListType, types.TupleType):
  |   353             result = f(t)
| |    |    |     > xenstore/xstransact.py:<lambda>
 | |    |    |    333         return complete(path, lambda t: t.gather(*args))
 |     |    39             ret.append(k)
 | |    |    > xenstore/xstransact.py:gather
 |     |  |    |     169         if len(args) and type(args[0]) != tuple:
 |    |    |     171         ret = []
  |      34     for k in sexpr:
| |    |    |      35         if type(k) in (types.ListType, types.TupleType):
 |   |    |     172         for tup in args:
 |    |    |     173             if len(tup) == 2:
 |    |    |     174                 (key, fn) = tup
 |    |      39             ret.append(k)
|    |    |  |      |    |      34     for k in sexpr:
 175                 defval = None
| |    |    |     179             val = self._read(key)
 |   |    |      40     return ret
 |    |    |    |< server/XMLRPCServer.py:fixup_sxpr
 |    |  |   |      34     for k in sexpr:
 |     |    |     |> xenstore/xstransact.py:_read
 |    |    |      44         path = self.prependPath(key)
||    |    |      |> xenstore/xstransact.py:prependPath
 |    35         if type(k) in (types.ListType, types.TupleType):
 |    |    |      |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
||       |    | 283         if self.path:
 |    |    |    | 284             return self.path + '/' + key
||        | |      | |  37                 ret.append(fixup_sxpr(k))
 |    |      |    | > server/XMLRPCServer.py:fixup_sxpr
 |    |    |    ||< xenstore/xstransact.py:prependPath
 |    |    |    |  45         try:
  33     ret = []
| |    |    |    |  34     for k in sexpr:
 |      |    |    |  35         if type(k) in (types.ListType, types.TupleType):
||    |    |        |  39             ret.append(k)
||      |    |    |  34     for k in sexpr:
 |    |     ||    |  35         if type(k) in (types.ListType, types.TupleType):
  46             return xshandle().read(self.transaction, path)
|    |    |    |  39             ret.append(k)
|  |    |    |    |   34     for k in sexpr:
 |    |   |  |    |   40     return ret
 |    |    |    | < server/XMLRPCServer.py:fixup_sxpr
  |  |      |  |> xenstore/xsutil.py:xshandle
 |      |  |       |  34     for k in sexpr:
||       |  15     if not xs_handle:
 | |      |    |    |  35         if type(k) in (types.ListType, 
types.TupleType):
 |    |    |    |  36             if len(k) != 2 or k[0] != 'vcpu_avail':
||    |      |  20     return xs_handle
 |  |    |  37                 ret.append(fixup_sxpr(k))
 |    |    |    | > server/XMLRPCServer.py:fixup_sxpr
 |  |      |    |    |   33     ret = []
 |    |    |    |   34     for k in sexpr:
| |      |    |    |   35         if type(k) in (types.ListType, 
types.TupleType):
 |< xenstore/xsutil.py:xshandle
|    |    |    |   39             ret.append(k)
|    |    | |   |    34     for k in sexpr:
 |  |      | |       |     |< xenstore/xstransact.py:_read
||    |    |     185             if val is None:
  35         if type(k) in (types.ListType, types.TupleType):
|    |    |     188                 val = fn(val)
| |    |    |     189             ret.append(val)
 |    |    |     172         for tup in args:
 |  |     |    |     173             if len(tup) == 2:
 |    |    |     174                 (key, fn) = tup
 | |        39             ret.append(k)
 |    | |   |        34     for k in sexpr:
 |    |  |     |   175                 defval = None
 |    |       40     return ret
 |   |  |        |     179             val = self._read(key)
< server/XMLRPCServer.py:fixup_sxpr
| |    |   |    |    |> xenstore/xstransact.py:_read
 |       |    |      44         path = self.prependPath(key)
||       |    |    |> xenstore/xstransact.py:prependPath
   34     for k in sexpr:
|    |   |   |  |        | | 283         if self.path:
 |   |  40     return ret
 |     |    |    | 284             return self.path + '/' + key
 | |      |    |    |< xenstore/xstransact.py:prependPath
 | |      |   |< server/XMLRPCServer.py:fixup_sxpr
 |  |         45         try:
||    |    |     46             return xshandle().read(self.transaction, path)
 |    |    |    > xenstore/xsutil.py:xshandle
 |   |   |    |      15     if not xs_handle:
 |   < server/XMLRPCServer.py:<lambda>
 |      | |      |    < server/XMLRPCServer.py:domains
|      20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomainInfo.py:_storeChanged
|     734         log.trace("XendDomainInfo.storeChanged");
|    |> XendLogging.py:trace
|    |  36         self.log(logging.TRACE, *args, **kwargs)
|    |< XendLogging.py:trace
|     736         changed = False
|     738         def f(x, y):
|     743         map(f, VM_CONFIG_PARAMS, 
self._readVMDetails(VM_CONFIG_PARAMS))
|    |> XendDomainInfo.py:_readVMDetails
|    |1485         try:
|    |1486             return self._gatherVm(*params)
|    | > XendDomainInfo.py:_gatherVm
|    |  653         return xstransact.Gather(self.vmpath, *args)
|    |  > xenstore/xstransact.py:Gather
|    |   333         return complete(path, lambda t: t.gather(*args))
|    |   > xenstore/xstransact.py:complete
|    |    350     while True:
|    |    351         t = xstransact(path)
|    |    > xenstore/xstransact.py:__init__
|    |      14         assert path is not None
|    |      16         self.in_transaction = False # Set this temporarily -- if 
this
|    |      19         self.path = path.rstrip("/")
|    |      20         self.transaction = xshandle().transaction_start()
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      21         self.in_transaction = True
|    |    < xenstore/xstransact.py:__init__
|    |    352         try:
|    |    353             result = f(t)
|    |    > xenstore/xstransact.py:<lambda>
|    |     333         return complete(path, lambda t: t.gather(*args))
|    |    |> xenstore/xstransact.py:gather
|    |    | 169         if len(args) and type(args[0]) != tuple:
|    |    | 171         ret = []
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 173             if len(tup) == 2:
|    |    | 174                 (key, fn) = tup
|    |    | 175                 defval = None
|    |    | 179             val = self._read(key)
|    |    | > xenstore/xstransact.py:_read
|    |    |   44         path = self.prependPath(key)
|    |    |  > xenstore/xstransact.py:prependPath
|    |    |   283         if self.path:
|    |    |   284             return self.path + '/' + key
|    |    |  < xenstore/xstransact.py:prependPath
|    |    |   45         try:
|    |    |   46             return xshandle().read(self.transaction, path)
|    |    |  > xenstore/xsutil.py:xshandle
|    |    |    15     if not xs_handle:
|    |    |    20     return xs_handle
|    |    |  < xenstore/xsutil.py:xshandle
|    |    | < xenstore/xstransact.py:_read
|    |    | 185             if val is None:
|    |    | 188                 val = fn(val)
|    |    | 189             ret.append(val)
|    |    | 172         for tup in args:
|    |    | 190         if len(ret) == 1:
|    |    | 192         return ret
|    |    |< xenstore/xstransact.py:gather
|    |    < xenstore/xstransact.py:<lambda>
|    |    354             if t.commit():
|    |    > xenstore/xstransact.py:commit
|    |      28         if not self.in_transaction:
|    |      30         self.in_transaction = False
|    |      31         rc = xshandle().transaction_end(self.transaction, False)
|    |    |> xenstore/xsutil.py:xshandle
|    |    |  15     if not xs_handle:
|    |    |  20     return xs_handle
|    |    |< xenstore/xsutil.py:xshandle
|    |      32         self.transaction = "0"
|    |      33         return rc
|    |    < xenstore/xstransact.py:commit
|    |    355                 return result
|    |   < xenstore/xstransact.py:complete
|    |   > xenstore/xstransact.py:__del__
|    |     24         if self.in_transaction:
|    |   < xenstore/xstransact.py:__del__
|    |  < xenstore/xstransact.py:Gather
|    | < XendDomainInfo.py:_gatherVm
|    |< XendDomainInfo.py:_readVMDetails
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|    |> XendDomainInfo.py:f
|    | 739             if y is not None and self.info[x[0]] != y:
|    |< XendDomainInfo.py:f
|     745         im = self._readVm('image')
|    |> XendDomainInfo.py:_readVm
|    | 644         return xstransact.Read(self.vmpath, *args)
|    | > xenstore/xstransact.py:Read
|    |  297         return complete(path, lambda t: t.read(*args))
|    |  > xenstore/xstransact.py:complete
|    |   350     while True:
|    |   351         t = xstransact(path)
|    |   > xenstore/xstransact.py:__init__
|    |     14         assert path is not None
|    |     16         self.in_transaction = False # Set this temporarily -- if 
this
|    |     19         self.path = path.rstrip("/")
|    |     20         self.transaction = xshandle().transaction_start()
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     21         self.in_transaction = True
|    |   < xenstore/xstransact.py:__init__
|    |   352         try:
|    |   353             result = f(t)
|    |   > xenstore/xstransact.py:<lambda>
|    |    297         return complete(path, lambda t: t.read(*args))
|    |    > xenstore/xstransact.py:read
|    |      59         if len(args) == 0:
|    |      61         if len(args) == 1:
|    |      62             return self._read(args[0])
|    |    |> xenstore/xstransact.py:_read
|    |    |  44         path = self.prependPath(key)
|    |    | > xenstore/xstransact.py:prependPath
|    |    |  283         if self.path:
|    |    |  284             return self.path + '/' + key
|    |    | < xenstore/xstransact.py:prependPath
|    |    |  45         try:
|    |    |  46             return xshandle().read(self.transaction, path)
|    |    | > xenstore/xsutil.py:xshandle
|    |    |   15     if not xs_handle:
|    |    |   20     return xs_handle
|    |    | < xenstore/xsutil.py:xshandle
|    |    |< xenstore/xstransact.py:_read
|    |    < xenstore/xstransact.py:read
|    |   < xenstore/xstransact.py:<lambda>
|    |   354             if t.commit():
|    |   > xenstore/xstransact.py:commit
|    |     28         if not self.in_transaction:
|    |     30         self.in_transaction = False
|    |     31         rc = xshandle().transaction_end(self.transaction, False)
|    |    > xenstore/xsutil.py:xshandle
|    |      15     if not xs_handle:
|    |      20     return xs_handle
|    |    < xenstore/xsutil.py:xshandle
|    |     32         self.transaction = "0"
|    |     33         return rc
|    |   < xenstore/xstransact.py:commit
|    |   355                 return result
|    |  < xenstore/xstransact.py:complete
|    |  > xenstore/xstransact.py:__del__
|    |    24         if self.in_transaction:
|    |  < xenstore/xstransact.py:__del__
|    | < xenstore/xstransact.py:Read
|    |< XendDomainInfo.py:_readVm
|     746         current_im = self.info['image']
|     747         if (im is not None and
|     752         if changed:
|     757         return 1
|    < XendDomainInfo.py:_storeChanged
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|     65             watch = we[1]
|     66             res = watch.fn(we[0], *watch.args, **watch.kwargs)
|    > XendDomain.py:_on_domains_changed
|     133         self.domains_lock.acquire()
|     134         try:
|     135             self._refresh()
|    |> XendDomain.py:_refresh
|    | 379         running = self._running_domains()
|    | > XendDomain.py:_running_domains
|    |  343         try:
|    |  344             return xc.domain_getinfo()
|    | < XendDomain.py:_running_domains
|    | 380         for dom in running:
|    | 381             domid = dom['domid']
|    | 382             if domid in self.domains and dom['dying'] != 1:
|    | 383                 self.domains[domid].update(dom)
|    | > XendDomainInfo.py:update
|    | 1630         log.trace("XendDomainInfo.update(%s) on domain %s", info,
|    | 1631                   str(self.domid))
|    |  > XendLogging.py:trace
|    |    36         self.log(logging.TRACE, *args, **kwargs)
|    |  < XendLogging.py:trace
|    | 1633         if not info:
|    | 1639         if security.on() and info.has_key('ssidref'):
|    | 1647         if 'ssidref' in info:
|    | 1648             info.pop('ssidref')
|    | 1653         self.info.update(info)
|    | 1654         self.info.validate()
|    |  > XendConfig.py:validate
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    202     ('bootloader',   lambda info: None),
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    203     ('bootloader_args', lambda info: None),            
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   762                 self[key] = default_func(self)
|    |   > XendConfig.py:<lambda>
|    |    206     ('image',        lambda info: None),
|    |   < XendConfig.py:<lambda>
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   761             if key not in self or self[key] == None:
|    |   760         for key, default_func in DEFAULT_CONFIGURATION:
|    |   765         if 'image' in self and isinstance(self['image'], str):
|    |   767         if 'security' in self and isinstance(self['security'], 
str):
|    |   769         if self['memory'] == 0 and 'mem_kb' in self:
|    |   771         if self['memory'] <= 0:
|    |   775         self['maxmem'] = max(self['memory'], self['maxmem'])
|    |   778         if 'mem_kb' in self:
|    |   779             self['memory_dynamic_max'] = (self['mem_kb'] + 
1023)/1024
|    |   782         for d_uuid, (d_type, d_info) in self['device'].items():
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   788             if self[event] not in CONFIG_RESTART_MODES:
|    |   787         for event in ('on_poweroff', 'on_reboot', 'on_crash'):
|    |   793         if 'vif_refs' not in self:
|    |   795         if 'vbd_refs' not in self:
|    |   797         if 'vtpm_refs' not in self:
|    |  < XendConfig.py:validate
|    | 1656         if refresh:
|    | 1657             self.refreshShutdown(info)
|    |  > XendDomainInfo.py:refreshShutdown
|    |   856         restart_reason = None
|    |   858         self.refresh_shutdown_lock.acquire()
|    |   859         try:
|    |   860             if xeninfo is None:
|    |   874             if xeninfo['dying']:
|    |   886             elif xeninfo['crashed']:
|    |   901             elif xeninfo['shutdown']:
|    |   928             elif self.dompath is None:
|    |   936                 if xeninfo['paused']:
|    |   939                     self._stateSet(DOM_STATE_RUNNING)
|    |   > XendDomainInfo.py:_stateSet
|    |   1595         self.state_updated.acquire()
|    |   1596         try:
|    |   1597             if self.state != state:
|    |   1601             self.state_updated.release()
|    |   < XendDomainInfo.py:_stateSet
|    |   941                 if self.shutdownStartTime:
|    |   950             self.refresh_shutdown_lock.release()
|    |   952         if restart_reason:
|    |  < XendDomainInfo.py:refreshShutdown
|    | 1659         log.trace("XendDomainInfo.update done on domain %s: %s",
|    | 1660                   str(self.domid), self.info)
|    |  > XendLogging.py:trace
|    |    36         self.log(logging.TRACE, *args, **kwargs)
|    |  < XendLogging.py:trace
|    | < XendDomainInfo.py:update
|    | 380         for dom in running:
|    | 381             domid = dom['domid']
|    | 382             if domid in self.domains and dom['dying'] != 1:
|    | 380         for dom in running:
|    | 389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    | 389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    | 389         running_domids = [d['domid'] for d in running if d['dying'] 
!= 1]
|    | 390         for domid, dom in self.domains.items():
|    | 391             if domid not in running_domids and domid != DOM0_ID:
|    | 390         for domid, dom in self.domains.items():
|    |< XendDomain.py:_refresh
|     137             self.domains_lock.release()
|     138         return 1
|    < XendDomain.py:_on_domains_changed
|     67             if not res:
|     62     while True:
|     63         try:
|     64             we = xs.read_watch()
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    153             while self.running:
|    154                 self.server.handle_request()
|    123                 for t in threads:
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|    121         while runningThreads > 0:
|    122             try:
|    123                 for t in threads:
|    124                     t.join(1.0)
|    > server/SrvServer.py:cleanup
|      70         log.debug("SrvServer.cleanup()")
|      71         for server in self.servers:
|      72             try:
|      73                 server.shutdown()
|    |> server/XMLRPCServer.py:shutdown
|    | 162         self.running = False
|    | 163         self.ready = False
|    |< server/XMLRPCServer.py:shutdown
|      71         for server in self.servers:
|    < server/SrvServer.py:cleanup
|    153             while self.running:
|    156             self.cleanup()
|    > server/XMLRPCServer.py:cleanup
|     159         log.debug("XMLRPCServer.cleanup()")
|    < server/XMLRPCServer.py:cleanup
|   < server/XMLRPCServer.py:run
|   123                 for t in threads:
|   125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|   125                 runningThreads = len([t for t in threads if 
t.isAlive()])
|   121         while runningThreads > 0:
|  < server/SrvServer.py:start
|  311             del servers
| < server/SrvDaemon.py:run
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel

 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.