nova/compute/api.py:API

    def _check_and_begin_detach(self, context, volume, instance):

        self.volume_api.check_detach(context, volume, instance=instance)

        self.volume_api.begin_detaching(context, volume['id'])

cinder/api/contrib/volume_actions.py:VolumeActionsController

    def _begin_detaching(self, req, id, body):

        """Update volume status to 'detaching'."""

        context = req.environ['cinder.context']

        # Not found exception will be handled at the wsgi level

        volume = self.volume_api.get(context, id)

        self.volume_api.begin_detaching(context, volume)

        return webob.Response(status_int=http_client.ACCEPTED)

该函数的主要作用是通过volume 的uuid，获取volume实例信息，并调用volume目录下的api模块

    @wrap_check_policy

    def begin_detaching(self, context, volume):

        # If we are in the middle of a volume migration, we don't want the

        # user to see that the volume is 'detaching'. Having

        # 'migration_status' set will have the same effect internally.

        expected = {'status': 'in-use',

                    'attach_status': fields.VolumeAttachStatus.ATTACHED,

                    'migration_status': self.AVAILABLE_MIGRATION_STATUS}

        result = volume.conditional_update({'status': 'detaching'}, expected)

        if not (result or self._is_volume_migrating(volume)):

            msg = _("Unable to detach volume. Volume status must be 'in-use' "

                    "and attach_status must be 'attached' to detach.")

            LOG.error(msg)

            raise exception.InvalidVolume(reason=msg)

        LOG.info(_LI("Begin detaching volume completed successfully."),

                 resource=volume)

def _detach_volume(self, context, volume_id, instance, destroy_bdm=True,attachment_id=None):

     ......

     self.volume_api.terminate_connection(context, volume_id, connector)

     ......

     self.volume_api.detach(context.elevated(), volume_id, instance.uuid,attachment_id)
     

   @wsgi.action('os-terminate_connection')

    def _terminate_connection(self, req, id, body):

        """Terminate volume attachment."""

        context = req.environ['cinder.context']

        # Not found exception will be handled at the wsgi level

        volume = self.volume_api.get(context, id)

        try:

            connector = body['os-terminate_connection']['connector']

        except KeyError:

            raise webob.exc.HTTPBadRequest(

                explanation=_("Must specify 'connector'"))

        try:

            self.volume_api.terminate_connection(context, volume, connector)

        except exception.VolumeBackendAPIException:

            msg = _("Unable to terminate volume connection from backend.")

            raise webob.exc.HTTPInternalServerError(explanation=msg)

        return webob.Response(status_int=http_client.ACCEPTED)
        

cinder/volume/api.py:API类

    @wrap_check_policy

    def terminate_connection(self, context, volume, connector, force=False):

       step : self.volume_rpcapi.terminate_connection(context,volume,connector,force)

       step  :self.unreserve_volume(context, volume)

   def terminate_connection(self, context, volume_id, connector, force=False):

        utils.require_driver_initialized(self.driver)----获取对应的驱动信息

        volume_ref = self.db.volume_get(context, volume_id)-----从数据库中获取卷的信息

        try:

            step 1.1 self.driver.terminate_connection(volume_ref, connector, force=force)-----调用对应的驱动的terminate_connection函数

    def terminate_connection(self, volume, connector, **kwargs):

        volume_iqn = volume['provider_location'].split(' ')[]

        # Delete initiator iqns from target ACL

        try:

            self._execute('cinder-rtstool', 'delete-initiator',

                          volume_iqn,

                          connector['initiator'],

                          run_as_root=True)

        except putils.ProcessExecutionError:

            LOG.exception(

                _LE("Failed to delete initiator iqn %s from target."),

                connector['initiator'])

            raise exception.ISCSITargetDetachFailed(volume_id=volume['id'])

        # We make changes persistent

        self._persist_configuration(volume['id'])

cinder/api/contrib/volume_actions.py

    @wsgi.action('os-detach')

    def _detach(self, req, id, body):

        volume = self.volume_api.get(context, id)

        attachment_id = None

        if body['os-detach']:

            attachment_id = body['os-detach'].get('attachment_id', None)

        try:

            self.volume_api.detach(context, volume, attachment_id)

cinder\volume\api.py

    @wrap_check_policy

    def detach(self, context, volume, attachment_id):

        if volume['status'] == 'maintenance':

            LOG.info(_LI('Unable to detach volume, '

                         'because it is in maintenance.'), resource=volume)

            msg = _("The volume cannot be detached in maintenance mode.")

            raise exception.InvalidVolume(reason=msg)

        detach_results = self.volume_rpcapi.detach_volume(context, volume,

                                                          attachment_id)

        LOG.info(_LI("Detach volume completed successfully."),

                 resource=volume)

        return detach_results

    @coordination.synchronized('{volume_id}-{f_name}')

    def detach_volume(self, context, volume_id, attachment_id=None,

                      volume=None):

        """Updates db to show volume is detached."""

        # TODO(vish): refactor this into a more general "unreserve"

        # FIXME(lixiaoy1): Remove this in v4. of RPC API.

        if volume is None:

            # For older clients, mimic the old behavior and look up the volume

            # by its volume_id.

            volume = objects.Volume.get_by_id(context, volume_id)

        if attachment_id:

            try:

                attachment = objects.VolumeAttachment.get_by_id(context,

                                                                attachment_id)

            except exception.VolumeAttachmentNotFound:

                LOG.info(_LI("Volume detach called, but volume not attached."),

                         resource=volume)

                # We need to make sure the volume status is set to the correct

                # status.  It could be in detaching status now, and we don't

                # want to leave it there.

                volume.finish_detach(attachment_id)

                return

        else:

            # We can try and degrade gracefully here by trying to detach

            # a volume without the attachment_id here if the volume only has

            # one attachment.  This is for backwards compatibility.

            attachments = volume.volume_attachment

            if len(attachments) > :

                # There are more than  attachments for this volume

                # we have to have an attachment id.

                msg = _("Detach volume failed: More than one attachment, "

                        "but no attachment_id provided.")

                LOG.error(msg, resource=volume)

                raise exception.InvalidVolume(reason=msg)

            elif len(attachments) == :

                attachment = attachments[]

            else:

                # there aren't any attachments for this volume.

                # so set the status to available and move on.

                LOG.info(_LI("Volume detach called, but volume not attached."),

                         resource=volume)

                volume.status = 'available'

                volume.attach_status = fields.VolumeAttachStatus.DETACHED

                volume.save()

                return

        self._notify_about_volume_usage(context, volume, "detach.start")

        try:

            # NOTE(flaper87): Verify the driver is enabled

            # before going forward. The exception will be caught

            # and the volume status updated.

            utils.require_driver_initialized(self.driver)

            LOG.info(_LI('Detaching volume %(volume_id)s from instance '

                         '%(instance)s.'),

                     {'volume_id': volume_id,

                      'instance': attachment.get('instance_uuid')},

                     resource=volume)

            self.driver.detach_volume(context, volume, attachment)

        except Exception as ex:

            with excutils.save_and_reraise_exception():

                self.db.volume_attachment_update(

                    context, attachment.get('id'), {

                        'attach_status':

                            fields.VolumeAttachStatus.ERROR_DETACHING})

            self.db.volume_metadata_update(context,

                                           volume_id,

                                           {'error': six.text_type(ex)},

                                           False)

        # NOTE(jdg): We used to do an ensure export here to

        # catch upgrades while volumes were attached (E->F)

        # this was necessary to convert in-use volumes from

        # int ID's to UUID's.  Don't need this any longer

        # We're going to remove the export here

        # (delete the iscsi target)

        try:

            utils.require_driver_initialized(self.driver)

            self.driver.remove_export(context.elevated(), volume)

        except exception.DriverNotInitialized:

            with excutils.save_and_reraise_exception():

                LOG.exception(_LE("Detach volume failed, due to "

                                  "uninitialized driver."),

                              resource=volume)

        except Exception as ex:

            LOG.exception(_LE("Detach volume failed, due to "

                              "remove-export failure."),

                          resource=volume)

            raise exception.RemoveExportException(volume=volume_id,

                                                  reason=six.text_type(ex))

        volume.finish_detach(attachment.id)

        self._notify_about_volume_usage(context, volume, "detach.end")

        LOG.info(_LI("Detach volume completed successfully."), resource=volume)