Beispiel #1
0
    def show_target(self, tid, iqn):
        if iqn is None:
            raise exception.InvalidParameterValue(
                err=_('valid iqn needed for show_target'))

        tid = self._get_target(iqn)
        if tid is None:
            raise exception.ISCSITargetHelperCommandFailed(
                error_message="Target not found")
Beispiel #2
0
    def remove_iscsi_target(self, tid, lun, vol_id, vol_name, **kwargs):
        disk_id = "%s%s" % (lun, vol_id.split('-')[-1])
        vol_uuid_file = vol_name
        if self.target_name is None:
            iqn = '%s%s' % (self.iscsi_target_prefix, vol_uuid_file)
        else:
            iqn = self.target_name

        if self.target_name is None:
            try:
                self.scst_execute('-noprompt', '-rem_target', iqn, '-driver',
                                  'iscsi')
            except putils.ProcessExecutionError as e:
                LOG.error(
                    "Failed to remove iscsi target for volume "
                    "id:%(vol_id)s: %(e)s", {
                        'vol_id': vol_id,
                        'e': e
                    })
                raise exception.ISCSITargetRemoveFailed(volume_id=vol_id)
            try:
                self.scst_execute('-noprompt', '-close_dev', "disk%s" % tid,
                                  '-handler', 'vdisk_fileio')
            except putils.ProcessExecutionError as e:
                LOG.error("Failed to close disk device %s", e)
                raise exception.ISCSITargetHelperCommandFailed(
                    error_message="Failed to close disk device for "
                    "SCST handler.")

            if self._get_target(iqn):
                try:
                    self.scst_execute('-noprompt', '-rem_target', iqn,
                                      '-driver', self.target_driver)
                except putils.ProcessExecutionError as e:
                    LOG.error(
                        "Failed to remove iscsi target for "
                        "volume id:%(vol_id)s: %(e)s", {
                            'vol_id': vol_id,
                            'e': e
                        })
                    raise exception.ISCSITargetRemoveFailed(volume_id=vol_id)
        else:
            if not int(lun) in self._get_luns_info():
                raise exception.ISCSITargetRemoveFailed(volume_id=vol_id)
            try:
                scst_group = "%s%s" % (self.remove_initiator_iqn,
                                       self.target_name)
                self.scst_execute('-noprompt', '-rem_lun', lun, '-driver',
                                  self.target_driver, '-target', iqn, '-group',
                                  scst_group)
            except putils.ProcessExecutionError as e:
                LOG.error("Failed to remove LUN %s", e)
                raise exception.ISCSITargetHelperCommandFailed(
                    error_message="Failed to remove LUN for SCST Target.")

            try:
                self.scst_execute('-noprompt', '-close_dev', disk_id,
                                  '-handler', 'vdisk_fileio')
            except putils.ProcessExecutionError as e:
                LOG.error("Failed to close disk device %s", e)
                raise exception.ISCSITargetHelperCommandFailed(
                    error_message="Failed to close disk device for "
                    "SCST handler.")

        self.scst_execute('-write_config', '/etc/scst.conf')
Beispiel #3
0
    def create_iscsi_target(self,
                            name,
                            vol_id,
                            tid,
                            lun,
                            path,
                            chap_auth=None):
        scst_group = "%s%s" % (self.initiator_iqn, self.target_name)
        vol_name = path.split("/")[3]
        try:
            (out, _err) = self.scst_execute('-noprompt', '-set_drv_attr',
                                            self.target_driver, '-attributes',
                                            'enabled=1')
            LOG.debug('StdOut from set driver attribute: %s', out)
        except putils.ProcessExecutionError as e:
            LOG.error("Failed to set attribute for enable target driver %s", e)
            raise exception.ISCSITargetHelperCommandFailed(
                error_message="Failed to enable SCST Target driver.")

        if self._get_target(name) is None:
            try:
                (out, _err) = self.scst_execute('-add_target', name, '-driver',
                                                self.target_driver)
                LOG.debug("StdOut from scstadmin create target: %s", out)
            except putils.ProcessExecutionError as e:
                LOG.error(
                    "Failed to create iscsi target for volume "
                    "id:%(vol_id)s: %(e)s", {
                        'vol_id': name,
                        'e': e
                    })
                raise exception.ISCSITargetCreateFailed(volume_id=vol_name)
            try:
                (out, _err) = self.scst_execute('-enable_target', name,
                                                '-driver', self.target_driver)
                LOG.debug("StdOut from scstadmin enable target: %s", out)
            except putils.ProcessExecutionError as e:
                LOG.error(
                    "Failed to set 'enable' attribute for "
                    "SCST target %s", e)
                raise exception.ISCSITargetHelperCommandFailed(
                    error_message="Failed to enable SCST Target.")
            if chap_auth and self.target_name:
                try:
                    chap_string = self._iscsi_authentication(
                        'IncomingUser='******'-noprompt',
                                                    '-set_tgt_attr', name,
                                                    '-driver',
                                                    self.target_driver,
                                                    '-attributes', chap_string)
                    LOG.debug(
                        "StdOut from scstadmin set target attribute:"
                        " %s.", out)
                except putils.ProcessExecutionError:
                    msg = _("Failed to set attribute 'Incoming user' for "
                            "SCST target.")
                    LOG.exception(msg)
                    raise exception.ISCSITargetHelperCommandFailed(
                        error_message=msg)

        if self.target_name:
            if self._get_group() is None:
                try:
                    (out, _err) = self.scst_execute('-add_group', scst_group,
                                                    '-driver',
                                                    self.target_driver,
                                                    '-target', name)
                    LOG.debug("StdOut from scstadmin create group: %s", out)
                except putils.ProcessExecutionError as e:
                    LOG.error("Failed to create group to SCST target %s", e)
                    raise exception.ISCSITargetHelperCommandFailed(
                        error_message="Failed to create group to SCST target.")
            try:
                (out, _err) = self.scst_execute('-add_init',
                                                self.initiator_iqn, '-driver',
                                                self.target_driver, '-target',
                                                name, '-group', scst_group)
                LOG.debug("StdOut from scstadmin add initiator: %s", out)
            except putils.ProcessExecutionError as e:
                LOG.error(
                    "Failed to add initiator to group "
                    " for SCST target %s", e)
                raise exception.ISCSITargetHelperCommandFailed(
                    error_message="Failed to add Initiator to group for "
                    "SCST target.")

        tid = self._get_target(name)
        if self.target_name is None:
            disk_id = "disk%s" % tid
        else:
            disk_id = "%s%s" % (lun, vol_id.split('-')[-1])

        try:
            self.scst_execute('-open_dev', disk_id, '-handler', 'vdisk_fileio',
                              '-attributes', 'filename=%s' % path)
        except putils.ProcessExecutionError as e:
            LOG.error("Failed to add device to handler %s", e)
            raise exception.ISCSITargetHelperCommandFailed(
                error_message="Failed to add device to SCST handler.")

        try:
            if self.target_name:
                self.scst_execute('-add_lun', lun, '-driver',
                                  self.target_driver, '-target', name,
                                  '-device', disk_id, '-group', scst_group)
            else:
                self.scst_execute('-add_lun', lun, '-driver',
                                  self.target_driver, '-target', name,
                                  '-device', disk_id)
        except putils.ProcessExecutionError as e:
            LOG.error(
                "Failed to add lun to SCST target "
                "id:%(vol_id)s: %(e)s", {
                    'vol_id': name,
                    'e': e
                })
            raise exception.ISCSITargetHelperCommandFailed(
                error_message="Failed to add LUN to SCST Target for "
                "volume " + vol_name)

            # SCST uses /etc/scst.conf as the default configuration when it
            # starts
        try:
            self.scst_execute('-write_config', '/etc/scst.conf')
        except putils.ProcessExecutionError as e:
            LOG.error("Failed to write in /etc/scst.conf.")
            raise exception.ISCSITargetHelperCommandFailed(
                error_message="Failed to write in /etc/scst.conf.")

        return tid