def test_sampleLabelings(self):
tree = Tree("(A:1,(B:1,(C:1,(E:1,D:1)Int_1:0.5[&&NHX:ancient=1])Int_2:0.5[&&NHX:ancient=0])Int_3:1)Root;", format=1)
chrom = {}
chrom["one"] = ["3","4"]
species = {}
species["C"] = chrom
chrom = {}
chrom["one"] = ["3","4"]
species["D"] = chrom
chrom = {}
chrom["one"] = []
species["E"] = chrom
chrom = {}
chrom["one"] = []
species["A"] = chrom
chrom = {}
chrom["one"] = []
species["B"] = chrom
adj = getAdjacencies.findAdjacencies(species)
paths = getAdjacencies.findTreePaths(tree)
internal,adjacenciesAncestral = getAdjacencies.assignAncestralAdjacencies(paths,adj,tree)
graphs = globalAdjacencyGraph.createGraph(adj,adjacenciesAncestral)
jointLabels, first = SR.enumJointLabelings(graphs)
probs={"Int_1":{(6, 7):0.1},"Int_2":{(6, 7):0.1},"Int_3":{(6, 7):0.1},"Root":{(6, 7):0.1}}
for i in range(0,10):
validLabels, validAtNode = SR.validLabels(jointLabels,first)
resolvedCCs = SR.sampleLabelings(tree, graphs, validAtNode, adj,probs, alpha=0)
reconstructedAdj = SR.reconstructedAdjacencies(resolvedCCs)
print reconstructedAdj
def __init__(self, key, opterr=None):
# Check the XML definition file exists
if not os.path.exists(XML_DEFS):
print "No XML def file found"
raise Exception.__init__(self, '')
# Read the definition list
self._fromxml('SM-errorcodes')
########DEBUG#######
#for val in self.errorlist.keys():
# subdict = self.errorlist[val]
# print "KEY [%s]" % val
# for subval in subdict.keys():
# print "\tSUBKEY: %s, VALUE: %s" % (subval,subdict[subval])
########END#######
# Now find the specific error
if self.errorlist.has_key(key):
subdict = self.errorlist[key]
errorcode = int(subdict['value'])
errormessage = subdict['description']
if opterr is not None:
errormessage += " [opterr=%s]" % opterr
util.SMlog("Raising exception [%d, %s]" %
(errorcode, errormessage))
raise SR.SROSError(errorcode, errormessage)
# development error
raise SR.SROSError(1, "Error reporting error, unknown key %s" % key)
def test_enumJointLabelings(self):
#print nx.maximal_matching(self.graph)
#print nx.max_weight_matching(self.graph)
joint,first = SR.enumJointLabelings([self.graph])
TestCase.assertEqual(self,len(joint[self.graph]),15)
valid, validAtNode = SR.validLabels(joint,first)
TestCase.assertEqual(self,len(valid[self.graph]),8)
def create(self, sr_uuid, size):
if self.checkmount():
raise SR.SROSError(113, 'GlusterFS mount point already attached')
try:
self.mount()
except GlusterFSException, exc:
# noinspection PyBroadException
try:
os.rmdir(self.mountpoint)
except:
# we have no recovery strategy
pass
raise SR.SROSError(111, "GlusterFS mount error [opterr=%s]" % exc.errstr)
def endpointing(self, current):
energy = 0.0
# print current
# print len(current)
self.is_speech = False
for i in range(len(current)):
energy += pow(current[i], 2)
energy = 10 * numpy.log(energy)
# print self.threshold, self.level, self.background
# print energy
if self.index == 0:
self.level = energy
# threshold equals to max energy of first ten frames divide 4
if self.index < 10 and self.index >= 0:
if self.max_energy < energy:
self.max_energy = energy
self.background += energy
if self.index == 9:
self.background /= 10
self.threshold = self.max_energy / 8
if self.index >= 10:
if energy < self.background:
self.background = energy
else:
self.background += (energy - self.background) * self.adjustment
self.level = (self.level * self.forget_factor +
energy) / (self.forget_factor + 1)
if self.level < self.background:
self.level = self.background
if self.level - self.background > self.threshold:
self.is_speech = True
if self.is_speech != self.past_is_speech:
if self.is_speech:
self.begin_index = self.index
# print "speech begin at %d\n" % self.begin_index
# print 'energy = %d\n' % energy
else:
self.end_index = self.index
if not self.record_continuous and self.time_synchronous and self.end_index - self.begin_index > 8:
# if self.need_train:
# self.need_train = 0
# self.DTW_obj = SR.training_model(5, self.using_kmeans)[0]
SR.test(self.time_synchronous, 1, 5, self.using_kmeans,
self.begin_index, self.end_index, self.DTW_obj,
self.read_feature_from_file)
# print "speech end at %d\n" % self.end_index
# print 'energy = %d\n' % energy
self.past_is_speech = self.is_speech
self.index += 1
def attach(self, sr_uuid):
if not self.checkmount():
try:
self.mount()
os.symlink(self.linkpath, self.path)
except GlusterFSException, exc:
raise SR.SROSError(12, exc.errstr)
def create(self, sr_uuid, size):
# Check whether an SR already exists
SRs = self.session.xenapi.SR.get_all_records()
for sr in SRs:
record = SRs[sr]
sm_config = record["sm_config"]
if 'datatype' in sm_config and \
sm_config['datatype'] == 'HBA' and \
sm_config['hbatype'] == self.type:
raise xs_errors.XenError('SRInUse')
self._init_hbadict()
if not self.attached:
raise xs_errors.XenError('InvalidDev', \
opterr=('No such HBA Device detected [%s]') % self.type)
if self._loadvdis() > 0:
scanrecord = SR.ScanRecord(self)
scanrecord.synchronise()
try:
self.detach(sr_uuid)
except:
pass
self.sm_config = self.session.xenapi.SR.get_sm_config(self.sr_ref)
self.sm_config['disktype'] = 'Raw'
self.sm_config['datatype'] = 'HBA'
self.sm_config['hbatype'] = self.type
self.sm_config['multipathable'] = 'true'
self.session.xenapi.SR.set_sm_config(self.sr_ref, self.sm_config)
def create_SR(self, cmd, dconf, cmd_params=None):
srcmd = mock.Mock()
srcmd.dconf = dconf
srcmd.params = {'command': cmd}
if cmd_params:
srcmd.params.update(cmd_params)
return SR.SR(srcmd, "some SR UUID")
def _is_open(session, args):
"""Check if VDI <args["vdiUuid"]> is open by a tapdisk on this host"""
import SRCommand, SR, NFSSR, EXTSR, LVHDSR, blktap2
util.SMlog("on-slave.is_open: %s" % args)
vdiUuid = args["vdiUuid"]
srRef = args["srRef"]
srRec = session.xenapi.SR.get_record(srRef)
srType = srRec["type"]
# FIXME: ugly hacks to create a VDI object without a real SRCommand to
# avoid having to refactor the core files
if srType.startswith("lvm"):
srType = "lvhd"
cmd = SRCommand.SRCommand(None)
cmd.driver_info = {"capabilities": None}
cmd.dconf = {"server": None, "device": "/HACK"}
cmd.params = {"command": None}
driver = SR.driver(srType)
sr = driver(cmd, srRec["uuid"])
vdi = sr.vdi(vdiUuid)
tapdisk = blktap2.Tapdisk.find_by_path(vdi.path)
util.SMlog("Tapdisk for %s: %s" % (vdi.path, tapdisk))
if tapdisk:
return "True"
return "False"
def scan(self, sr_uuid):
"""
This function is almost a copy of its base class equivalent.
Main differences are:
- Fixed erroneous size calculation
- Set VDI names automatically
- Avoid ScanRecord sync for missing VDIS (stale LUNs)
The last one is called in the sub-sub class so we cannot simply
extend the base class funcion but we need to override it
"""
self._init_hbadict()
if not self.passthrough:
if not self.attached:
raise xs_errors.XenError('SRUnavailable')
self._loadvdis()
# This block is almost SR.scan but without missing sync
self._db_update()
scanrecord = SR.ScanRecord(self)
scanrecord.synchronise_new()
scanrecord.synchronise_existing()
# Fixing sizes calculation
phys_util = 0
for key in self.vdis:
vdi_ref = self.session.xenapi.VDI.get_by_uuid(key)
if B_util.is_vdi_attached(self.session, vdi_ref):
phys_util += self.vdis[key].size
self._set_stats(phys_util=phys_util)
self._set_vdis_name()
def run(self):
global goal_pos, servo_command, init_get, functionMode
while self.__running.isSet():
self.__flag.wait()
if SR_mode:
voice_command = SR.run()
if voice_command == 'forward':
SpiderG.walk('forward')
time.sleep(2)
SpiderG.servoStop()
elif voice_command == 'backward':
SpiderG.walk('backward')
time.sleep(2)
SpiderG.servoStop()
elif voice_command == 'left':
SpiderG.walk('turnleft')
time.sleep(5)
SpiderG.servoStop()
elif voice_command == 'right':
SpiderG.walk('turnright')
time.sleep(5)
SpiderG.servoStop()
elif voice_command == 'stop':
SpiderG.servoStop()
else:
self.pause()
def create(self, sr_uuid, size):
# Check whether an SR already exists
SRs = self.session.xenapi.SR.get_all_records()
for sr in SRs:
record = SRs[sr]
sm_config = record["sm_config"]
if 'targetIQN' in sm_config and \
sm_config['targetIQN'] == self.targetIQN:
raise xs_errors.XenError('SRInUse')
self.attach(sr_uuid)
# Wait up to MAX_TIMEOUT for devices to appear
util.wait_for_path(self.path, MAX_TIMEOUT)
if self._loadvdis() > 0:
scanrecord = SR.ScanRecord(self)
scanrecord.synchronise()
try:
self.detach(sr_uuid)
except:
pass
self.sm_config = self.session.xenapi.SR.get_sm_config(self.sr_ref)
self.sm_config['disktype'] = 'Raw'
self.sm_config['datatype'] = 'ISCSI'
self.sm_config['target'] = self.target
self.sm_config['targetIQN'] = self.targetIQN
self.sm_config['multipathable'] = 'true'
self.session.xenapi.SR.set_sm_config(self.sr_ref, self.sm_config)
return
def endpointing(self, current):
energy = 0.0
# print current
# print len(current)
self.is_speech = False
for i in range(len(current)):
energy += pow(current[i], 2)
energy = 10 * numpy.log(energy)
# print self.threshold, self.level, self.background
# print energy
if self.index == 0:
self.level = energy
# threshold equals to max energy of first ten frames divide 4
if self.index < 10 and self.index >= 0:
if self.max_energy < energy:
self.max_energy = energy
self.background += energy
if self.index == 9:
self.background /= 10
self.threshold = self.max_energy / 4
if self.index >= 10:
if energy < self.background:
self.background = energy
else:
self.background += (energy - self.background) * self.adjustment
self.level = (self.level * self.forget_factor + energy) / (self.forget_factor + 1)
if self.level < self.background:
self.level = self.background
if self.level - self.background > self.threshold:
self.is_speech = True
if self.is_speech != self.past_is_speech:
if self.is_speech:
self.begin_index = self.index
# print "speech begin at %d\n" % self.begin_index
# print 'energy = %d\n' % energy
else:
self.end_index = self.index
if self.time_synchronous and self.end_index - self.begin_index > 8:
# if self.need_train:
# self.need_train = 0
# self.DTW_obj = SR.training_model(5, self.using_kmeans)[0]
SR.test(self.time_synchronous, 1, 5, self.using_kmeans, self.begin_index,
self.end_index, self.DTW_obj, self.read_feature_from_file)
# print "speech end at %d\n" % self.end_index
# print 'energy = %d\n' % energy
self.past_is_speech = self.is_speech
self.index += 1
def main():
pc = PCC.PrintControl(printid, portname, baudrate, tem_position)
pc.printor_alive()
fr = FR.FileReceiver()
sr = SR.StatueReportor()
ss = threading.Thread(target=state_send_thread, args=(pc, sr))
gft = threading.Thread(target=get_file_thread, args=(pc, fr))
ss.start()
gft.start()
ss.join()
gft.join()
def load(self, sr_uuid):
driver = SR.driver('iscsi')
self.iscsi = driver(self.original_srcmd, sr_uuid)
# User must specify a LUN ID(s) for adding to the VG
if not self.dconf.has_key('LUNid') or not self.dconf['LUNid']:
raise xs_errors.XenError('ConfigLUNIDMissing')
self.dconf['device'] = os.path.join(self.iscsi.path,"LUN%s" % \
self.dconf['LUNid'])
if not self.iscsi.attached:
# Must attach SR here in order to load VG
self.iscsi.attach(sr_uuid)
super(EXToISCSISR, self).load(sr_uuid)
def delete(self, sr_uuid):
# try to remove/delete non VDI contents first
super(GlusterFSSR, self).delete(sr_uuid)
try:
if self.checkmount():
self.detach(sr_uuid)
self.mount()
if util.ioretry(lambda: util.pathexists(self.linkpath)):
util.ioretry(lambda: os.rmdir(self.linkpath))
self.unmount(self.mountpoint, True)
except util.CommandException, inst:
self.detach(sr_uuid)
if inst.code != errno.ENOENT:
raise SR.SROSError(114, "Failed to remove GlusterFS mount point")
def load(self, sr_uuid):
driver = SR.driver('iscsi')
self.iscsi = driver(self.original_srcmd, sr_uuid)
# User must specify a LUN ID(s) for adding to the VG
if not self.dconf.has_key('LUNid') or not self.dconf['LUNid']:
raise xs_errors.XenError('ConfigLUNIDMissing')
self.dconf['device'] = os.path.join(self.iscsi.path,"LUN%s" % \
self.dconf['LUNid'])
if not self.iscsi.attached:
# Must attach SR here in order to load VG
self.iscsi.attach(sr_uuid)
super(EXToISCSISR, self).load(sr_uuid)
def scan(self, sr_uuid):
util.SMlog("RBDSR.load: sr_uuid=%s" % sr_uuid)
cephutils.SR.scan(self, sr_uuid)
self.physical_size = self.RBDPOOLs[sr_uuid]['stats'][
'max_avail'] + self.RBDPOOLs[sr_uuid]['stats']['bytes_used']
self.physical_utilisation = self.RBDPOOLs[sr_uuid]['stats'][
'bytes_used']
self.virtual_allocation = self._get_allocated_size()
self._loadvdis()
self._db_update()
scanrecord = SR.ScanRecord(self)
scanrecord.synchronise_existing()
scanrecord.synchronise_new()
def test_attach_nfs_no_server(self, _checkmount, testHost, makedirs,
validate_nfsversion, convertDNS, gen_uuid):
isosr = self.create_isosr(location='aServer:/aLocation',
atype='nfs_iso',
sr_uuid='asr_uuid')
_checkmount.side_effect = [False]
testHost.side_effect = SR.SROSError(
140, 'Incorrect DNS name, unable to resolve.')
with self.assertRaises(SR.SROSError) as ose:
isosr.attach(None)
self.assertEqual(140, ose.exception.errno)
def load(self, sr_uuid):
driver = SR.driver('hba')
self.hbasr = driver(self.original_srcmd, sr_uuid)
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
except:
pass
if not self.dconf.has_key('SCSIid') or not self.dconf['SCSIid']:
print >>sys.stderr,self.hbasr.print_devs()
raise xs_errors.XenError('ConfigSCSIid')
self.SCSIid = self.dconf['SCSIid']
self._pathrefresh(OCFSoHBASR)
super(OCFSoHBASR, self).load(sr_uuid)
def load(self, sr_uuid):
driver = SR.driver('hba')
self.hbasr = driver(self.original_srcmd, sr_uuid)
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
except:
pass
if 'SCSIid' not in self.dconf or not self.dconf['SCSIid']:
print(self.hbasr.print_devs(), file=sys.stderr)
raise xs_errors.XenError('ConfigSCSIid')
self.SCSIid = self.dconf['SCSIid']
self._pathrefresh(OCFSoHBASR, load = False)
super(OCFSoHBASR, self).load(sr_uuid)
class SR_ctrl(threading.Thread):
def __init__(self, *args, **kwargs):
super(SR_ctrl, self).__init__(*args, **kwargs)
self.__flag = threading.Event()
self.__flag.set()
self.__running = threading.Event()
self.__running.set()
def run(self):
global goal_pos, servo_command, init_get, functionMode
while self.__running.isSet():
self.__flag.wait()
if SR_mode:
voice_command = SR.run()
if voice_command == 'forward':
turn.turnMiddle()
move.move(speed_set, 'forward')
time.sleep(1)
move.motorStop()
elif voice_command == 'backward':
turn.turnMiddle()
move.move(speed_set, 'backward')
time.sleep(1)
move.motorStop()
elif voice_command == 'left':
servo.turnLeft()
move.move(speed_set, 'forward')
time.sleep(1)
turn.turnMiddle()
move.motorStop()
elif voice_command == 'right':
servo.turnRight()
move.move(speed_set, 'forward')
time.sleep(1)
turn.turnMiddle()
move.motorStop()
elif voice_command == 'stop':
turn.turnMiddle()
move.motorStop()
def scan(self, sr_uuid):
if not self.isMaster:
util.SMlog('sr_scan blocked for non-master')
raise xs_errors.XenError('LVMMaster')
self._loadbuffer()
self._loadvdis()
stats = lvutil._getVGstats(self.vgname)
self.physical_size = stats['physical_size']
self.physical_utilisation = stats['physical_utilisation']
self.virtual_allocation = self.physical_utilisation
# Update the SR record
self._db_update()
# Synchronise the VDIs
scanrecord = SR.ScanRecord(self)
# XXX: never forget VDI records to work around glitch where some
# volumes temporarily disappeared
scanrecord.synchronise_new()
scanrecord.synchronise_existing()
def load(self, sr_uuid):
driver = SR.driver('hba')
if 'type' not in self.original_srcmd.params['device_config'] or \
'type' in self.original_srcmd.params['device_config'] and \
self.original_srcmd.dconf['type'] == "any":
self.original_srcmd.dconf['type'] = "fcoe"
self.hbasr = driver(self.original_srcmd, sr_uuid)
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
except:
pass
if 'SCSIid' not in self.dconf or not self.dconf['SCSIid']:
print(self.hbasr.print_devs(), file=sys.stderr)
raise xs_errors.XenError('ConfigSCSIid')
self.SCSIid = self.dconf['SCSIid']
LVHDSR.LVHDSR.load(self, sr_uuid)
def load(self, sr_uuid):
driver = SR.driver('hba')
self.hbasr = driver(self.original_srcmd, sr_uuid)
# If this is a vdi command, don't initialise SR
if not (util.isVDICommand(self.original_srcmd.cmd)):
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref,
self.sr_ref)
except:
pass
try:
if not self.dconf.has_key('SCSIid') and self.dconf.has_key(
'device'):
# UPGRADE FROM MIAMI: add SCSIid key to device_config
util.SMlog("Performing upgrade from Miami")
if not os.path.exists(self.dconf['device']):
raise xs_errors.XenError('InvalidDev')
SCSIid = scsiutil.getSCSIid(self.dconf['device'])
self.dconf['SCSIid'] = SCSIid
del self.dconf['device']
if pbd <> None:
device_config = self.session.xenapi.PBD.get_device_config(
pbd)
device_config['SCSIid'] = SCSIid
device_config['upgraded_from_miami'] = 'true'
del device_config['device']
self.session.xenapi.PBD.set_device_config(
pbd, device_config)
except:
pass
if not self.dconf.has_key('SCSIid') or not self.dconf['SCSIid']:
print >> sys.stderr, self.hbasr.print_devs()
raise xs_errors.XenError('ConfigSCSIid')
self.SCSIid = self.dconf['SCSIid']
self._pathrefresh(LVHDoHBASR, load=False)
LVHDSR.LVHDSR.load(self, sr_uuid)
def load(self, sr_uuid):
driver = SR.driver('hba')
if 'type' not in self.original_srcmd.params['device_config'] or \
'type' in self.original_srcmd.params['device_config'] and \
self.original_srcmd.dconf['type'] == "any":
self.original_srcmd.dconf['type'] = "fcoe"
self.hbasr = driver(self.original_srcmd, sr_uuid)
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
except:
pass
if not self.dconf.has_key('SCSIid') or not self.dconf['SCSIid']:
print >> sys.stderr, self.hbasr.print_devs()
raise xs_errors.XenError('ConfigSCSIid')
self.SCSIid = self.dconf['SCSIid']
self._pathrefresh(LVHDoFCoESR, load=False)
LVHDSR.LVHDSR.load(self, sr_uuid)
def load(self, sr_uuid):
driver = SR.driver('hba')
if 'type' not in self.original_srcmd.params['device_config'] or \
'type' in self.original_srcmd.params['device_config'] and \
self.original_srcmd.dconf['type'] == "any":
self.original_srcmd.dconf['type'] = "fcoe"
self.hbasr = driver(self.original_srcmd, sr_uuid)
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
except:
pass
if not self.dconf.has_key('SCSIid') or not self.dconf['SCSIid']:
print >>sys.stderr, self.hbasr.print_devs()
raise xs_errors.XenError('ConfigSCSIid')
self.SCSIid = self.dconf['SCSIid']
self._pathrefresh(LVHDoFCoESR)
LVHDSR.LVHDSR.load(self, sr_uuid)
def test_after_master_attach_vdi_not_available(
self, mock_log, mock_scan, mock_xenapi):
"""
Test that after_master_attach calls scan
"""
mock_session = mock.MagicMock(name='MockXapiSession')
mock_xenapi.xapi_local.return_value = mock_session
sr1 = self.create_SR("sr_create", {'ISCSIid': '12333423'},
{'session_ref': 'session1'})
mock_scan.side_effect = SR.SROSError(46, "The VDI is not available")
sr1.after_master_attach('dummy uuid')
mock_scan.assert_called_once_with(sr1, 'dummy uuid')
self.assertEquals(1, mock_log.call_count)
self.assertIn("Error in SR.after_master_attach",
mock_log.call_args[0][0])
mock_session.xenapi.message.create.assert_called_once_with(
"POST_ATTACH_SCAN_FAILED", 2, 'SR', 'dummy uuid', mock.ANY)
def load(self, sr_uuid):
if not sr_uuid:
# This is a probe call, generate a temp sr_uuid
sr_uuid = util.gen_uuid()
driver = SR.driver('iscsi')
self.iscsi = driver(self.original_srcmd, sr_uuid)
# Be extremely careful not to throw exceptions here since this function
# is the main one used by all operations including probing and creating
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
except:
pass
if not self.dconf.has_key('SCSIid') and self.dconf.has_key(
'LUNid') and pbd <> None:
# UPGRADE FROM RIO: add SCSIid key to device_config
util.SMlog("Performing upgrade from Rio")
scsiid = self._getSCSIid_from_LUN(sr_uuid)
device_config = self.session.xenapi.PBD.get_device_config(pbd)
device_config['SCSIid'] = scsiid
device_config['upgraded_from_rio'] = 'true'
self.session.xenapi.PBD.set_device_config(pbd, device_config)
self.dconf['SCSIid'] = scsiid
# Apart from the upgrade case, user must specify a SCSIid
if not self.dconf.has_key('SCSIid'):
self._LUNprint(sr_uuid)
raise xs_errors.XenError('ConfigSCSIid')
self.SCSIid = self.dconf['SCSIid']
self._pathrefresh(LVMoISCSISR)
super(LVMoISCSISR, self).load(sr_uuid)
def load(self, sr_uuid):
driver = SR.driver('hba')
self.hbasr = driver(self.original_srcmd, sr_uuid)
# If this is a vdi command, don't initialise SR
if not (util.isVDICommand(self.original_srcmd.cmd)):
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
except:
pass
try:
if not self.dconf.has_key('SCSIid') and self.dconf.has_key('device'):
# UPGRADE FROM MIAMI: add SCSIid key to device_config
util.SMlog("Performing upgrade from Miami")
if not os.path.exists(self.dconf['device']):
raise xs_errors.XenError('InvalidDev')
SCSIid = scsiutil.getSCSIid(self.dconf['device'])
self.dconf['SCSIid'] = SCSIid
del self.dconf['device']
if pbd <> None:
device_config = self.session.xenapi.PBD.get_device_config(pbd)
device_config['SCSIid'] = SCSIid
device_config['upgraded_from_miami'] = 'true'
del device_config['device']
self.session.xenapi.PBD.set_device_config(pbd, device_config)
except:
pass
if not self.dconf.has_key('SCSIid') or not self.dconf['SCSIid']:
print >>sys.stderr,self.hbasr.print_devs()
raise xs_errors.XenError('ConfigSCSIid')
self.SCSIid = self.dconf['SCSIid']
self._pathrefresh(LVHDoHBASR, load = False)
LVHDSR.LVHDSR.load(self, sr_uuid)
def load(self, sr_uuid):
if not sr_uuid:
# This is a probe call, generate a temp sr_uuid
sr_uuid = util.gen_uuid()
driver = SR.driver('iscsi')
self.iscsi = driver(self.original_srcmd, sr_uuid)
# Be extremely careful not to throw exceptions here since this function
# is the main one used by all operations including probing and creating
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
except:
pass
if not self.dconf.has_key('SCSIid') and self.dconf.has_key('LUNid') and pbd <> None:
# UPGRADE FROM RIO: add SCSIid key to device_config
util.SMlog("Performing upgrade from Rio")
scsiid = self._getSCSIid_from_LUN(sr_uuid)
device_config = self.session.xenapi.PBD.get_device_config(pbd)
device_config['SCSIid'] = scsiid
device_config['upgraded_from_rio'] = 'true'
self.session.xenapi.PBD.set_device_config(pbd, device_config)
self.dconf['SCSIid'] = scsiid
# Apart from the upgrade case, user must specify a SCSIid
if not self.dconf.has_key('SCSIid'):
self._LUNprint(sr_uuid)
raise xs_errors.XenError('ConfigSCSIid')
self.SCSIid = self.dconf['SCSIid']
self._pathrefresh(LVMoISCSISR)
super(LVMoISCSISR, self).load(sr_uuid)
def run(self):
global goal_pos, servo_command, init_get, functionMode
while self.__running.isSet():
self.__flag.wait()
if SR_mode:
voice_command = SR.run()
if voice_command == 'forward':
turn.turnMiddle()
move.move(speed_set, 'forward')
time.sleep(1)
move.motorStop()
elif voice_command == 'backward':
turn.turnMiddle()
move.move(speed_set, 'backward')
time.sleep(1)
move.motorStop()
elif voice_command == 'left':
servo.turnLeft()
move.move(speed_set, 'forward')
time.sleep(1)
turn.turnMiddle()
move.motorStop()
elif voice_command == 'right':
servo.turnRight()
move.move(speed_set, 'forward')
time.sleep(1)
turn.turnMiddle()
move.motorStop()
elif voice_command == 'stop':
turn.turnMiddle()
move.motorStop()
else:
self.pause()
def load(self, sr_uuid):
driver = SR.driver("hba")
self.hbasr = driver(self.original_srcmd, sr_uuid)
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
except:
pass
try:
if not self.dconf.has_key("SCSIid") and self.dconf.has_key("device"):
# UPGRADE FROM MIAMI: add SCSIid key to device_config
util.SMlog("Performing upgrade from Miami")
if not os.path.exists(self.dconf["device"]):
raise
SCSIid = scsiutil.getSCSIid(self.dconf["device"])
self.dconf["SCSIid"] = SCSIid
del self.dconf["device"]
if pbd <> None:
device_config = self.session.xenapi.PBD.get_device_config(pbd)
device_config["SCSIid"] = SCSIid
device_config["upgraded_from_miami"] = "true"
del device_config["device"]
self.session.xenapi.PBD.set_device_config(pbd, device_config)
except:
pass
if not self.dconf.has_key("SCSIid") or not self.dconf["SCSIid"]:
print >>sys.stderr, self.hbasr.print_devs()
raise xs_errors.XenError("ConfigSCSIid")
self.SCSIid = self.dconf["SCSIid"]
self._pathrefresh(LVMoHBASR)
super(LVMoHBASR, self).load(sr_uuid)
def main():
command = SRCommand.SRCommand()
command.parse("")
if not command.type:
raise SRCommand.SRInvalidArgumentException( \
'missing driver type argument: -t <type>')
if not command.dconf:
raise SRCommand.SRInvalidArgumentException('missing dconf string')
if not command.cmdname:
raise SRCommand.SRInvalidArgumentException('missing command')
if not command.sr_uuid:
raise SRCommand.SRInvalidArgumentException('missing SR UUID')
if command.cmdtype == 'vdi' and not command.vdi_uuid:
raise SRCommand.SRInvalidArgumentException('missing VDI UUID')
if not command.cmd:
raise SRCommand.SRInvalidArgumentException('unknown command')
if command.args is None:
raise SRCommand.SRInvalidArgumentException('wrong number of arguments')
driver = SR.driver(command.type)
sr = driver(command.dconf, command.sr_uuid)
command.run(sr)
def load(self, sr_uuid):
if not sr_uuid:
# This is a probe call, generate a temp sr_uuid
sr_uuid = util.gen_uuid()
driver = SR.driver('iscsi')
if self.original_srcmd.dconf.has_key('target'):
self.original_srcmd.dconf['targetlist'] = self.original_srcmd.dconf['target']
iscsi = driver(self.original_srcmd, sr_uuid)
self.iscsiSRs = []
self.iscsiSRs.append(iscsi)
if self.dconf['target'].find(',') == 0 or self.dconf['targetIQN'] == "*":
# Instantiate multiple sessions
self.iscsiSRs = []
if self.dconf['targetIQN'] == "*":
IQN = "any"
else:
IQN = self.dconf['targetIQN']
dict = {}
IQNstring = ""
IQNs = []
try:
if self.dconf.has_key('multiSession'):
IQNs = self.dconf['multiSession'].split("|")
for IQN in IQNs:
if IQN:
dict[IQN] = ""
else:
try:
IQNs.remove(IQN)
except:
# Exceptions are not expected but just in case
pass
# Order in multiSession must be preserved. It is important for dual-controllers.
# IQNstring cannot be built with a dictionary iteration because of this
IQNstring = self.dconf['multiSession']
else:
for tgt in self.dconf['target'].split(','):
try:
tgt_ip = util._convertDNS(tgt)
except:
raise xs_errors.XenError('DNSError')
iscsilib.ensure_daemon_running_ok(iscsi.localIQN)
map = iscsilib.discovery(tgt_ip,iscsi.port,iscsi.chapuser,iscsi.chappassword,targetIQN=IQN)
util.SMlog("Discovery for IP %s returned %s" % (tgt,map))
for i in range(0,len(map)):
(portal,tpgt,iqn) = map[i]
(ipaddr, port) = iscsilib.parse_IP_port(portal)
try:
util._testHost(ipaddr, long(port), 'ISCSITarget')
except:
util.SMlog("Target Not reachable: (%s:%s)" % (ipaddr, port))
continue
key = "%s,%s,%s" % (ipaddr,port,iqn)
dict[key] = ""
# Again, do not mess up with IQNs order. Dual controllers will benefit from that
if IQNstring == "":
# Compose the IQNstring first
for key in dict.iterkeys(): IQNstring += "%s|" % key
# Reinitialize and store iterator
key_iterator = dict.iterkeys()
else:
key_iterator = IQNs
# Now load the individual iSCSI base classes
for key in key_iterator:
(ipaddr,port,iqn) = key.split(',')
srcmd_copy = copy.deepcopy(self.original_srcmd)
srcmd_copy.dconf['target'] = ipaddr
srcmd_copy.dconf['targetIQN'] = iqn
srcmd_copy.dconf['multiSession'] = IQNstring
util.SMlog("Setting targetlist: %s" % srcmd_copy.dconf['targetlist'])
self.iscsiSRs.append(driver(srcmd_copy, sr_uuid))
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
if pbd <> None and not self.dconf.has_key('multiSession'):
dconf = self.session.xenapi.PBD.get_device_config(pbd)
dconf['multiSession'] = IQNstring
self.session.xenapi.PBD.set_device_config(pbd, dconf)
except:
util.logException("LVHDoISCSISR.load")
self.iscsi = self.iscsiSRs[0]
# Be extremely careful not to throw exceptions here since this function
# is the main one used by all operations including probing and creating
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
except:
pass
# Apart from the upgrade case, user must specify a SCSIid
if not self.dconf.has_key('SCSIid'):
# Dual controller issue
self.LUNs = {} # Dict for LUNs from all the iscsi objects
for ii in range(0, len(self.iscsiSRs)):
self.iscsi = self.iscsiSRs[ii]
self._LUNprint(sr_uuid)
for key in self.iscsi.LUNs:
self.LUNs[key] = self.iscsi.LUNs[key]
self.print_LUNs_XML()
self.iscsi = self.iscsiSRs[0] # back to original value
raise xs_errors.XenError('ConfigSCSIid')
self.SCSIid = self.dconf['SCSIid']
# This block checks if the first iscsi target contains the right SCSIid.
# If not it scans the other iscsi targets because chances are that more
# than one controller is present
dev_match = False
forced_login = False
# No need to check if only one iscsi target is present
if len(self.iscsiSRs) == 1:
pass
else:
target_success = False
attempt_discovery = False
for iii in range(0, len(self.iscsiSRs)):
# Check we didn't leave any iscsi session open
# If exceptions happened before, the cleanup function has worked on the right target.
if forced_login == True:
try:
iscsilib.ensure_daemon_running_ok(self.iscsi.localIQN)
iscsilib.logout(self.iscsi.target, self.iscsi.targetIQN)
forced_login = False
except:
raise xs_errors.XenError('ISCSILogout')
self.iscsi = self.iscsiSRs[iii]
util.SMlog("path %s" %self.iscsi.path)
util.SMlog("iscsci data: targetIQN %s, portal %s" % (self.iscsi.targetIQN, self.iscsi.target))
iscsilib.ensure_daemon_running_ok(self.iscsi.localIQN)
if not iscsilib._checkTGT(self.iscsi.targetIQN):
attempt_discovery = True
try:
# Ensure iscsi db has been populated
map = iscsilib.discovery(
self.iscsi.target,
self.iscsi.port,
self.iscsi.chapuser,
self.iscsi.chappassword,
targetIQN=self.iscsi.targetIQN)
if len(map) == 0:
util.SMlog("Discovery for iscsi data targetIQN %s,"
" portal %s returned empty list"
" Trying another path if available" %
(self.iscsi.targetIQN,
self.iscsi.target))
continue
except:
util.SMlog("Discovery failed for iscsi data targetIQN"
" %s, portal %s. Trying another path if"
" available" %
(self.iscsi.targetIQN, self.iscsi.target))
continue
try:
iscsilib.login(self.iscsi.target,
self.iscsi.targetIQN,
self.iscsi.chapuser,
self.iscsi.chappassword,
self.iscsi.incoming_chapuser,
self.iscsi.incoming_chappassword,
self.mpath == "true")
except:
util.SMlog("Login failed for iscsi data targetIQN %s,"
" portal %s. Trying another path"
" if available" %
(self.iscsi.targetIQN, self.iscsi.target))
continue
target_success = True;
forced_login = True
# A session should be active.
if not util.wait_for_path(self.iscsi.path, ISCSISR.MAX_TIMEOUT):
util.SMlog("%s has no associated LUNs" % self.iscsi.targetIQN)
continue
scsiid_path = "/dev/disk/by-id/scsi-" + self.SCSIid
if not util.wait_for_path(scsiid_path, ISCSISR.MAX_TIMEOUT):
util.SMlog("%s not found" %scsiid_path)
continue
for file in filter(self.iscsi.match_lun, util.listdir(self.iscsi.path)):
lun_path = os.path.join(self.iscsi.path,file)
lun_dev = scsiutil.getdev(lun_path)
try:
lun_scsiid = scsiutil.getSCSIid(lun_dev)
except:
util.SMlog("getSCSIid failed on %s in iscsi %s: LUN"
" offline or iscsi path down" %
(lun_dev, self.iscsi.path))
continue
util.SMlog("dev from lun %s %s" %(lun_dev, lun_scsiid))
if lun_scsiid == self.SCSIid:
util.SMlog("lun match in %s" %self.iscsi.path)
dev_match = True
# No more need to raise ISCSITarget exception.
# Resetting attempt_discovery
attempt_discovery = False
break
if dev_match:
if iii == 0:
break
util.SMlog("IQN reordering needed")
new_iscsiSRs = []
IQNs = {}
IQNstring = ""
# iscsiSRs can be seen as a circular buffer: the head now is the matching one
for kkk in range(iii, len(self.iscsiSRs)) + range(0, iii):
new_iscsiSRs.append(self.iscsiSRs[kkk])
ipaddr = self.iscsiSRs[kkk].target
port = self.iscsiSRs[kkk].port
iqn = self.iscsiSRs[kkk].targetIQN
key = "%s,%s,%s" % (ipaddr,port,iqn)
# The final string must preserve the order without repetition
if not IQNs.has_key(key):
IQNs[key] = ""
IQNstring += "%s|" % key
util.SMlog("IQNstring is now %s" %IQNstring)
self.iscsiSRs = new_iscsiSRs
util.SMlog("iqn %s is leading now" %self.iscsiSRs[0].targetIQN)
# Updating pbd entry, if any
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
if pbd <> None and self.dconf.has_key('multiSession'):
util.SMlog("Updating multiSession in PBD")
dconf = self.session.xenapi.PBD.get_device_config(pbd)
dconf['multiSession'] = IQNstring
self.session.xenapi.PBD.set_device_config(pbd, dconf)
except:
pass
break
if not target_success and attempt_discovery:
raise xs_errors.XenError('ISCSITarget')
# Check for any unneeded open iscsi sessions
if forced_login == True:
try:
iscsilib.ensure_daemon_running_ok(self.iscsi.localIQN)
iscsilib.logout(self.iscsi.target, self.iscsi.targetIQN)
forced_login = False
except:
raise xs_errors.XenError('ISCSILogout')
self._pathrefresh(LVHDoISCSISR, load = False)
LVHDSR.LVHDSR.load(self, sr_uuid)
raise xs_errors.XenError('VDIUnavailable')
resp = {}
resp['device_config'] = self.sr.dconf
resp['sr_uuid'] = sr_uuid
resp['vdi_uuid'] = vdi_uuid
resp['sr_sm_config'] = self.sr.sm_config
resp['command'] = 'vdi_attach_from_config'
# Return the 'config' encoded within a normal XMLRPC response so that
# we can use the regular response/error parsing code.
config = xmlrpclib.dumps(tuple([resp]), "vdi_attach_from_config")
return xmlrpclib.dumps((config, ), "", 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("SMBFileVDI.attach_from_config")
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')
if __name__ == '__main__':
SRCommand.run(SMBSR, DRIVER_INFO)
else:
SR.registerSR(SMBSR)
#
resp['device_config'] = self.sr.dconf
resp['sr_uuid'] = sr_uuid
resp['vdi_uuid'] = vdi_uuid
resp['command'] = 'vdi_attach_from_config'
# Return the 'config' encoded within a normal XMLRPC response so that
# we can use the regular response/error parsing code.
config = xmlrpclib.dumps(tuple([resp]), "vdi_attach_from_config")
return xmlrpclib.dumps((config,), "", True)
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'
)
if __name__ == '__main__':
SRCommand.run(FileSR, DRIVER_INFO)
else:
SR.registerSR(FileSR)
def train_continuous_model(input_list, continuous_words, number_of_states_for_each_word=5):
number_of_frames_in_each_state_for_each_template = []
number_of_words = len(continuous_words) + 2 # 2为首尾的silence
number_of_states = number_of_states_for_each_word * (number_of_words)
number_of_frames_in_each_state = [] # 第i个元素代表state i的frame数
template = []
covariance_matrix_in_each_state = []
mean_in_each_state = []
for i in xrange(number_of_words):
if i == 0 or i == number_of_words - 1:
word = 10 # silence
else:
word = int(continuous_words[i - 1])
mfcc_list = SR.get_isolated_templates(word)
model = k_means(mfcc_list)
temp_number_of_frames_in_each_state = [0 for i in xrange(number_of_states_for_each_word)]
for number_of_frames_in_each_state_in_each_template in model[5]:
for i in xrange(number_of_states_for_each_word):
temp_number_of_frames_in_each_state[i] += number_of_frames_in_each_state_in_each_template[i]
number_of_frames_in_each_state.extend(temp_number_of_frames_in_each_state)
template.extend(model[0][0])
covariance_matrix_in_each_state.extend(model[2])
mean_in_each_state.extend(model[3])
for input_feature in input_list:
print len(template), len(input_feature)
last_state_index = [[[0, 0] for i in xrange(len(template))] for j in xrange(len(input_feature))]
cost_matrix = [[float('inf') for i in xrange(len(template))] for j in xrange(len(input_feature))]
cost_matrix[0][0] = get_mahalanobis_distance(covariance_matrix_in_each_state[0],
mean_in_each_state[0], input_feature[0])[1]
for i in xrange(1, len(input_feature)):
for j in xrange(len(template)):
if j == 0:
transform_list = [j]
else:
transform_list = [j - 1, j]
for last_state in transform_list:
edge_cost = (number_of_frames_in_each_state[j] - 10.0) / number_of_frames_in_each_state[
j] if j == last_state else 10.0 / number_of_frames_in_each_state[last_state]
new_cost = cost_matrix[i - 1][last_state] + edge_cost
if cost_matrix[i][j] > new_cost:
min_index = last_state
cost_matrix[i][j] = new_cost
cost_matrix[i][j] += get_mahalanobis_distance(covariance_matrix_in_each_state[j],
mean_in_each_state[j], input_feature[i])[1]
last_state_index[i][j] = [i - 1, min_index]
min_cost = min(
cost_matrix[len(input_feature) - 1][(len(template) - number_of_states_for_each_word):len(template)])
cur_index = cost_matrix[len(input_feature) - 1].index(min_cost)
path = []
i = len(input_feature) - 1
while i >= 0:
path.append(cur_index)
cur_index = last_state_index[i][cur_index][1]
i -= 1
print path
number_of_frames_in_each_state_in_one_template = [0 for i in xrange(number_of_states)]
for state in path:
number_of_frames_in_each_state_in_one_template[state] += 1
number_of_frames_in_each_state_for_each_template.append(number_of_frames_in_each_state_in_one_template)
print number_of_frames_in_each_state_for_each_template
trained_model = train_model(input_list, number_of_states, number_of_frames_in_each_state_for_each_template)
return trained_model
try:
util.pread2(["mkfs.ext3", "-F", self.remotepath])
except util.CommandException, inst:
raise xs_errors.XenError('LVMFilesystem', \
opterr='mkfs failed error %d' % inst.code)
#Update serial number string
scsiutil.add_serial_record(self.session, self.sr_ref, \
scsiutil.devlist_to_serialstring(self.root.split(',')))
def vdi(self, uuid, loadLocked = False):
if not loadLocked:
return EXTFileVDI(self, uuid)
return EXTFileVDI(self, uuid)
class EXTFileVDI(FileSR.FileVDI):
def attach(self, sr_uuid, vdi_uuid):
if not hasattr(self,'xenstore_data'):
self.xenstore_data = {}
self.xenstore_data["storage-type"]="ext"
return super(EXTFileVDI, self).attach(sr_uuid, vdi_uuid)
if __name__ == '__main__':
SRCommand.run(EXTSR, DRIVER_INFO)
else:
SR.registerSR(EXTSR)
count += 1
return count
def _getLUNbySMconfig(self, sm_config):
raise xs_errors.XenError('VDIUnavailable')
def vdi(self, uuid):
return LUNperVDI.RAWVDI(self, uuid)
def srlist_toxml(self, SRs):
dom = xml.dom.minidom.Document()
element = dom.createElement("SRlist")
dom.appendChild(element)
for val in SRs:
record = SRs[val]
entry = dom.createElement('SR')
element.appendChild(entry)
subentry = dom.createElement("UUID")
entry.appendChild(subentry)
textnode = dom.createTextNode(val)
subentry.appendChild(textnode)
return dom.toprettyxml()
if __name__ == '__main__':
SRCommand.run(HBASR, DRIVER_INFO)
else:
SR.registerSR(HBASR)
raise xs_errors.XenError('VDIUnavailable')
resp = {}
resp['device_config'] = self.sr.dconf
resp['sr_uuid'] = sr_uuid
resp['vdi_uuid'] = vdi_uuid
resp['sr_sm_config'] = self.sr.sm_config
resp['command'] = 'vdi_attach_from_config'
# Return the 'config' encoded within a normal XMLRPC response so that
# we can use the regular response/error parsing code.
config = xmlrpclib.dumps(tuple([resp]), "vdi_attach_from_config")
return xmlrpclib.dumps((config,), "", 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("CIFSFileVDI.attach_from_config")
try:
if not util.pathexists(self.sr.path):
self.sr.attach(sr_uuid)
except:
util.logException("CIFSFileVDI.attach_from_config")
raise xs_errors.XenError('SRUnavailable', \
opterr='Unable to attach from config')
if __name__ == '__main__':
SRCommand.run(CIFSSR, DRIVER_INFO)
else:
SR.registerSR(CIFSSR)
#
self.sr.update(sr_uuid)
return super(udevVDI, self).get_params()
def update(self, sr_uuid, vdi_location):
self.load(vdi_location)
# _db_update requires self.uuid to be set
self.uuid = self.sr.srcmd.params['vdi_uuid']
self._db_update()
# also reset the name-label and description since we're a bit of
# a special SR
# this would lead to an infinite loop as VDI.set_name_label now
# calls VDI.update
# temporarily commenting this to pass quicktest
#vdi = self.sr.session.xenapi.VDI.get_by_uuid(self.uuid)
#self.sr.session.xenapi.VDI.set_name_label(vdi, self.label)
#self.sr.session.xenapi.VDI.set_name_description(vdi, self.description)
def attach(self, sr_uuid, vdi_uuid):
if self.deleted:
raise xs_errors.XenError('VDIUnavailable')
return super(udevVDI, self).attach(sr_uuid, vdi_uuid)
def detach(self, sr_uuid, vdi_uuid):
pass
if __name__ == '__main__':
SRCommand.run(udevSR, DRIVER_INFO)
else:
SR.registerSR(udevSR)
driver = SR.driver('hba')
if 'type' not in self.original_srcmd.params['device_config'] or \
'type' in self.original_srcmd.params['device_config'] and \
self.original_srcmd.dconf['type'] == "any":
self.original_srcmd.dconf['type'] = "fcoe"
self.hbasr = driver(self.original_srcmd, sr_uuid)
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
except:
pass
if 'SCSIid' not in self.dconf or not self.dconf['SCSIid']:
print(self.hbasr.print_devs(), file=sys.stderr)
raise xs_errors.XenError('ConfigSCSIid')
self.SCSIid = self.dconf['SCSIid']
LVHDSR.LVHDSR.load(self, sr_uuid)
def vdi(self, uuid):
return LVHDoFCoEVDI(self, uuid)
class LVHDoFCoEVDI(LVHDoHBASR.LVHDoHBAVDI):
pass
if __name__ == '__main__':
SRCommand.run(LVHDoFCoESR, DRIVER_INFO)
else:
SR.registerSR(LVHDoFCoESR)
def vdiExists(self, vdi_path):
""" Reads first 8 bytes of the path and checks for the cookie """
fd = open(vdi_path)
cookie = fd.read(8)
fd.close()
if cookie == VHD_COOKIE:
return True
return False
def _get_vdi_from_xapi(self, vdi_uuid):
vdi = {}
try:
vdi_ref = self.sr.session.xenapi.VDI.get_by_uuid(vdi_uuid)
vdi = self.sr.session.xenapi.VDI.get_record(vdi_ref)
except: # Can raise exception when creating a new VDI so it is not yet in the DB
pass
return vdi
if __name__ == '__main__':
SRCommand.run(VDILUNSR, DRIVER_INFO)
else:
SR.registerSR(VDILUNSR)
dict['device_config'] = self.sr.dconf
dict['sr_uuid'] = sr_uuid
dict['vdi_uuid'] = vdi_uuid
dict['allocation'] = self.sr.sm_config['allocation']
dict['command'] = 'vdi_attach_from_config'
# Return the 'config' encoded within a normal XMLRPC response so that
# we can use the regular response/error parsing code.
config = xmlrpclib.dumps(tuple([dict]), "vdi_attach_from_config")
return xmlrpclib.dumps((config,), "", True)
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 match_scsidev(s):
regex = re.compile("^/dev/disk/by-id|^/dev/mapper")
return regex.search(s, 0)
if __name__ == '__main__':
SRCommand.run(LVHDoHBASR, DRIVER_INFO)
else:
SR.registerSR(LVHDoHBASR)
util.SMlog("OCFSFileVDI.generate_config")
if not util.pathexists(self.path):
raise xs_errors.XenError('VDIUnavailable')
resp = {}
resp['device_config'] = self.sr.dconf
resp['sr_uuid'] = sr_uuid
resp['vdi_uuid'] = vdi_uuid
resp['command'] = 'vdi_attach_from_config'
# Return the 'config' encoded within a normal XMLRPC response so that
# we can use the regular response/error parsing code.
config = xmlrpclib.dumps(tuple([resp]), "vdi_attach_from_config")
return xmlrpclib.dumps((config,), "", 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("OCFSFileVDI.attach_from_config")
try:
if not util.pathexists(self.sr.path):
self.sr.attach(sr_uuid)
except:
util.logException("OCFSFileVDI.attach_from_config")
raise xs_errors.XenError('SRUnavailable', \
opterr='Unable to attach from config')
if __name__ == '__main__':
SRCommand.run(OCFSSR, DRIVER_INFO)
else:
SR.registerSR(OCFSSR)
element.appendChild(entry)
subentry = dom.createElement("UUID")
entry.appendChild(subentry)
textnode = dom.createTextNode(val)
subentry.appendChild(textnode)
subentry = dom.createElement("Target")
entry.appendChild(subentry)
textnode = dom.createTextNode(record['target'])
subentry.appendChild(textnode)
subentry = dom.createElement("TargetIQN")
entry.appendChild(subentry)
textnode = dom.createTextNode(record['targetIQN'])
subentry.appendChild(textnode)
return dom.toprettyxml()
def match_lun(self, s):
regex = re.compile("_")
if regex.search(s,0):
return False
regex = re.compile("LUN")
return regex.search(s, 0)
if __name__ == '__main__':
SRCommand.run(ISCSISR, DRIVER_INFO)
else:
SR.registerSR(ISCSISR)
def delete(self, sr_uuid, vdi_uuid):
util.SMlog("Raw LUN VDI delete")
scsi_id = self.sm_config['SCSIid']
xapi_session = self.session.xenapi
# Cleaning up SR sm_config
scsi_key = "scsi-" + scsi_id
xapi_session.SR.remove_from_sm_config(self.sr.sr_ref, scsi_key)
def detach(self, sr_uuid, vdi_uuid):
scsi_id = self.sm_config['SCSIid']
xapi_session = self.session.xenapi
# Multipath disable
if self.sr.mpath == "true":
self.sr.mpathmodule.reset(scsi_id, explicit_unmap=True)
util.remove_mpathcount_field(self.sr.session, self.sr.host_ref,
self.sr.sr_ref, scsi_id)
# Get size from xapi db
vdi_ref = xapi_session.VDI.get_by_uuid(vdi_uuid)
size = int(xapi_session.VDI.get_virtual_size(vdi_ref))
self.sr.update_stats(-size)
if __name__ == '__main__':
SRCommand.run(RawHBASR, DRIVER_INFO)
else:
SR.registerSR(RawHBASR)
if 'type' not in self.original_srcmd.params['device_config'] or \
'type' in self.original_srcmd.params['device_config'] and \
self.original_srcmd.dconf['type'] == "any":
self.original_srcmd.dconf['type'] = "fcoe"
self.hbasr = driver(self.original_srcmd, sr_uuid)
pbd = None
try:
pbd = util.find_my_pbd(self.session, self.host_ref, self.sr_ref)
except:
pass
if not self.dconf.has_key('SCSIid') or not self.dconf['SCSIid']:
print >>sys.stderr, self.hbasr.print_devs()
raise xs_errors.XenError('ConfigSCSIid')
self.SCSIid = self.dconf['SCSIid']
self._pathrefresh(LVHDoFCoESR)
LVHDSR.LVHDSR.load(self, sr_uuid)
def vdi(self, uuid):
return LVHDoFCoEVDI(self, uuid)
class LVHDoFCoEVDI(LVHDoHBASR.LVHDoHBAVDI):
pass
if __name__ == '__main__':
SRCommand.run(LVHDoFCoESR, DRIVER_INFO)
else:
SR.registerSR(LVHDoFCoESR)
st = os.stat(self.path)
self.size = long(st.st_size)
self.utilisation = long(st.st_size)
except OSError, inst:
raise xs_errors.XenError('EIO', \
opterr='failed to star %s error is %d' % self.path % \
inst.sterror)
def create(self, sr_uuid, vdi_uuid, size):
# This is a no-op in this driver, VDI's will be introduced via
# separate call vdi_introduce
raise xs_errors.XenError('Unimplemented', \
opterr='VDI create unsupported')
def delete(self, sr_uuid, vdi_uuid):
raise xs_errors.XenError('Unimplemented', \
opterr='VDI delete unsupported')
def clone(self, sr_uuid, vdi_uuid):
raise xs_errors.XenError('Unimplemented', \
opterr='VDI clone unsupported')
def snapshot(self, sr_uuid, vdi_uuid):
raise xs_errors.XenError('Unimplemented', \
opterr='VDI snapshot unsupported')
if __name__ == '__main__':
SRCommand.run(RAWSR, DRIVER_INFO)
else:
SR.registerSR(RAWSR)
stat = os.stat(self.path)
self.utilisation = long(stat.st_size)
self.size = long(stat.st_size)
except:
pass
def __init__(self, mysr, uuid, filename):
self.uuid = uuid
VDI.VDI.__init__(self, mysr, None)
self.path = os.path.join(mysr.dconf['location'], filename)
self.label = filename
self.location = filename
self.vdi_type = 'file'
self.read_only = True
self.shareable = True
self.sm_config = {}
def detach(self, sr_uuid, vdi_uuid):
pass
def clone(self, sr_uuid, vdi_uuid):
return self.get_params()
def snapshot(self, sr_uuid, vdi_uuid):
return self.get_params()
if __name__ == '__main__':
SRCommand.run(SHMSR, DRIVER_INFO)
else:
SR.registerSR(SHMSR)
self.physical_size += obj.size
count += 1
return count
def _getLUNbySMconfig(self, sm_config):
raise xs_errors.XenError('VDIUnavailable')
def vdi(self, uuid):
return LUNperVDI.RAWVDI(self, uuid)
def srlist_toxml(self, SRs):
dom = xml.dom.minidom.Document()
element = dom.createElement("SRlist")
dom.appendChild(element)
for val in SRs:
record = SRs[val]
entry = dom.createElement('SR')
element.appendChild(entry)
subentry = dom.createElement("UUID")
entry.appendChild(subentry)
textnode = dom.createTextNode(val)
subentry.appendChild(textnode)
return dom.toprettyxml()
if __name__ == '__main__':
SRCommand.run(HBASR, DRIVER_INFO)
else:
SR.registerSR(HBASR)
dict['device_config'] = self.sr.dconf
if dict['device_config'].has_key('chappassword_secret'):
s = util.get_secret(self.session, dict['device_config']['chappassword_secret'])
del dict['device_config']['chappassword_secret']
dict['device_config']['chappassword'] = s
dict['sr_uuid'] = sr_uuid
dict['vdi_uuid'] = vdi_uuid
dict['command'] = 'vdi_attach_from_config'
# Return the 'config' encoded within a normal XMLRPC response so that
# we can use the regular response/error parsing code.
config = xmlrpclib.dumps(tuple([dict]), "vdi_attach_from_config")
return xmlrpclib.dumps((config,), "", True)
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')
if __name__ == '__main__':
SRCommand.run(OCFSoISCSISR, DRIVER_INFO)
else:
SR.registerSR(OCFSoISCSISR)
diskinfo = {}
cmd = [SR.TAPDISK_UTIL, "query", vhdutil.VDI_TYPE_VHD, "-vpf", path]
txt = util.pread(cmd).split('\n')
diskinfo['size'] = txt[0]
lst = [txt[1].split('/')[-1].replace(vhdutil.FILE_EXTN_VHD, "")]
for val in filter(util.exactmatch_uuid, lst):
diskinfo['parent'] = val
diskinfo['hidden'] = txt[2].split()[1]
return diskinfo
def _create(self, size, path):
cmd = [SR.TAPDISK_UTIL, "create", vhdutil.VDI_TYPE_VHD, size, path]
text = util.pread(cmd)
def _mark_hidden(self, path):
vhdutil.setHidden(path, True)
self.hidden = 1
def extractUuid(path):
fileName = os.path.basename(path)
uuid = fileName.replace(vhdutil.FILE_EXTN_VHD, "")
return uuid
extractUuid = staticmethod(extractUuid)
if __name__ == '__main__':
SRCommand.run(FileSR, DRIVER_INFO)
else:
SR.registerSR(FileSR)
def runSample(params):
#retrieving the given parameter
ccs=params[0]
tree=params[1]
extantAdjacencies=params[2]
adjacencyProbs=params[3]
alpha=params[4]
i=params[5]
extantAdjacencies_species_adj=params[6]
outputDirectory=params[7]
reconstructedMarkerCount=params[8]
allSampleReconstructionStatistic={}
dict_SCJ={}
#lock = multiprocessing.Lock()
#output text log
outLog="Sample: "+str(i)+"\n"
#start sampling method like in the Main.py
outLog+="Enumerate joint labelings...\n"
jointLabels, first = SR.enumJointLabelings(ccs)
outLog+="Check valid labels...\n"
validLabels, validAtNode = SR.validLabels(jointLabels, first)
#lock.acquire()
outLog+= "Compute ancestral labels with SR...\n"
topDown = SR.sampleLabelings(tree, ccs, validAtNode, extantAdjacencies, adjacencyProbs, alpha)
#lock.release()
reconstructedAdj = SR.reconstructedAdjacencies(topDown)
SR.outputReconstructedAdjacencies(reconstructedAdj, outputDirectory+"/reconstructed_adjacencies_" + str(i))
for node in reconstructedAdj:
# count for each adjaency on each internal node, how often this adjacencies over all samples occurs there
for adjacency in reconstructedAdj[node]:
#lock.acquire()
if (node,adjacency) in allSampleReconstructionStatistic:
allSampleReconstructionStatistic[(node,adjacency)] += 1
else:
allSampleReconstructionStatistic.update({(node,adjacency):1})
#lock.release()
outLog+="Scaffolding...\n"
scaffolds = scaffolding.scaffoldAdjacencies(reconstructedAdj)
undoubled = scaffolding.undoubleScaffolds(scaffolds)
scaffolding.outputUndoubledScaffolds(undoubled, outputDirectory+"/undoubled_scaffolds_" + str(i))
scaffolding.outputScaffolds(scaffolds, outputDirectory+"/doubled_scaffolds_" + str(i))
log=scaffolding.sanityCheckScaffolding(undoubled)
outLog+=log
for node in undoubled:
outLog+= str(node)+'\n'
markerCounter = 0
for scaffold in undoubled[node]:
first = scaffold[0]
last = scaffold[-1]
if not first == last:
markerCounter = markerCounter + len(scaffold)
else:
markerCounter = markerCounter + len(scaffold) - 1
outLog+= str(node) + " number of reconstructed undoubled marker in scaffolds: " + str(markerCounter)+'\n'
# number of reconstructed markerIds given by reconstructedMarkerCount
# singleton scaffolds number / number of not reconstructed marker
notReconstructedMarkerCount = reconstructedMarkerCount - markerCounter
# number of all scaffolds
allScaffoldCount = len(undoubled[node]) + notReconstructedMarkerCount
outLog+= str(node) + " number of singleton scaffolds (not reconstructed marker): " + str(
notReconstructedMarkerCount)+'\n'
outLog+= str(node) + " number of scaffolds: " + str(allScaffoldCount)+'\n'
#lock.acquire()
scj = calculate_SCJ(tree, reconstructedAdj, extantAdjacencies_species_adj)
outLog+="Single-Cut-or-Join-Distance: " + str(scj)+'\n'
dict_SCJ.update({'Sample_' + str(i): scj})
#lock.release()
return (allSampleReconstructionStatistic,dict_SCJ,outLog)
cephutils.VDI.update(self, sr_uuid, vdi_uuid)
sm_config = self.session.xenapi.VDI.get_sm_config(self_vdi_ref)
if sm_config.has_key('reverted'):
if sm_config['reverted'] == 'true':
del sm_config['reverted']
self.session.xenapi.VDI.set_sm_config(self_vdi_ref, sm_config)
else:
if has_snapshots == True:
for snapshot_uuid in self.snaps.keys():
util.SMlog("RBDVDI.update start setting snapshots")
snapshot_vdi_ref = self.session.xenapi.VDI.get_by_uuid(snapshot_uuid)
self.session.xenapi.VDI.set_name_label(snapshot_vdi_ref, self.session.xenapi.VDI.get_name_label(self_vdi_ref))
self.session.xenapi.VDI.set_name_description(snapshot_vdi_ref, self.session.xenapi.VDI.get_name_description(self_vdi_ref))
util.SMlog("RBDVDI.update finish setting snapshots")
else:
self_vdi_sm_config = self.session.xenapi.VDI.get_sm_config(self_vdi_ref)
base_vdi_uuid = self_vdi_sm_config["snapshot-of"]
base_vdi_ref = self.session.xenapi.VDI.get_by_uuid(base_vdi_uuid)
self.label=self.session.xenapi.VDI.get_name_label(base_vdi_ref)
self.description=self.session.xenapi.VDI.get_name_description(base_vdi_ref)
self.snaps = {}
self.snaps[vdi_uuid]=self.session.xenapi.VDI.get_snapshot_time(self_vdi_ref)
cephutils.VDI.update(self, sr_uuid, base_vdi_uuid)
if __name__ == '__main__':
SRCommand.run(RBDSR, DRIVER_INFO)
else:
SR.registerSR(RBDSR)
if dict['device_config'].has_key('chappassword_secret'):
s = util.get_secret(self.session, dict['device_config']['chappassword_secret'])
del dict['device_config']['chappassword_secret']
dict['device_config']['chappassword'] = s
dict['sr_uuid'] = sr_uuid
dict['vdi_uuid'] = vdi_uuid
dict['allocation'] = self.sr.sm_config['allocation']
dict['command'] = 'vdi_attach_from_config'
# Return the 'config' encoded within a normal XMLRPC response so that
# we can use the regular response/error parsing code.
config = xmlrpclib.dumps(tuple([dict]), "vdi_attach_from_config")
return xmlrpclib.dumps((config,), "", 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')
if __name__ == '__main__':
SRCommand.run(LVHDoISCSISR, DRIVER_INFO)
else:
SR.registerSR(LVHDoISCSISR)
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 clone(self, sr_uuid, vdi_uuid):
timestamp_before = int(util.get_mtime(self.sr.path))
ret = super(NFSFileVDI, self).clone(sr_uuid, vdi_uuid)
timestamp_after = int(util.get_mtime(self.sr.path))
if timestamp_after == timestamp_before:
util.SMlog("SR dir timestamp didn't change, updating")
timestamp_after += 1
os.utime(self.sr.path, (timestamp_after, timestamp_after))
return ret
class NFSFileVDINolock(NFSFileVDI):
def load(self, vdi_uuid):
self.lock = self.sr.lock
self._load(vdi_uuid)
if __name__ == '__main__':
SRCommand.run(NFSSR, DRIVER_INFO)
else:
SR.registerSR(NFSSR)
self.sr.dconf['multipathhandle'] = self.sr.mpathhandle
dict['device_config'] = self.sr.dconf
dict['sr_uuid'] = sr_uuid
dict['vdi_uuid'] = vdi_uuid
dict['command'] = 'vdi_attach_from_config'
# Return the 'config' encoded within a normal XMLRPC response so that
# we can use the regular response/error parsing code.
config = xmlrpclib.dumps(tuple([dict]), "vdi_attach_from_config")
return xmlrpclib.dumps((config,), "", True)
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 match_scsidev(s):
regex = re.compile("^/dev/disk/by-id|^/dev/mapper")
return regex.search(s, 0)
if __name__ == '__main__':
SRCommand.run(OCFSoHBASR, DRIVER_INFO)
else:
SR.registerSR(OCFSoHBASR)
