def run(driver, driver_info):
"""Convenience method to run command on the given driver"""
cmd = SRCommand(driver_info)
try:
cmd.parse()
cmd.run_statics()
sr = driver(cmd, cmd.sr_uuid)
sr.direct = True
ret = cmd.run(sr)
if ret == None:
print util.return_nil()
else:
print ret
except Exception, e:
try:
util.logException(driver_info['name'])
except KeyError:
util.SMlog('driver_info does not contain a \'name\' key.')
except:
pass
# If exception is of type SR.SRException,
# pass to xapi, else re-raise.
if isinstance(e, SR.SRException):
print e.toxml()
else:
raise
def attach_from_config(self, sr_uuid, vdi_uuid):
util.SMlog("RBDVDI.attach_from_config")
self.sr.attach(sr_uuid)
try:
vdi_name = "%s%s" % (cephutils.VDI_PREFIX, vdi_uuid)
dev_name = "%s/%s" % (self.sr.SR_ROOT, vdi_name)
self.path = self.sr._get_path(vdi_uuid)
if self.mode == "kernel":
util.pread2([
"rbd", "map", vdi_name, "--pool", self.sr.CEPH_POOL_NAME,
"--name", self.sr.CEPH_USER
])
elif self.mode == "fuse":
pass
elif self.mode == "nbd":
cmdout = util.pread2([
"rbd-nbd", "--nbds_max",
str(cephutils.NBDS_MAX), "map",
"%s/%s" % (self.sr.CEPH_POOL_NAME, vdi_name), "--name",
self.sr.CEPH_USER
]).rstrip('\n')
util.pread2(["ln", "-s", cmdout, dev_name])
return VDI.VDI.attach(self, sr_uuid, vdi_uuid)
except:
util.logException("RBDVDI.attach_from_config")
raise xs_errors.XenError('SRUnavailable', \
opterr='Unable to attach the heartbeat disk')
def pixmapFromSvg(self, pmapSize=None, withBorders=None):
"""returns a pixmap with default size as given in SVG and optional borders/shadows"""
if withBorders is None:
withBorders = Preferences.showShadows
if withBorders:
wantSize = self.tileset.tileSize.toSize()
else:
wantSize = self.tileset.faceSize.toSize()
if not pmapSize:
pmapSize = wantSize
result = QPixmap(pmapSize)
result.fill(Qt.transparent)
painter = QPainter(result)
if not painter.isActive():
logException('painter is not active. Wanted size: %s' % str(pmapSize))
try:
xScale = float(pmapSize.width()) / wantSize.width()
yScale = float(pmapSize.height()) / wantSize.height()
except ZeroDivisionError:
xScale = 1
yScale = 1
if not withBorders:
painter.scale(*self.tileset.tileFaceRelation())
painter.translate(-self.facePos())
renderer = self.tileset.renderer()
renderer.render(painter, self.elementId())
painter.resetTransform()
self._drawDarkness(painter)
if self.showFace():
faceSize = self.tileset.faceSize.toSize()
faceSize = QSize(faceSize.width() * xScale, faceSize.height() * yScale)
painter.translate(self.facePos())
renderer.render(painter, self.tileset.svgName[self.tile.element.lower()],
QRectF(QPointF(), QSizeF(faceSize)))
return result
def run(driver, driver_info):
"""Convenience method to run command on the given driver"""
cmd = SRCommand(driver_info)
try:
cmd.parse()
cmd.run_statics()
sr = driver(cmd, cmd.sr_uuid)
sr.direct = True
ret = cmd.run(sr)
if ret == None:
print util.return_nil()
else:
print ret
except (Exception, SR.SRException) as e:
try:
util.logException(driver_info['name'])
except KeyError:
util.SMlog('driver_info does not contain a \'name\' key.')
except:
pass
# If exception is of type SR.SRException, pass to Xapi.
# If generic python Exception, print a generic xmlrpclib
# dump and pass to XAPI.
if isinstance(e, SR.SRException):
print e.toxml()
else:
print xmlrpclib.dumps(xmlrpclib.Fault(1200, str(e)), "", True)
sys.exit(0)
def mount(self, mountpoint=None):
mountpoint = self.makeMountPoint(mountpoint)
new_env, domain = cifutils.getCIFCredentials(self.dconf, self.session)
options = self.getMountOptions(domain)
if options:
options = ",".join(str(x) for x in options if x)
try:
util.ioretry(lambda:
util.pread(["mount.cifs", self.remoteserver,
mountpoint, "-o", options], new_env=new_env),
errlist=[errno.EPIPE, errno.EIO],
maxretry=2, nofail=True)
except util.CommandException as inst:
raise SMBException("mount failed with return code %d" % inst.code)
# Sanity check to ensure that the user has at least RO access to the
# mounted share. Windows sharing and security settings can be tricky.
try:
util.listdir(mountpoint)
except util.CommandException:
try:
self.unmount(mountpoint, True)
except SMBException:
util.logException('SMBSR.unmount()')
raise SMBException("Permission denied. "
"Please check user privileges.")
def create(self, sr_uuid, size):
self.__check_license()
if self.checkmount():
raise xs_errors.XenError('SMBAttached')
try:
self.mount()
except SMBException as exc:
try:
os.rmdir(self.mountpoint)
except:
pass
raise xs_errors.XenError('SMBMount', opterr=exc.errstr)
if util.ioretry(lambda: util.pathexists(self.linkpath)):
if len(util.ioretry(lambda: util.listdir(self.linkpath))) != 0:
self.detach(sr_uuid)
raise xs_errors.XenError('SRExists')
else:
try:
util.ioretry(lambda: util.makedirs(self.linkpath))
os.symlink(self.linkpath, self.path)
except util.CommandException as inst:
if inst.code != errno.EEXIST:
try:
self.unmount(self.mountpoint, True)
except SMBException:
util.logException('SMBSR.unmount()')
raise xs_errors.XenError(
'SMBCreate',
opterr="remote directory creation error: {}"
.format(os.strerror(inst.code))
)
self.detach(sr_uuid)
def fset(self, lightSource):
"""set active lightSource"""
# pylint: disable=W0212
if self._lightSource != lightSource:
if lightSource not in LIGHTSOURCES:
logException(TileException('lightSource %s illegal' % lightSource))
self._reload(self.tileset, lightSource)
def quitProgram(result=None):
"""now all connections to servers are cleanly closed"""
if isinstance(result, Failure):
logException(result)
try:
Internal.reactor.stop()
except ReactorNotRunning:
pass
StateSaver.saveAll()
field = Internal.field
if field:
# if we have the ruleset editor visible, we get:
# File "/hdd/pub/src/gitgames/kajongg/src/rulesetselector.py", line 194, in headerData
# if role == Qt.DisplayRole and orientation == Qt.Horizontal:
# AttributeError: 'NoneType' object has no attribute 'DisplayRole'
# how can Qt get None? Same happens with QEvent, see statesaver.py
if field.confDialog:
field.confDialog.hide()
field.hide(
) # do not make the user see the delay for stopping the reactor
# we may be in a Deferred callback which would
# catch sys.exit as an exception
# and the qt4reactor does not quit the app when being stopped
Internal.quitWaitTime = 0
QTimer.singleShot(10, Client.appquit)
def startLocalServer(self, port):
"""start a local server"""
try:
args = ['kajonggserver'] # the default
if sys.argv[0].endswith('kajongg.py'):
tryServer = sys.argv[0].replace('.py', 'server.py')
if os.path.exists(tryServer):
args = ['python', tryServer]
if self.useSocket or os.name == 'nt':
args.append('--local')
if port:
args.append('--port=%d' % port)
if self.useSocket:
args.append('--db=%slocal.db' % appdataDir())
if Debug.argString:
args.append('--debug=%s' % Debug.argString)
if Options.socket:
args.append('--socket=%s' % Options.socket)
process = subprocess.Popen(args, shell=os.name == 'nt')
if Debug.connections:
logDebug(
m18n(
'started the local kajongg server: pid=<numid>%1</numid> %2',
process.pid, ' '.join(args)))
except OSError as exc:
logException(exc)
def run(driver, driver_info):
"""Convenience method to run command on the given driver"""
cmd = SRCommand(driver_info)
try:
cmd.parse()
cmd.run_statics()
sr = driver(cmd, cmd.sr_uuid)
sr.direct = True
ret = cmd.run(sr)
if ret == None:
print util.return_nil ()
else:
print ret
except (Exception, SR.SRException) as e:
try:
util.logException(driver_info['name'])
except KeyError:
util.SMlog('driver_info does not contain a \'name\' key.')
except:
pass
# If exception is of type SR.SRException,
# pass to xapi, else re-raise.
if isinstance(e, SR.SRException):
print e.toxml()
else:
raise
sys.exit(0)
def run(driver, driver_info):
"""Convenience method to run command on the given driver"""
cmd = SRCommand(driver_info)
try:
cmd.parse()
cmd.run_statics()
sr = driver(cmd, cmd.sr_uuid)
sr.direct = True
ret = cmd.run(sr)
if ret == None:
print util.return_nil ()
else:
print ret
except (Exception, SR.SRException) as e:
try:
util.logException(driver_info['name'])
except KeyError:
util.SMlog('driver_info does not contain a \'name\' key.')
except:
pass
# If exception is of type SR.SRException, pass to Xapi.
# If generic python Exception, print a generic xmlrpclib
# dump and pass to XAPI.
if isinstance(e, SR.SRException):
print e.toxml()
else:
print xmlrpclib.dumps(xmlrpclib.Fault(1200, str(e)), "", True)
sys.exit(0)
def playerByName(self, playerName):
"""return None or the matching player"""
if playerName is None:
return None
for myPlayer in self.players:
if myPlayer.name == playerName:
return myPlayer
logException('Move references unknown player %s' % playerName)
def __getitem__(self, index):
"""allow access by idx or by wind"""
if isinstance(index, basestring) and len(index) == 1:
for player in self:
if player.wind == index:
return player
logException("no player has wind %s" % index)
return list.__getitem__(self, index)
def validateDefinition(self, prevDefinition):
"""check for validity. If wrong, restore prevDefinition."""
payers = int(self.options.get('payers', 1))
payees = int(self.options.get('payees', 1))
if not 2 <= payers + payees <= 4:
self.definition = prevDefinition
logException(m18nc('%1 can be a sentence', '%4 have impossible values %2/%3 in rule "%1"',
self.name, payers, payees, 'payers/payees'))
def attach_from_config(self, sr_uuid, vdi_uuid):
try:
if not util.pathexists(self.sr.path):
self.sr.attach(sr_uuid)
except:
util.logException("SMBFileVDI.attach_from_config")
raise xs_errors.XenError('SRUnavailable',
opterr='Unable to attach from config')
def __init__(self, cmdList, args=None, dbHandle=None, silent=False, mayFail=False):
"""we take a list of sql statements. Only the last one is allowed to be
a select statement.
Do prepared queries by passing a single query statement in cmdList
and the parameters in args. If args is a list of lists, execute the
prepared query for every sublist.
If dbHandle is passed, use that for db access.
Else if the default dbHandle (DBHandle.default) is defined, use it."""
# pylint: disable=R0912
# pylint says too many branches
silent |= not Debug.sql
self.dbHandle = dbHandle or DBHandle.default
preparedQuery = not isinstance(cmdList, list) and bool(args)
self.query = QSqlQuery(self.dbHandle)
self.msg = None
self.records = []
if not isinstance(cmdList, list):
cmdList = list([cmdList])
self.cmdList = cmdList
for cmd in cmdList:
retryCount = 0
while retryCount < 100:
self.lastError = None
if preparedQuery:
self.query.prepare(cmd)
if not isinstance(args[0], list):
args = list([args])
for dataSet in args:
if not silent:
_, utf8Args = xToUtf8(u'', dataSet)
logDebug("{cmd} [{args}]".format(cmd=cmd, args=", ".join(utf8Args)))
for value in dataSet:
self.query.addBindValue(QVariant(value))
self.success = self.query.exec_()
if not self.success:
break
else:
if not silent:
logDebug('%s %s' % (self.dbHandle.name, cmd))
self.success = self.query.exec_(cmd)
if self.success or self.query.lastError().number() not in (5, 6):
# 5: database locked, 6: table locked. Where can we get symbols for this?
break
time.sleep(0.1)
retryCount += 1
if not self.success:
self.lastError = unicode(self.query.lastError().text())
self.msg = 'ERROR in %s: %s' % (self.dbHandle.databaseName(), self.lastError)
if mayFail:
if not silent:
logDebug(self.msg)
else:
logException(self.msg)
return
self.records = None
self.fields = None
if self.query.isSelect():
self.retrieveRecords()
def loadGame(self):
"""load a game"""
selnum = len(self.selection.selectedRows())
if selnum != 1:
# should never happen
logException('loadGame: %d rows selected' % selnum)
idx = self.view.currentIndex()
self.selectedGame = self.model.record(idx.row()).value(0).toInt()[0]
self.buttonBox.accepted.emit()
def _log_last_triggered(session, sr_uuid):
try:
sr_ref = session.xenapi.SR.get_by_uuid(sr_uuid)
other_config = session.xenapi.SR.get_other_config(sr_ref)
if other_config.has_key(TRIM_LAST_TRIGGERED_KEY):
session.xenapi.SR.remove_from_other_config(sr_ref, TRIM_LAST_TRIGGERED_KEY)
session.xenapi.SR.add_to_other_config(sr_ref, TRIM_LAST_TRIGGERED_KEY, str(time.time()))
except:
util.logException("Unable to set other-config:%s" % TRIM_LAST_TRIGGERED_KEY)
def _log_last_triggered(session, sr_uuid):
try:
sr_ref = session.xenapi.SR.get_by_uuid(sr_uuid)
other_config = session.xenapi.SR.get_other_config(sr_ref)
if other_config.has_key(TRIM_LAST_TRIGGERED_KEY):
session.xenapi.SR.remove_from_other_config(sr_ref, TRIM_LAST_TRIGGERED_KEY)
session.xenapi.SR.add_to_other_config(sr_ref, TRIM_LAST_TRIGGERED_KEY, str(time.time()))
except:
util.logException("Unable to set other-config:%s" % TRIM_LAST_TRIGGERED_KEY)
def initDb():
"""open the db, create or update it if needed.
sets DBHandle.default."""
try:
DBHandle() # sets DBHandle.default
except BaseException as exc:
DBHandle.default = None
logException(exc)
return False
return True
def attach_from_config(self, sr_uuid, vdi_uuid):
util.SMlog("LVHDoISCSIVDI.attach_from_config")
try:
self.sr.iscsi.attach(sr_uuid)
if not self.sr.iscsi._attach_LUN_bySCSIid(self.sr.SCSIid):
raise xs_errors.XenError("InvalidDev")
return LVHDSR.LVHDVDI.attach(self, sr_uuid, vdi_uuid)
except:
util.logException("LVHDoISCSIVDI.attach_from_config")
raise xs_errors.XenError("SRUnavailable", opterr="Unable to attach the heartbeat disk")
def attach_from_config(self, sr_uuid, vdi_uuid):
"""Used for HA State-file only. Will not just attach the VDI but
also start a tapdisk on the file"""
util.SMlog("NFSFileVDI.attach_from_config")
try:
self.sr.attach(sr_uuid)
except:
util.logException("NFSFileVDI.attach_from_config")
raise xs_errors.XenError('SRUnavailable', \
opterr='Unable to attach from config')
def validateDefinition(self, prevDefinition):
"""check for validity. If wrong, restore prevDefinition."""
payers = int(self.options.get('payers', 1))
payees = int(self.options.get('payees', 1))
if not 2 <= payers + payees <= 4:
self.definition = prevDefinition
logException(
m18nc('%1 can be a sentence',
'%4 have impossible values %2/%3 in rule "%1"',
self.name, payers, payees, 'payers/payees'))
def attach_from_config(self, sr_uuid, vdi_uuid):
try:
self.sr.attach(sr_uuid)
if not self.sr._attach_LUN_bySCSIid(self.sr.SCSIid):
raise xs_errors.XenError('InvalidDev')
return LVHDSR.LVHDVDI.attach(self, sr_uuid, vdi_uuid)
except:
util.logException('LVHDoRBDVDI.attach_from_config')
raise xs_errors.XenError('SRUnavailable',
opterr='Failed to attach RBD')
def initDb():
"""open the db, create or update it if needed.
sets DBHandle.default."""
try:
DBHandle() # sets DBHandle.default
except BaseException as exc:
DBHandle.default = None
logException(exc)
return False
return True
def attach_from_config(self, sr_uuid, vdi_uuid):
"""Used for HA State-file only. Will not just attach the VDI but
also start a tapdisk on the file"""
util.SMlog("NFSFileVDI.attach_from_config")
try:
self.sr.attach(sr_uuid)
except:
util.logException("NFSFileVDI.attach_from_config")
raise xs_errors.XenError('SRUnavailable', \
opterr='Unable to attach from config')
def create(self, sr_uuid, size):
try:
# attach the device
util.SMlog("Trying to attach iscsi disk")
self.iscsi.attach(sr_uuid)
if not self.iscsi.attached:
raise xs_errors.XenError('SRNotAttached')
util.SMlog("Attached iscsi disk at %s \n" % self.iscsi.path)
try:
# generate new UUIDs for VG and LVs
old_vg_name = self._getVgName(self.dconf['device'])
lvm_config_dict = self._getLvmInfo(old_vg_name)
lvUuidMap = {} # Maps old lv uuids to new uuids
for lv_name in lvm_config_dict[old_vg_name]['logical_volumes']:
if lv_name == MDVOLUME_NAME:
continue
oldUuid = lv_name[4:] # remove the VHD-
lvUuidMap[oldUuid] = util.gen_uuid()
new_vg_name = VG_PREFIX + sr_uuid
self._resignLvm(sr_uuid, old_vg_name, lvUuidMap,
lvm_config_dict)
# causes creation of nodes and activates the lvm volumes
LVHDSR.LVHDSR.load(self, sr_uuid)
new_vdi_info = self._resignSrMetadata(new_vg_name, self.uuid,
lvUuidMap)
self._resignVdis(new_vg_name, lvUuidMap)
self._deleteAllSnapshots(new_vdi_info)
# Detach LVM
self.lvmCache.deactivateNoRefcount(MDVOLUME_NAME)
for newUuid in lvUuidMap.values():
new_lv_name = self.LV_VHD_PREFIX + newUuid
self.lvmCache.deactivateNoRefcount(new_lv_name)
except:
util.logException("RESIGN_CREATE")
raise
finally:
iscsilib.logout(self.iscsi.target, self.iscsi.targetIQN, all=True)
raise xs_errors.XenError(
"The SR has been successfully resigned. Use the lvmoiscsi type to attach it"
)
def findFreePort():
"""find an unused port on the current system.
used when we want to start a local server on windows"""
for port in range(2000, 9000):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(1)
try:
sock.connect(('127.0.0.1', port))
except socket.error:
return port
logException('cannot find a free port')
def findFreePort():
"""find an unused port on the current system.
used when we want to start a local server on windows"""
for port in range(2000, 9000):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(1)
try:
sock.connect(('127.0.0.1', port))
except socket.error:
return port
logException('cannot find a free port')
def attach_from_config(self, sr_uuid, vdi_uuid):
util.SMlog("OCFSoISCSIVDI.attach_from_config")
try:
self.sr.iscsi.attach(sr_uuid)
if not self.sr.iscsi._attach_LUN_bySCSIid(self.sr.SCSIid):
raise xs_errors.XenError('InvalidDev')
return OCFSSR.OCFSFileVDI.attach(self, sr_uuid, vdi_uuid)
except:
util.logException("OCFSoISCSIVDI.attach_from_config")
raise xs_errors.XenError('SRUnavailable', \
opterr='Unable to attach the heartbeat disk')
def attach_from_config(self, sr_uuid, vdi_uuid):
util.SMlog("LVHDoHBAVDI.attach_from_config")
self.sr.hbasr.attach(sr_uuid)
if self.sr.mpath == "true":
self.sr.mpathmodule.refresh(self.sr.SCSIid,0)
try:
return self.attach(sr_uuid, vdi_uuid)
except:
util.logException("LVHDoHBAVDI.attach_from_config")
raise xs_errors.XenError('SRUnavailable', \
opterr='Unable to attach the heartbeat disk')
def attach_from_config(self, sr_uuid, vdi_uuid):
util.SMlog("OCFSoHBAVDI.attach_from_config")
self.sr.hbasr.attach(sr_uuid)
if self.sr.mpath == "true":
self.sr.mpathmodule.refresh(self.sr.SCSIid,0)
try:
return self.attach(sr_uuid, vdi_uuid)
except:
util.logException("OCFSoHBAVDI.attach_from_config")
raise xs_errors.XenError('SRUnavailable', \
opterr='Unable to attach the heartbeat disk')
def attach_from_config(self, sr_uuid, vdi_uuid):
util.SMlog("OCFSoISCSIVDI.attach_from_config")
try:
self.sr.iscsi.attach(sr_uuid)
if not self.sr.iscsi._attach_LUN_bySCSIid(self.sr.SCSIid):
raise xs_errors.XenError('InvalidDev')
return OCFSSR.OCFSFileVDI.attach(self, sr_uuid, vdi_uuid)
except:
util.logException("OCFSoISCSIVDI.attach_from_config")
raise xs_errors.XenError('SRUnavailable', \
opterr='Unable to attach the heartbeat disk')
def run(self, sr):
try:
return self._run_locked(sr)
except (util.SMException, XenAPI.Failure), e:
util.logException(self.cmd)
msg = str(e)
if isinstance(e, util.CommandException):
msg = "Command %s failed (%s): %s" % (e.cmd, e.code, e.reason)
excType = EXCEPTION_TYPE.get(self.cmd)
if not excType:
excType = "SMGeneral"
raise xs_errors.XenError(excType, opterr=msg)
def wrapper(self, *args):
if not self.initialized:
util.SMlog("LVMCache: will initialize now")
self.refresh()
#util.SMlog("%s(%s): %s" % (op, args, self.toString()))
try:
ret = op(self, *args)
except KeyError:
util.logException("LVMCache")
util.SMlog("%s(%s): %s" % (op, args, self.toString()))
raise
return ret
def wrapper(self, *args):
if not self.initialized:
util.SMlog("LVMCache: will initialize now")
self.refresh()
#util.SMlog("%s(%s): %s" % (op, args, self.toString()))
try:
ret = op(self, *args)
except KeyError:
util.logException("LVMCache")
util.SMlog("%s(%s): %s" % (op, args, self.toString()))
raise
return ret
def create(self, sr_uuid, size):
try:
# attach the device
util.SMlog("Trying to attach iscsi disk")
self.iscsi.attach(sr_uuid)
if not self.iscsi.attached:
raise xs_errors.XenError('SRNotAttached')
util.SMlog("Attached iscsi disk at %s \n" % self.iscsi.path)
try:
# generate new UUIDs for VG and LVs
old_vg_name = self._getVgName(self.dconf['device'])
lvm_config_dict = self._getLvmInfo(old_vg_name)
lvUuidMap = {} # Maps old lv uuids to new uuids
for lv_name in lvm_config_dict[old_vg_name]['logical_volumes']:
if lv_name == MDVOLUME_NAME:
continue
oldUuid = lv_name[4:] # remove the VHD-
lvUuidMap[oldUuid] = util.gen_uuid()
new_vg_name = VG_PREFIX + sr_uuid
self._resignLvm(sr_uuid, old_vg_name, lvUuidMap, lvm_config_dict)
# causes creation of nodes and activates the lvm volumes
LVHDSR.LVHDSR.load(self, sr_uuid)
new_vdi_info = self._resignSrMetadata(new_vg_name, self.uuid, lvUuidMap)
self._resignVdis(new_vg_name, lvUuidMap)
self._deleteAllSnapshots(new_vdi_info)
# Detach LVM
self.lvmCache.deactivateNoRefcount(MDVOLUME_NAME)
for newUuid in lvUuidMap.values():
new_lv_name = self.LV_VHD_PREFIX + newUuid
self.lvmCache.deactivateNoRefcount(new_lv_name)
except:
util.logException("RESIGN_CREATE")
raise
finally:
iscsilib.logout(self.iscsi.target, self.iscsi.targetIQN, all=True)
raise xs_errors.XenError("The SR has been successfully resigned. Use the lvmoiscsi type to attach it")
def create(self, type, id, val):
"""Create an entry of type "type" for "id" with the value "val".
Error if such an entry already exists."""
valExisting = self.get(type, id)
writeData = False
if valExisting:
raise JournalerException("Journal already exists for '%s:%s': %s" \
% (type, id, valExisting))
lvName = self._getNameLV(type, id, val)
mapperDevice = self._getLVMapperName(lvName)
if len(mapperDevice) > LVM_MAX_NAME_LEN:
lvName = self._getNameLV(type, id)
writeData = True
mapperDevice = self._getLVMapperName(lvName)
assert len(mapperDevice) <= LVM_MAX_NAME_LEN
self.lvmCache.create(lvName, self.LV_SIZE, self.LV_TAG)
if writeData:
fullPath = self.lvmCache._getPath(lvName)
fd = open_file(fullPath, True)
try:
e = None
try:
min_block_size = get_min_blk_size_wrapper(fd)
data = "%d %s" % (len(val), val)
file_write_wrapper(fd, 0, min_block_size, data, len(data))
except Exception as e:
raise
finally:
try:
close(fd)
self.lvmCache.deactivateNoRefcount(lvName)
except Exception as e2:
msg = 'failed to close/deactivate %s: %s' \
% (lvName, e2)
if not e:
util.SMlog(msg)
raise e2
else:
util.SMlog('WARNING: %s (error ignored)' % msg)
except:
util.logException("journaler.create")
try:
self.lvmCache.remove(lvName)
except Exception as e:
util.SMlog('WARNING: failed to clean up failed journal ' \
' creation: %s (error ignored)' % e)
raise JournalerException("Failed to write to journal %s" \
% lvName)
def scan_srlist(prefix, root):
VGs = {}
for dev in root.split(','):
try:
sr_uuid = _get_sr_uuid(dev, [prefix]).strip(' \n')
if len(sr_uuid):
if VGs.has_key(sr_uuid):
VGs[sr_uuid] += ",%s" % dev
else:
VGs[sr_uuid] = dev
except Exception, e:
util.logException("exception (ignored): %s" % e)
continue
def attach_from_config(self, sr_uuid, vdi_uuid):
"""
Attach and activate a VDI using config generated by
vdi_generate_config above. This is used for cases such as
the HA state-file and the redo-log.
"""
util.SMlog("FileVDI.attach_from_config")
try:
if not util.pathexists(self.sr.path):
self.sr.attach(sr_uuid)
except:
util.logException("FileVDI.attach_from_config")
raise xs_errors.XenError("SRUnavailable", opterr="Unable to attach from config")
def attach(self, sr_uuid, vdi_uuid):
try:
vdi_ref = self.sr.srcmd.params['vdi_ref']
self.session.xenapi.VDI.remove_from_xenstore_data(vdi_ref, \
"vdi-type")
self.session.xenapi.VDI.remove_from_xenstore_data(vdi_ref, \
"storage-type")
self.session.xenapi.VDI.add_to_xenstore_data(vdi_ref, \
"storage-type", "nfs")
except:
util.logException("NFSSR:attach")
pass
return super(NFSFileVDI, self).attach(sr_uuid, vdi_uuid)
def scan_srlist(prefix, root, sr_alloc=None):
VGs = {}
for dev in root.split(','):
try:
sr_uuid = _get_sr_uuid(dev, [prefix]).strip(' \n')
if len(sr_uuid):
if VGs.has_key(sr_uuid):
VGs[sr_uuid] += ",%s" % dev
else:
VGs[sr_uuid] = dev
except Exception, e:
util.logException("exception (ignored): %s" % e)
continue
def attach(self, sr_uuid, vdi_uuid):
try:
vdi_ref = self.sr.srcmd.params['vdi_ref']
self.session.xenapi.VDI.remove_from_xenstore_data(vdi_ref, \
"vdi-type")
self.session.xenapi.VDI.remove_from_xenstore_data(vdi_ref, \
"storage-type")
self.session.xenapi.VDI.add_to_xenstore_data(vdi_ref, \
"storage-type", "nfs")
except:
util.logException("NFSSR:attach")
pass
return super(NFSFileVDI, self).attach(sr_uuid, vdi_uuid)
def run(self, sr):
try:
return self._run_locked(sr)
except (util.CommandException, util.SMException, XenAPI.Failure), e:
util.logException(self.cmd)
msg = str(e)
if isinstance(e, util.CommandException):
msg = "Command %s failed (%s): %s" % \
(e.cmd, e.reason, os.strerror(abs(e.code)))
excType = EXCEPTION_TYPE.get(self.cmd)
if not excType:
excType = "SMGeneral"
raise xs_errors.XenError(excType, opterr=msg)
def __init__(self):
QSqlDatabase.__init__(self, "QSQLITE")
if not DBHandle.default:
DBHandle.default = self
if not os.path.exists(self.dbPath()):
self.createDatabase()
self.setDatabaseName(self.dbPath())
if not self.open():
self.default = None
logException('opening %s: %s' % (self.dbPath(), self.lastError()))
# timeout in msec:
self.setConnectOptions("QSQLITE_BUSY_TIMEOUT=2000")
with Transaction(silent=True):
self.upgradeDb()
def __init__(self):
QSqlDatabase.__init__(self, "QSQLITE")
if not DBHandle.default:
DBHandle.default = self
if not os.path.exists(self.dbPath()):
self.createDatabase()
self.setDatabaseName(self.dbPath())
if not self.open():
self.default = None
logException('opening %s: %s' % (self.dbPath(), self.lastError()))
# timeout in msec:
self.setConnectOptions("QSQLITE_BUSY_TIMEOUT=2000")
with Transaction(silent=True):
self.upgradeDb()
def scan_srlist(prefix, root):
VGs = {}
for dev in root.split(','):
try:
sr_uuid = _get_sr_uuid(dev, [prefix]).strip(' \n')
if len(sr_uuid):
if sr_uuid in VGs:
VGs[sr_uuid] += ",%s" % dev
else:
VGs[sr_uuid] = dev
except Exception as e:
util.logException("exception (ignored): %s" % e)
continue
return VGs
def run(self, sr):
try:
return self._run_locked(sr)
except (util.CommandException, util.SMException, XenAPI.Failure) as e:
util.logException(self.cmd)
msg = str(e)
if isinstance(e, util.CommandException):
msg = "Command %s failed (%s): %s" % \
(e.cmd, e.reason, os.strerror(abs(e.code)))
excType = EXCEPTION_TYPE.get(self.cmd)
if not excType:
excType = "SMGeneral"
raise xs_errors.XenError(excType, opterr=msg)
except blktap2.TapdiskFailed as e:
util.logException('tapdisk failed exception: %s' % e)
raise xs_errors.XenError(
'TapdiskFailed', os.strerror(e.get_error().get_error_code()))
except blktap2.TapdiskExists as e:
util.logException('tapdisk exists exception: %s' % e)
raise xs_errors.XenError('TapdiskAlreadyRunning', e.__str__())
except:
util.logException('generic exception: %s' % self.cmd)
raise
def deactivateAll(self):
# this is the cleanup step that will be performed even if the original
# operation failed - don't throw exceptions here
success = True
for persistent in [self.TEMPORARY, self.PERSISTENT]:
for binary in [self.NORMAL, self.BINARY]:
uuids = self.lvActivations[persistent][binary].keys()
for uuid in uuids:
try:
self.deactivate(uuid, binary, persistent)
except:
success = False
util.logException("_deactivateAll")
return success
def attach_from_config(self, sr_uuid, vdi_uuid):
"""
Attach and activate a VDI using config generated by
vdi_generate_config above. This is used for cases such as
the HA state-file and the redo-log.
"""
util.SMlog("FileVDI.attach_from_config")
try:
if not util.pathexists(self.sr.path):
self.sr.attach(sr_uuid)
except:
util.logException("FileVDI.attach_from_config")
raise xs_errors.XenError('SRUnavailable',
opterr='Unable to attach from config')
def deactivateAll(self):
# this is the cleanup step that will be performed even if the original
# operation failed - don't throw exceptions here
success = True
for persistent in [self.TEMPORARY, self.PERSISTENT]:
for binary in [self.NORMAL, self.BINARY]:
uuids = self.lvActivations[persistent][binary].keys()
for uuid in uuids:
try:
self.deactivate(uuid, binary, persistent)
except:
success = False
util.logException("_deactivateAll")
return success
def __init__(self):
if common.Preferences:
logException('Preferences is not None')
common.Preferences = self
KConfigSkeleton.__init__(self)
self.addString('General', 'tilesetName', 'default')
self.addString('General', 'windTilesetName', 'traditional')
self.addString('General', 'backgroundName', 'wood_light')
self.addBool('Display', 'showShadows', True)
self.addBool('Display', 'rearrangeMelds', False)
self.addBool('Display', 'showOnlyPossibleActions', True)
self.addBool('Display', 'propose', True)
self.addInteger('Display', 'animationSpeed', 70, 0, 99)
self.addBool('Display', 'useSounds', True)
self.addBool('Display', 'uploadVoice', False)
def __init__(self):
if common.Preferences:
logException('Preferences is not None')
common.Preferences = self
KConfigSkeleton.__init__(self)
self.addString('General', 'tilesetName', 'default')
self.addString('General', 'windTilesetName', 'traditional')
self.addString('General', 'backgroundName', 'wood_light')
self.addBool('Display', 'showShadows', True)
self.addBool('Display', 'rearrangeMelds', False)
self.addBool('Display', 'showOnlyPossibleActions', True)
self.addBool('Display', 'propose', True)
self.addInteger('Display', 'animationSpeed', 70, 0, 99)
self.addBool('Display', 'useSounds', True)
self.addBool('Display', 'uploadVoice', False)
def createDatabase(self):
"""use a temp file name. When done, rename to final file name,
thusly avoiding races if two processes want to build the same
database"""
tempName = '%s.new.%d' % (self.dbPath(), os.getpid())
self.setDatabaseName(tempName)
if not self.open():
logException('creating %s: %s' % (tempName, self.lastError()))
with Transaction(silent=True):
self.createTables()
self.__generateDbIdent()
QSqlDatabase.close(self)
newName = self.dbPath()
if os.path.exists(newName):
os.remove(tempName)
else:
os.rename(tempName, newName)
def showConcealedTiles(self, tileNames, show=True):
"""show or hide tileNames"""
if not self.game.playOpen and self != self.game.myself:
if not isinstance(tileNames, (list, tuple)):
tileNames = [tileNames]
assert len(tileNames) <= len(self.__concealedTileNames), \
'%s: showConcealedTiles %s, we have only %s' % (self, tileNames, self.__concealedTileNames)
for tileName in tileNames:
src, dst = ('Xy', tileName) if show else (tileName, 'Xy')
assert src != dst, (self, src, dst, tileNames, self.__concealedTileNames)
if not src in self.__concealedTileNames:
logException( '%s: showConcealedTiles(%s): %s not in %s.' % \
(self, tileNames, src, self.__concealedTileNames))
idx = self.__concealedTileNames.index(src)
self.__concealedTileNames[idx] = dst
self.__hand = None
self.syncHandBoard()
def wrapper(self, *args):
acquired = False
if not self.lock.held():
self.lock.acquire()
acquired = True
try:
try:
ret = op(self, *args)
except (util.SMException, XenAPI.Failure), e:
util.logException("FileSR:%s" % op)
msg = str(e)
if isinstance(e, util.CommandException):
msg = "Command %s failed (%s): %s" % \
(e.cmd, e.code, e.reason)
raise xs_errors.XenError(excType, opterr=msg)
except:
util.logException("FileSR:%s" % op)
raise
def attach_from_config(self, sr_uuid, vdi_uuid):
util.SMlog("RBDVDI.attach_from_config")
self.sr.attach(sr_uuid)
try:
vdi_name = "%s%s" % (cephutils.VDI_PREFIX, vdi_uuid)
dev_name = "%s/%s" % (self.sr.SR_ROOT, vdi_name)
self.path = self.sr._get_path(vdi_uuid)
if self.mode == "kernel":
util.pread2(["rbd", "map", vdi_name, "--pool", self.sr.CEPH_POOL_NAME, "--name", self.sr.CEPH_USER])
elif self.mode == "fuse":
pass
elif self.mode == "nbd":
cmdout = util.pread2(["rbd-nbd", "--nbds_max", str(cephutils.NBDS_MAX), "map", "%s/%s" % (self.sr.CEPH_POOL_NAME, vdi_name), "--name", self.sr.CEPH_USER]).rstrip('\n')
util.pread2(["ln", "-s", cmdout, dev_name])
return VDI.VDI.attach(self, sr_uuid, vdi_uuid)
except:
util.logException("RBDVDI.attach_from_config")
raise xs_errors.XenError('SRUnavailable', \
opterr='Unable to attach the heartbeat disk')
def renderer(self):
"""initialise the svg renderer with the selected svg file"""
if self.__renderer is None:
self.__renderer = QSvgRenderer(self.__graphicspath)
if not self.__renderer.isValid():
logException(TileException( \
m18n('file <filename>%1</filename> contains no valid SVG'), self.__graphicspath))
distance = 0
if self.desktopFileName == 'classic':
distance = 2
distanceSize = QSizeF(distance, distance)
self.faceSize = self.__renderer.boundsOnElement('BAMBOO_1').size()+distanceSize
self.tileSize = self.__renderer.boundsOnElement('TILE_2').size()+distanceSize
if not Internal.scaleScene:
self.faceSize /= 2
self.tileSize /= 2
shW = self.shadowWidth()
shH = self.shadowHeight()
self.__shadowOffsets = [[(-shW, 0), (0, 0), (0, shH), (-shH, shW)],
[(0, 0), (shH, 0), (shW, shH), (0, shW)],
[(0, -shH), (shH, -shW), (shW, 0), (0, 0)],
[(-shW, -shH), (0, -shW), (0, 0), (-shH, 0)]]
return self.__renderer
def pixmap(self, size):
"""returns a background pixmap or None for isPlain"""
self.__pmap = None
if not self.isPlain:
width = size.width()
height = size.height()
if self.tiled:
width = self.imageWidth
height = self.imageHeight
cachekey = QString("%1W%2H%3") \
.arg(self.name).arg(width).arg(height)
self.__pmap = QPixmapCache.find(cachekey)
if not self.__pmap:
renderer = QSvgRenderer(self.__graphicspath)
if not renderer.isValid():
logException(BackgroundException( \
m18n('file <filename>%1</filename> contains no valid SVG', self.__graphicspath)))
self.__pmap = QPixmap(width, height)
self.__pmap.fill(Qt.transparent)
painter = QPainter(self.__pmap)
renderer.render(painter)
QPixmapCache.insert(cachekey, self.__pmap)
return self.__pmap
