try:
self._constructDomain()
self._storeVmDetails()
- self._createDevices()
self._createChannels()
+ self._createDevices()
self._storeDomDetails()
self._endRestore()
except:
def storeVm(self, *args):
return xstransact.Store(self.vmpath, *args)
-
- def _readVmTxn(self, transaction, *args):
- paths = map(lambda x: self.vmpath + "/" + x, args)
- return transaction.read(*paths)
-
- def _writeVmTxn(self, transaction, *args):
- paths = map(lambda x: self.vmpath + "/" + x, args)
- return transaction.write(*paths)
-
- def _removeVmTxn(self, transaction, *args):
- paths = map(lambda x: self.vmpath + "/" + x, args)
- return transaction.remove(*paths)
-
- def _gatherVmTxn(self, transaction, *args):
- paths = map(lambda x: self.vmpath + "/" + x, args)
- return transaction.gather(paths)
-
- def storeVmTxn(self, transaction, *args):
- paths = map(lambda x: self.vmpath + "/" + x, args)
- return transaction.store(*paths)
-
#
# Function to update xenstore /dom/*
#
def _recreateDomFunc(self, t):
t.remove()
t.mkdir()
- t.set_permissions({'dom' : self.domid})
+ t.set_permissions({'dom' : self.domid, 'read' : True})
t.write('vm', self.vmpath)
+ for i in [ 'device', 'control', 'error' ]:
+ t.mkdir(i)
+ t.set_permissions(i, {'dom' : self.domid})
def _storeDomDetails(self):
to_store = {
paths = self._prepare_phantom_paths()
- self._cleanupVm()
if self.dompath is not None:
self.destroyDomain()
self._cleanup_phantom_devs(paths)
+ self._cleanupVm()
if "transient" in self.info["other_config"] \
and bool(self.info["other_config"]["transient"]):
self._writeVm(to_store)
self._setVmPermissions()
-
def _setVmPermissions(self):
"""Allow the guest domain to read its UUID. We don't allow it to
access any other entry, for security."""
log.warn("".join(traceback.format_stack()))
return self._stateGet()
else:
- raise AttributeError()
+ raise AttributeError(name)
def __setattr__(self, name, value):
if name == "state":
ignore_devices = ignore_store,
legacy_only = legacy_only)
- #if not ignore_store and self.dompath:
- # vnc_port = self.readDom('console/vnc-port')
- # if vnc_port is not None:
- # result.append(['device',
- # ['console', ['vnc-port', str(vnc_port)]]])
-
return result
# Xen API
if not config.has_key('device'):
devid = config.get('id')
if devid != None:
- config['device'] = 'eth%d' % devid
+ config['device'] = 'eth%s' % devid
else:
config['device'] = ''
log.debug(
'DevController: still waiting to write device entries.')
+ devpath = self.devicePath(devid)
+
t.remove(frontpath)
t.remove(backpath)
+ t.remove(devpath)
t.mkdir(backpath)
t.set_permissions(backpath,
t.write2(frontpath, front)
t.write2(backpath, back)
+ t.mkdir(devpath)
+ t.write2(devpath, {
+ 'backend' : backpath,
+ 'backend-id' : "%i" % backdom,
+ 'frontend' : frontpath,
+ 'frontend-id' : "%i" % self.vm.getDomid()
+ })
+
if t.commit():
return devid
if force:
frontpath = self.frontendPath(dev)
- backpath = xstransact.Read(frontpath, "backend")
+ backpath = self.readVm(dev, "backend")
if backpath:
xstransact.Remove(backpath)
xstransact.Remove(frontpath)
+ # xstransact.Remove(self.devicePath()) ?? Below is the same ?
self.vm._removeVm("device/%s/%d" % (self.deviceClass, dev))
def configurations(self, transaction = None):
@return: dict
"""
if transaction is None:
- backdomid = xstransact.Read(self.frontendPath(devid), "backend-id")
+ backdomid = xstransact.Read(self.devicePath(devid), "backend-id")
else:
- backdomid = transaction.read(self.frontendPath(devid) + "/backend-id")
+ backdomid = transaction.read(self.devicePath(devid) + "/backend-id")
+
if backdomid is None:
raise VmError("Device %s not connected" % devid)
return result
+ def readVm(self, devid, *args):
+ devpath = self.devicePath(devid)
+ if devpath:
+ return xstransact.Read(devpath, *args)
+ else:
+ raise VmError("Device config %s not found" % devid)
+
def readBackend(self, devid, *args):
- frontpath = self.frontendPath(devid)
- backpath = xstransact.Read(frontpath, "backend")
+ backpath = self.readVm(devid, "backend")
if backpath:
return xstransact.Read(backpath, *args)
else:
raise VmError("Device %s not connected" % devid)
def readBackendTxn(self, transaction, devid, *args):
- frontpath = self.frontendPath(devid)
- backpath = transaction.read(frontpath + "/backend")
+ backpath = self.readVm(devid, "backend")
if backpath:
paths = map(lambda x: backpath + "/" + x, args)
return transaction.read(*paths)
"""@return The IDs of each of the devices currently configured for
this instance's deviceClass.
"""
- fe = self.backendRoot()
+ fe = self.deviceRoot()
if transaction:
return map(lambda x: int(x.split('/')[-1]), transaction.list(fe))
def writeBackend(self, devid, *args):
- frontpath = self.frontendPath(devid)
- backpath = xstransact.Read(frontpath, "backend")
+ backpath = self.readVm(devid, "backend")
if backpath:
xstransact.Write(backpath, *args)
def waitForBackend(self, devid):
-
frontpath = self.frontendPath(devid)
- # lookup a phantom
+ # lookup a phantom
phantomPath = xstransact.Read(frontpath, 'phantom_vbd')
if phantomPath is not None:
log.debug("Waiting for %s's phantom %s.", devid, phantomPath)
if result['status'] != 'Connected':
return (result['status'], err)
- backpath = xstransact.Read(frontpath, "backend")
+ backpath = self.readVm(devid, "backend")
if backpath:
def frontendRoot(self):
return "%s/device/%s" % (self.vm.getDomainPath(), self.deviceClass)
- def backendRoot(self):
- """Construct backend root path assuming backend is domain 0."""
- from xen.xend.XendDomain import DOM0_ID
- from xen.xend.xenstore.xsutil import GetDomainPath
- return "%s/backend/%s/%s" % (GetDomainPath(DOM0_ID),
- self.deviceClass, self.vm.getDomid())
-
def frontendMiscPath(self):
return "%s/device-misc/%s" % (self.vm.getDomainPath(),
self.deviceClass)
+ def deviceRoot(self):
+ """Return the /vm/device. Because backendRoot assumes the
+ backend domain is 0"""
+ return "%s/device/%s" % (self.vm.vmpath, self.deviceClass)
+
+ def devicePath(self, devid):
+ """Return the /device entry of the given VM. We use it to store
+ backend/frontend locations"""
+ return "%s/device/%s/%s" % (self.vm.vmpath,
+ self.deviceClass, devid)
def hotplugStatusCallback(statusPath, ev, result):
log.debug("hotplugStatusCallback %s.", statusPath)
if sec_lab:
back['security_label'] = sec_lab
- config_path = "device/%s/%d/" % (self.deviceClass, devid)
- for x in back:
- self.vm._writeVm(config_path + x, back[x])
-
back['handle'] = "%i" % devid
back['script'] = os.path.join(xoptions.network_script_dir, script)
if rate:
result = DevController.getDeviceConfiguration(self, devid, transaction)
- config_path = "device/%s/%d/" % (self.deviceClass, devid)
- devinfo = ()
for x in ( 'script', 'ip', 'bridge', 'mac',
'type', 'vifname', 'rate', 'uuid', 'model', 'accel',
'security_label'):
if transaction is None:
- y = self.vm._readVm(config_path + x)
+ y = self.readBackend(devid, x)
else:
- y = self.vm._readVmTxn(transaction, config_path + x)
- devinfo += (y,)
- (script, ip, bridge, mac, typ, vifname, rate, uuid,
- model, accel, security_label) = devinfo
-
- if script:
- result['script'] = script
- if ip:
- result['ip'] = ip
- if bridge:
- result['bridge'] = bridge
- if mac:
- result['mac'] = mac
- if typ:
- result['type'] = typ
- if vifname:
- result['vifname'] = vifname
- if rate:
- result['rate'] = rate
- if uuid:
- result['uuid'] = uuid
- if model:
- result['model'] = model
- if accel:
- result['accel'] = accel
- if security_label:
- result['security_label'] = security_label
+ y = self.readBackendTxn(transaction, devid, x)
+ if y:
+ result[x] = y
return result
projects / people / vhanquez / xen.git / commitdiff