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
|
Home