WARNING - OLD ARCHIVES

This is an archived copy of the Xen.org mailing list, which we have preserved to ensure that existing links to archives are not broken. The live archive, which contains the latest emails, can be found at http://lists.xen.org/
   
 
 
Xen 
 
Home Products Support Community News
 
   
 

xen-devel

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

To: Ewan Mellor <ewan@xxxxxxxxxxxxx>
Subject: Re: [Xen-devel] domain reboots broken (and suspend too)
From: Chris <hap10@xxxxxxxxxxxxxx>
Date: Fri, 17 Nov 2006 17:12:43 -0500
Cc: xen-devel@xxxxxxxxxxxxxxxxxxx, Alex Williamson <alex.williamson@xxxxxx>
Delivery-date: Mon, 20 Nov 2006 01:38:59 -0800
Envelope-to: www-data@xxxxxxxxxxxxxxxxxx
In-reply-to: <20061117011953.GB28584@xxxxxxxxxxxxxxxxxxxxxx>
List-help: <mailto:xen-devel-request@lists.xensource.com?subject=help>
List-id: Xen developer discussion <xen-devel.lists.xensource.com>
List-post: <mailto:xen-devel@lists.xensource.com>
List-subscribe: <http://lists.xensource.com/cgi-bin/mailman/listinfo/xen-devel>, <mailto:xen-devel-request@lists.xensource.com?subject=subscribe>
List-unsubscribe: <http://lists.xensource.com/cgi-bin/mailman/listinfo/xen-devel>, <mailto:xen-devel-request@lists.xensource.com?subject=unsubscribe>
References: <1163710300.5529.35.camel@lappy> <455CDD17.8040900@xxxxxxxxxxxxxx> <20061117011953.GB28584@xxxxxxxxxxxxxxxxxxxxxx>
Sender: xen-devel-bounces@xxxxxxxxxxxxxxxxxxx
User-agent: Thunderbird 1.5.0.8 (Macintosh/20061025)
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
<Prev in Thread] Current Thread [Next in Thread>