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")
Example #2
0
    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')             
Example #3
0
    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')