Пример #1
0
    def change_multiattach(extra_specs, new_type_extra_specs):
        """Check if a change in multiattach is required for retype.

        :param extra_specs: the source type extra specs
        :param new_type_extra_specs: the target type extra specs
        :return: bool
        """
        is_src_multiattach = volume_utils.is_boolean_str(
            extra_specs.get('multiattach'))
        is_tgt_multiattach = volume_utils.is_boolean_str(
            new_type_extra_specs.get('multiattach'))
        return is_src_multiattach != is_tgt_multiattach
Пример #2
0
    def create_volume(self, volume):
        """Driver entry point for creating a new volume (Data ONTAP LUN)."""

        LOG.debug('create_volume on %s', volume['host'])

        # get Data ONTAP volume name as pool name
        pool_name = volume_utils.extract_host(volume['host'], level='pool')

        if pool_name is None:
            msg = _("Pool is not available in the volume host field.")
            raise exception.InvalidHost(reason=msg)

        extra_specs = na_utils.get_volume_extra_specs(volume)

        lun_name = volume['name']

        size = int(volume['size']) * units.Gi

        metadata = {
            'OsType': self.lun_ostype,
            'SpaceReserved': self.lun_space_reservation,
            'Path': '/vol/%s/%s' % (pool_name, lun_name)
        }

        qos_policy_group_info = self._setup_qos_for_volume(volume, extra_specs)
        qos_policy_group_name = (na_utils.get_qos_policy_group_name_from_info(
            qos_policy_group_info))
        qos_policy_group_is_adaptive = volume_utils.is_boolean_str(
            extra_specs.get('netapp:qos_policy_group_is_adaptive'))

        try:
            self._create_lun(pool_name, lun_name, size, metadata,
                             qos_policy_group_name,
                             qos_policy_group_is_adaptive)
        except Exception:
            LOG.exception("Exception creating LUN %(name)s in pool %(pool)s.",
                          {
                              'name': lun_name,
                              'pool': pool_name
                          })
            self._mark_qos_policy_group_for_deletion(qos_policy_group_info)
            msg = _("Volume %s could not be created.")
            raise exception.VolumeBackendAPIException(data=msg %
                                                      (volume['name']))
        LOG.debug('Created LUN with name %(name)s and QoS info %(qos)s', {
            'name': lun_name,
            'qos': qos_policy_group_info
        })

        metadata['Path'] = '/vol/%s/%s' % (pool_name, lun_name)
        metadata['Volume'] = pool_name
        metadata['Qtree'] = None

        handle = self._create_lun_handle(metadata)
        self._add_lun_to_table(NetAppLun(handle, lun_name, size, metadata))

        model_update = self._get_volume_model_update(volume)

        return model_update
Пример #3
0
    def _clone_source_to_destination(self, source, destination_volume):
        source_size = source['size']
        destination_size = destination_volume['size']

        source_name = source['name']
        destination_name = destination_volume['name']

        extra_specs = na_utils.get_volume_extra_specs(destination_volume)

        qos_policy_group_info = self._setup_qos_for_volume(
            destination_volume, extra_specs)
        qos_policy_group_name = (na_utils.get_qos_policy_group_name_from_info(
            qos_policy_group_info))
        qos_policy_group_is_adaptive = (
            volume_utils.is_boolean_str(
                extra_specs.get('netapp:qos_policy_group_is_adaptive')) or
            na_utils.is_qos_policy_group_spec_adaptive(qos_policy_group_info))

        try:
            self._clone_lun(
                source_name,
                destination_name,
                space_reserved=self.lun_space_reservation,
                qos_policy_group_name=qos_policy_group_name,
                qos_policy_group_is_adaptive=qos_policy_group_is_adaptive)

            if destination_size != source_size:

                try:
                    self._extend_volume(destination_volume, destination_size,
                                        qos_policy_group_name)
                except Exception:
                    with excutils.save_and_reraise_exception():
                        LOG.error("Resizing %s failed. Cleaning volume.",
                                  destination_volume['id'])
                        self.delete_volume(destination_volume)

            return self._get_volume_model_update(destination_volume)

        except Exception:
            LOG.exception(
                "Exception cloning volume %(name)s from source "
                "volume %(source)s.", {
                    'name': destination_name,
                    'source': source_name
                })

            self._mark_qos_policy_group_for_deletion(qos_policy_group_info)

            msg = _("Volume %s could not be created from source volume.")
            raise exception.VolumeBackendAPIException(data=msg %
                                                      destination_name)
Пример #4
0
 def _do_qos_for_volume(self, volume, extra_specs, cleanup=True):
     qos_policy_group_is_adaptive = volume_utils.is_boolean_str(
         extra_specs.get('netapp:qos_policy_group_is_adaptive'))
     try:
         qos_policy_group_info = na_utils.get_valid_qos_policy_group_info(
             volume, extra_specs)
         self.zapi_client.provision_qos_policy_group(qos_policy_group_info)
         self._set_qos_policy_group_on_volume(volume, qos_policy_group_info,
                                              qos_policy_group_is_adaptive)
     except Exception:
         with excutils.save_and_reraise_exception():
             LOG.error("Setting QoS for %s failed", volume['id'])
             if cleanup:
                 LOG.debug("Cleaning volume %s", volume['id'])
                 self._cleanup_volume_on_failure(volume)
Пример #5
0
 def _do_qos_for_volume(self, volume, extra_specs, cleanup=True):
     try:
         qos_policy_group_info = na_utils.get_valid_qos_policy_group_info(
             volume, extra_specs)
         pool = volume_utils.extract_host(volume['host'], level='pool')
         qos_min_support = self.ssc_library.is_qos_min_supported(pool)
         qos_policy_group_is_adaptive = (
             volume_utils.is_boolean_str(
                 extra_specs.get('netapp:qos_policy_group_is_adaptive'))
             or na_utils.is_qos_policy_group_spec_adaptive(
                 qos_policy_group_info))
         self.zapi_client.provision_qos_policy_group(
             qos_policy_group_info, qos_min_support)
         self._set_qos_policy_group_on_volume(volume, qos_policy_group_info,
                                              qos_policy_group_is_adaptive)
     except Exception:
         with excutils.save_and_reraise_exception():
             LOG.error("Setting QoS for %s failed", volume['id'])
             if cleanup:
                 LOG.debug("Cleaning volume %s", volume['id'])
                 self._cleanup_volume_on_failure(volume)