def _run(self, sr, target):
dconf_type = sr.dconf.get("type")
if not dconf_type or not NO_LOGGING.get(dconf_type) or \
not self.cmd in NO_LOGGING[dconf_type]:
if 'device_config' in self.params:
util.SMlog("%s %s" % (self.cmd, util.hidePasswdInParams(self.params,'device_config')))
else:
util.SMlog("%s %s" % (self.cmd, repr(self.params)))
caching_params = dict((k, self.params.get(k)) for k in \
[blktap2.VDI.CONF_KEY_ALLOW_CACHING,
blktap2.VDI.CONF_KEY_MODE_ON_BOOT,
blktap2.VDI.CONF_KEY_CACHE_SR,
blktap2.VDI.CONF_KEY_O_DIRECT])
if self.cmd == 'vdi_create':
# These are the fields owned by the backend, passed on the
# commandline:
# LVM SRs store their metadata in XML format. XML does not support
# all unicode characters, so we must check if the label or the
# description contain such characters. We must enforce this
# restriction to other SRs as well (even if they do allow these
# characters) in order to be consistent.
target.label = self.params['args'][1]
target.description = self.params['args'][2]
if not util.isLegalXMLString(target.label) \
or not util.isLegalXMLString(target.description):
raise xs_errors.XenError('IllegalXMLChar', \
opterr = 'The name and/or description you supplied contains one or more unsupported characters. The name and/or description must contain valid XML characters. See http://www.w3.org/TR/2004/REC-xml-20040204/#charsets for more information.')
target.ty = self.params['vdi_type']
target.metadata_of_pool = self.params['args'][3]
target.is_a_snapshot = self.params['args'][4] == "true"
target.snapshot_time = self.params['args'][5]
target.snapshot_of = self.params['args'][6]
target.read_only = self.params['args'][7] == "true"
return target.create(self.params['sr_uuid'], self.vdi_uuid, long(self.params['args'][0]))
elif self.cmd == 'vdi_update':
# Check for invalid XML characters, similar to VDI.create right
# above.
vdi_ref = sr.session.xenapi.VDI.get_by_uuid(self.vdi_uuid)
name_label = sr.session.xenapi.VDI.get_name_label(vdi_ref)
description = sr.session.xenapi.VDI.get_name_description(vdi_ref)
if not util.isLegalXMLString(name_label) \
or not util.isLegalXMLString(description):
raise xs_errors.XenError('IllegalXMLChar', \
opterr = 'The name and/or description you supplied contains one or more unsupported characters. The name and/or description must contain valid XML characters. See http://www.w3.org/TR/2004/REC-xml-20040204/#charsets for more information.')
return target.update(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_introduce':
target = sr.vdi(self.params['new_uuid'])
return target.introduce(self.params['sr_uuid'], self.params['new_uuid'])
elif self.cmd == 'vdi_delete':
return target.delete(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_attach':
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
writable = self.params['args'][0] == 'true'
return target.attach(self.params['sr_uuid'], self.vdi_uuid, writable, caching_params = caching_params)
elif self.cmd == 'vdi_detach':
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
return target.detach(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_snapshot':
return target.snapshot(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_clone':
return target.clone(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_resize':
return target.resize(self.params['sr_uuid'], self.vdi_uuid, long(self.params['args'][0]))
elif self.cmd == 'vdi_resize_online':
return target.resize_online(self.params['sr_uuid'], self.vdi_uuid, long(self.params['args'][0]))
elif self.cmd == 'vdi_activate':
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
writable = self.params['args'][0] == 'true'
return target.activate(self.params['sr_uuid'], self.vdi_uuid,
writable, caching_params)
elif self.cmd == 'vdi_deactivate':
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
return target.deactivate(self.params['sr_uuid'], self.vdi_uuid,
caching_params)
elif self.cmd == 'vdi_epoch_begin':
if caching_params.get(blktap2.VDI.CONF_KEY_MODE_ON_BOOT) != "reset":
return
if not "VDI_RESET_ON_BOOT/2" in self.driver_info['capabilities']:
raise xs_errors.XenError('Unimplemented')
return target.reset_leaf(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_epoch_end':
return
elif self.cmd == 'vdi_generate_config':
return target.generate_config(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_compose':
vdi1_uuid = sr.session.xenapi.VDI.get_uuid(self.params['args'][0])
return target.compose(self.params['sr_uuid'], vdi1_uuid, self.vdi_uuid)
elif self.cmd == 'vdi_attach_from_config':
try:
if self.params.has_key('allocation') \
and self.params['allocation'] == 'xlvhd':
os.environ['THIN_STATE_FILE_ATTACH'] = "true"
target.sr._write_vginfo(self.params['sr_uuid'])
ret = target.attach_from_config(self.params['sr_uuid'], self.vdi_uuid)
if not target.sr.driver_config.get("ATTACH_FROM_CONFIG_WITH_TAPDISK"):
return ret
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
return target.attach(self.params['sr_uuid'], self.vdi_uuid, True, True)
finally:
os.unsetenv('THIN_STATE_FILE_ATTACH')
elif self.cmd == 'sr_create':
return sr.create(self.params['sr_uuid'], long(self.params['args'][0]))
elif self.cmd == 'sr_delete':
return sr.delete(self.params['sr_uuid'])
elif self.cmd == 'sr_update':
return sr.update(self.params['sr_uuid'])
elif self.cmd == 'sr_probe':
txt = sr.probe()
util.SMlog( "sr_probe result: %s" % util.splitXmlText( txt, showContd=True ) )
# return the XML document as a string
return xmlrpclib.dumps((txt,), "", True)
elif self.cmd == 'sr_attach':
is_master = False
if sr.dconf.get("SRmaster") == "true":
is_master = True
resetvdis.reset_sr(sr.session, util.get_this_host(),
self.params['sr_uuid'], is_master)
if is_master:
# Schedule a scan only when attaching on the SRmaster
util.set_dirty(sr.session, self.params["sr_ref"])
return sr.attach(self.params['sr_uuid'])
elif self.cmd == 'sr_detach':
return sr.detach(self.params['sr_uuid'])
elif self.cmd == 'sr_content_type':
return sr.content_type(self.params['sr_uuid'])
elif self.cmd == 'sr_scan':
return sr.scan(self.params['sr_uuid'])
else:
util.SMlog("Unknown command: %s" % self.cmd)
raise xs_errors.XenError('BadRequest')
def _run(self, sr, target):
dconf_type = sr.dconf.get("type")
if not dconf_type or not NO_LOGGING.get(dconf_type) or \
not self.cmd in NO_LOGGING[dconf_type]:
if 'device_config' in self.params:
util.SMlog(
"%s %s" %
(self.cmd,
util.hidePasswdInParams(self.params, 'device_config')))
else:
util.SMlog("%s %s" % (self.cmd, repr(self.params)))
caching_params = dict((k, self.params.get(k)) for k in \
[blktap2.VDI.CONF_KEY_ALLOW_CACHING,
blktap2.VDI.CONF_KEY_MODE_ON_BOOT,
blktap2.VDI.CONF_KEY_CACHE_SR,
blktap2.VDI.CONF_KEY_O_DIRECT])
if self.cmd == 'vdi_create':
# These are the fields owned by the backend, passed on the
# commandline:
# LVM SRs store their metadata in XML format. XML does not support
# all unicode characters, so we must check if the label or the
# description contain such characters. We must enforce this
# restriction to other SRs as well (even if they do allow these
# characters) in order to be consistent.
target.label = self.params['args'][1]
target.description = self.params['args'][2]
if not util.isLegalXMLString(target.label) \
or not util.isLegalXMLString(target.description):
raise xs_errors.XenError('IllegalXMLChar', \
opterr = 'The name and/or description you supplied contains one or more unsupported characters. The name and/or description must contain valid XML characters. See http://www.w3.org/TR/2004/REC-xml-20040204/#charsets for more information.')
target.ty = self.params['vdi_type']
target.metadata_of_pool = self.params['args'][3]
target.is_a_snapshot = self.params['args'][4] == "true"
target.snapshot_time = self.params['args'][5]
target.snapshot_of = self.params['args'][6]
target.read_only = self.params['args'][7] == "true"
return target.create(self.params['sr_uuid'], self.vdi_uuid,
long(self.params['args'][0]))
elif self.cmd == 'vdi_update':
# Check for invalid XML characters, similar to VDI.create right
# above.
vdi_ref = sr.session.xenapi.VDI.get_by_uuid(self.vdi_uuid)
name_label = sr.session.xenapi.VDI.get_name_label(vdi_ref)
description = sr.session.xenapi.VDI.get_name_description(vdi_ref)
if not util.isLegalXMLString(name_label) \
or not util.isLegalXMLString(description):
raise xs_errors.XenError('IllegalXMLChar', \
opterr = 'The name and/or description you supplied contains one or more unsupported characters. The name and/or description must contain valid XML characters. See http://www.w3.org/TR/2004/REC-xml-20040204/#charsets for more information.')
return target.update(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_introduce':
target = sr.vdi(self.params['new_uuid'])
return target.introduce(self.params['sr_uuid'],
self.params['new_uuid'])
elif self.cmd == 'vdi_delete':
if 'VDI_CONFIG_CBT' in util.sr_get_capability(
self.params['sr_uuid']):
return target.delete(self.params['sr_uuid'],
self.vdi_uuid,
data_only=False)
else:
return target.delete(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_attach':
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
writable = self.params['args'][0] == 'true'
return target.attach(self.params['sr_uuid'],
self.vdi_uuid,
writable,
caching_params=caching_params)
elif self.cmd == 'vdi_detach':
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
return target.detach(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_snapshot':
return target.snapshot(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_clone':
return target.clone(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_resize':
return target.resize(self.params['sr_uuid'], self.vdi_uuid,
long(self.params['args'][0]))
elif self.cmd == 'vdi_resize_online':
return target.resize_online(self.params['sr_uuid'], self.vdi_uuid,
long(self.params['args'][0]))
elif self.cmd == 'vdi_activate':
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
writable = self.params['args'][0] == 'true'
return target.activate(self.params['sr_uuid'], self.vdi_uuid,
writable, caching_params)
elif self.cmd == 'vdi_deactivate':
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
return target.deactivate(self.params['sr_uuid'], self.vdi_uuid,
caching_params)
elif self.cmd == 'vdi_epoch_begin':
if caching_params.get(
blktap2.VDI.CONF_KEY_MODE_ON_BOOT) != "reset":
return
if not "VDI_RESET_ON_BOOT/2" in self.driver_info['capabilities']:
raise xs_errors.XenError('Unimplemented')
return target.reset_leaf(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_epoch_end':
return
elif self.cmd == 'vdi_generate_config':
return target.generate_config(self.params['sr_uuid'],
self.vdi_uuid)
elif self.cmd == 'vdi_compose':
vdi1_uuid = sr.session.xenapi.VDI.get_uuid(self.params['args'][0])
return target.compose(self.params['sr_uuid'], vdi1_uuid,
self.vdi_uuid)
elif self.cmd == 'vdi_attach_from_config':
ret = target.attach_from_config(self.params['sr_uuid'],
self.vdi_uuid)
if not target.sr.driver_config.get(
"ATTACH_FROM_CONFIG_WITH_TAPDISK"):
return ret
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
return target.attach(self.params['sr_uuid'], self.vdi_uuid, True,
True)
elif self.cmd == 'vdi_detach_from_config':
extras = {}
if target.sr.driver_config.get("ATTACH_FROM_CONFIG_WITH_TAPDISK"):
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
extras['deactivate'] = True
extras['caching_params'] = caching_params
target.detach(self.params['sr_uuid'], self.vdi_uuid, **extras)
elif self.cmd == 'vdi_enable_cbt':
return target.configure_blocktracking(self.params['sr_uuid'],
self.vdi_uuid, True)
elif self.cmd == 'vdi_disable_cbt':
return target.configure_blocktracking(self.params['sr_uuid'],
self.vdi_uuid, False)
elif self.cmd == 'vdi_data_destroy':
return target.data_destroy(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_list_changed_blocks':
return target.list_changed_blocks()
elif self.cmd == 'sr_create':
return sr.create(self.params['sr_uuid'],
long(self.params['args'][0]))
elif self.cmd == 'sr_delete':
return sr.delete(self.params['sr_uuid'])
elif self.cmd == 'sr_update':
return sr.update(self.params['sr_uuid'])
elif self.cmd == 'sr_probe':
txt = sr.probe()
util.SMlog("sr_probe result: %s" %
util.splitXmlText(txt, showContd=True))
# return the XML document as a string
return xmlrpclib.dumps((txt, ), "", True)
elif self.cmd == 'sr_attach':
is_master = False
if sr.dconf.get("SRmaster") == "true":
is_master = True
resetvdis.reset_sr(sr.session, util.get_this_host(),
self.params['sr_uuid'], is_master)
if is_master:
# Schedule a scan only when attaching on the SRmaster
util.set_dirty(sr.session, self.params["sr_ref"])
return sr.attach(self.params['sr_uuid'])
elif self.cmd == 'sr_detach':
return sr.detach(self.params['sr_uuid'])
elif self.cmd == 'sr_content_type':
return sr.content_type(self.params['sr_uuid'])
elif self.cmd == 'sr_scan':
return sr.scan(self.params['sr_uuid'])
else:
util.SMlog("Unknown command: %s" % self.cmd)
raise xs_errors.XenError('BadRequest')
def run(self, sr):
util.SMlog("%s %s" % (self.cmd, repr(self.params)))
if self.cmd == 'vdi_create':
self.vdi_uuid = util.gen_uuid ()
target = sr.vdi(self.vdi_uuid)
return target.create(self.params['sr_uuid'], self.vdi_uuid, long(self.params['args'][0]))
elif self.cmd == 'vdi_update':
target = sr.vdi(self.vdi_uuid)
return target.update(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_introduce':
target = sr.vdi(self.params['new_uuid'])
return target.introduce(self.params['sr_uuid'], self.params['new_uuid'])
elif self.cmd == 'vdi_delete':
target = sr.vdi(self.vdi_uuid)
return target.delete(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_attach':
target = sr.vdi(self.vdi_uuid)
return target.attach(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_detach':
target = sr.vdi(self.vdi_uuid)
return target.detach(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_snapshot':
target = sr.vdi(self.vdi_uuid)
return target.snapshot(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_clone':
target = sr.vdi(self.vdi_uuid)
return target.clone(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_resize':
target = sr.vdi(self.vdi_uuid)
return target.resize(self.params['sr_uuid'], self.vdi_uuid, long(self.params['args'][0]))
elif self.cmd == 'vdi_resize_online':
target = sr.vdi(self.vdi_uuid)
return target.resize_online(self.params['sr_uuid'], self.vdi_uuid, long(self.params['args'][0]))
elif self.cmd == 'vdi_activate':
target = sr.vdi(self.vdi_uuid)
return target.activate(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_deactivate':
target = sr.vdi(self.vdi_uuid)
return target.deactivate(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_generate_config':
target = sr.vdi(self.vdi_uuid)
return target.generate_config(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_attach_from_config':
target = sr.vdi(self.vdi_uuid)
return target.attach_from_config(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'sr_create':
return sr.create(self.params['sr_uuid'], long(self.params['args'][0]))
elif self.cmd == 'sr_delete':
return sr.delete(self.params['sr_uuid'])
elif self.cmd == 'sr_update':
return sr.update(self.params['sr_uuid'])
elif self.cmd == 'sr_probe':
txt = sr.probe()
util.SMlog("sr_probe result: %s" % txt)
# return the XML document as a string
return xmlrpclib.dumps((txt,), "", True)
elif self.cmd == 'sr_attach':
# Schedule a scan only when attaching on the SRmaster
if sr.dconf.has_key("SRmaster") and self.dconf["SRmaster"] == "true":
util.set_dirty(sr.session, self.params["sr_ref"])
return sr.attach(self.params['sr_uuid'])
elif self.cmd == 'sr_detach':
return sr.detach(self.params['sr_uuid'])
elif self.cmd == 'sr_content_type':
return sr.content_type(self.params['sr_uuid'])
elif self.cmd == 'sr_scan':
return sr.scan(self.params['sr_uuid'])
else:
util.SMlog("Unknown command: %s" % self.cmd)
raise xs_errors.XenError('BadRequest')
def _run(self, sr, target):
dconf_type = sr.dconf.get("type")
if not dconf_type or not NO_LOGGING.get(dconf_type) or not self.cmd in NO_LOGGING[dconf_type]:
util.SMlog("%s %s" % (self.cmd, repr(self.params)))
caching_params = dict(
(k, self.params.get(k))
for k in [
blktap2.VDI.CONF_KEY_ALLOW_CACHING,
blktap2.VDI.CONF_KEY_MODE_ON_BOOT,
blktap2.VDI.CONF_KEY_CACHE_SR,
]
)
if self.cmd == "vdi_create":
# These are the fields owned by the backend, passed on the
# commandline:
target.label = self.params["args"][1]
target.description = self.params["args"][2]
target.ty = self.params["vdi_type"]
target.metadata_of_pool = self.params["args"][3]
target.is_a_snapshot = self.params["args"][4] == "true"
target.snapshot_time = self.params["args"][5]
target.snapshot_of = self.params["args"][6]
target.read_only = self.params["args"][7] == "true"
return target.create(self.params["sr_uuid"], self.vdi_uuid, long(self.params["args"][0]))
elif self.cmd == "vdi_update":
return target.update(self.params["sr_uuid"], self.vdi_uuid)
elif self.cmd == "vdi_introduce":
target = sr.vdi(self.params["new_uuid"])
return target.introduce(self.params["sr_uuid"], self.params["new_uuid"])
elif self.cmd == "vdi_delete":
return target.delete(self.params["sr_uuid"], self.vdi_uuid)
elif self.cmd == "vdi_attach":
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
writable = self.params["args"][0] == "true"
return target.attach(self.params["sr_uuid"], self.vdi_uuid, writable)
elif self.cmd == "vdi_detach":
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
return target.detach(self.params["sr_uuid"], self.vdi_uuid)
elif self.cmd == "vdi_snapshot":
return target.snapshot(self.params["sr_uuid"], self.vdi_uuid)
elif self.cmd == "vdi_clone":
return target.clone(self.params["sr_uuid"], self.vdi_uuid)
elif self.cmd == "vdi_resize":
return target.resize(self.params["sr_uuid"], self.vdi_uuid, long(self.params["args"][0]))
elif self.cmd == "vdi_resize_online":
return target.resize_online(self.params["sr_uuid"], self.vdi_uuid, long(self.params["args"][0]))
elif self.cmd == "vdi_activate":
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
writable = self.params["args"][0] == "true"
return target.activate(self.params["sr_uuid"], self.vdi_uuid, writable, caching_params)
elif self.cmd == "vdi_deactivate":
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
return target.deactivate(self.params["sr_uuid"], self.vdi_uuid, caching_params)
elif self.cmd == "vdi_generate_config":
return target.generate_config(self.params["sr_uuid"], self.vdi_uuid)
elif self.cmd == "vdi_attach_from_config":
ret = target.attach_from_config(self.params["sr_uuid"], self.vdi_uuid)
if not target.sr.driver_config.get("ATTACH_FROM_CONFIG_WITH_TAPDISK"):
return ret
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
return target.attach(self.params["sr_uuid"], self.vdi_uuid, True, True)
elif self.cmd == "sr_create":
return sr.create(self.params["sr_uuid"], long(self.params["args"][0]))
elif self.cmd == "sr_delete":
return sr.delete(self.params["sr_uuid"])
elif self.cmd == "sr_update":
return sr.update(self.params["sr_uuid"])
elif self.cmd == "sr_probe":
txt = sr.probe()
util.SMlog("sr_probe result: %s" % txt)
# return the XML document as a string
return xmlrpclib.dumps((txt,), "", True)
elif self.cmd == "sr_attach":
is_master = False
if sr.dconf.get("SRmaster") == "true":
is_master = True
resetvdis.reset(sr.session, util.get_this_host(), self.params["sr_uuid"], is_master)
if is_master:
# Schedule a scan only when attaching on the SRmaster
util.set_dirty(sr.session, self.params["sr_ref"])
return sr.attach(self.params["sr_uuid"])
elif self.cmd == "sr_detach":
return sr.detach(self.params["sr_uuid"])
elif self.cmd == "sr_content_type":
return sr.content_type(self.params["sr_uuid"])
elif self.cmd == "sr_scan":
return sr.scan(self.params["sr_uuid"])
else:
util.SMlog("Unknown command: %s" % self.cmd)
raise xs_errors.XenError("BadRequest")
def _run(self, sr, target):
dconf_type = sr.dconf.get("type")
if not dconf_type or not NO_LOGGING.get(dconf_type) or \
not self.cmd in NO_LOGGING[dconf_type]:
util.SMlog("%s %s" % (self.cmd, repr(self.params)))
caching_params = dict((k, self.params.get(k)) for k in \
[blktap2.VDI.CONF_KEY_ALLOW_CACHING,
blktap2.VDI.CONF_KEY_MODE_ON_BOOT,
blktap2.VDI.CONF_KEY_CACHE_SR])
if self.cmd == 'vdi_create':
# These are the fields owned by the backend, passed on the
# commandline:
target.label = self.params['args'][1]
target.description = self.params['args'][2]
target.ty = self.params['vdi_type']
target.metadata_of_pool = self.params['args'][3]
target.is_a_snapshot = self.params['args'][4] == "true"
target.snapshot_time = self.params['args'][5]
target.snapshot_of = self.params['args'][6]
target.read_only = self.params['args'][7] == "true"
return target.create(self.params['sr_uuid'], self.vdi_uuid,
long(self.params['args'][0]))
elif self.cmd == 'vdi_update':
return target.update(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_introduce':
target = sr.vdi(self.params['new_uuid'])
return target.introduce(self.params['sr_uuid'],
self.params['new_uuid'])
elif self.cmd == 'vdi_delete':
return target.delete(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_attach':
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
writable = self.params['args'][0] == 'true'
return target.attach(self.params['sr_uuid'], self.vdi_uuid,
writable)
elif self.cmd == 'vdi_detach':
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
return target.detach(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_snapshot':
return target.snapshot(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_clone':
return target.clone(self.params['sr_uuid'], self.vdi_uuid)
elif self.cmd == 'vdi_resize':
return target.resize(self.params['sr_uuid'], self.vdi_uuid,
long(self.params['args'][0]))
elif self.cmd == 'vdi_resize_online':
return target.resize_online(self.params['sr_uuid'], self.vdi_uuid,
long(self.params['args'][0]))
elif self.cmd == 'vdi_activate':
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
writable = self.params['args'][0] == 'true'
return target.activate(self.params['sr_uuid'], self.vdi_uuid,
writable, caching_params)
elif self.cmd == 'vdi_deactivate':
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
return target.deactivate(self.params['sr_uuid'], self.vdi_uuid,
caching_params)
elif self.cmd == 'vdi_generate_config':
return target.generate_config(self.params['sr_uuid'],
self.vdi_uuid)
elif self.cmd == 'vdi_attach_from_config':
ret = target.attach_from_config(self.params['sr_uuid'],
self.vdi_uuid)
if not target.sr.driver_config.get(
"ATTACH_FROM_CONFIG_WITH_TAPDISK"):
return ret
target = blktap2.VDI(self.vdi_uuid, target, self.driver_info)
return target.attach(self.params['sr_uuid'], self.vdi_uuid, True,
True)
elif self.cmd == 'sr_create':
return sr.create(self.params['sr_uuid'],
long(self.params['args'][0]))
elif self.cmd == 'sr_delete':
return sr.delete(self.params['sr_uuid'])
elif self.cmd == 'sr_update':
return sr.update(self.params['sr_uuid'])
elif self.cmd == 'sr_probe':
txt = sr.probe()
util.SMlog("sr_probe result: %s" % txt)
# return the XML document as a string
return xmlrpclib.dumps((txt, ), "", True)
elif self.cmd == 'sr_attach':
is_master = False
if sr.dconf.get("SRmaster") == "true":
is_master = True
resetvdis.reset(sr.session, util.get_this_host(),
self.params['sr_uuid'], is_master)
if is_master:
# Schedule a scan only when attaching on the SRmaster
util.set_dirty(sr.session, self.params["sr_ref"])
return sr.attach(self.params['sr_uuid'])
elif self.cmd == 'sr_detach':
return sr.detach(self.params['sr_uuid'])
elif self.cmd == 'sr_content_type':
return sr.content_type(self.params['sr_uuid'])
elif self.cmd == 'sr_scan':
return sr.scan(self.params['sr_uuid'])
else:
util.SMlog("Unknown command: %s" % self.cmd)
raise xs_errors.XenError('BadRequest')