SAP: Add affinity UUID validation

cinder/action_track.py

@@ -0,0 +1,200 @@
+# Copyright 2023 Openstack Foundation.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import abc
+import inspect
+import traceback
+
+import decorator
+from oslo_config import cfg
+from oslo_log import log as logging
+from oslo_utils import excutils
+
+from cinder import context as cinder_context
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger(__name__)
+
+ACTION_VOLUME_CREATE = "volume_create"
+ACTION_VOLUME_DELETE = "volume_delete"
+ACTION_VOLUME_RESERVE = "volume_reserve"
+ACTION_VOLUME_ATTACH = "volume_attach"
+ACTION_VOLUME_EXTEND = "volume_extend"
+ACTION_VOLUME_DETACH = "volume_detach"
+ACTION_VOLUME_MIGRATE = "volume_migrate"
+ACTION_VOLUME_RETYPE = "volume_retype"
+ACTION_VOLUME_BACKUP = "volume_backup"
+ACTION_BACKUP_RESTORE = "volume_restore"
+ACTION_VOLUME_BACKUP_DELETE = "volume_backup_delete"
+ACTION_VOLUME_COPY_TO_IMAGE = "volume_copy_to_image"
+ACTION_VOLUME_BACKUP_RESET_STATUS = "volume_backup_reset_status"
+ACTION_SNAPSHOT_CREATE = "snapshot_create"
+ACTION_SNAPSHOT_DELETE = "snapshot_delete"
+
+
+VALID_RESOURCE_NAMES = [
+    'volume', 'backup', 'snapshot'
+]
+VALID_CONTEXT_NAMES = [
+    'context', 'ctxt'
+]
+
+log_level_map = {
+    logging.CRITICAL: LOG.error,
+    logging.ERROR: LOG.error,
+    logging.WARNING: LOG.warning,
+    logging.INFO: LOG.info,
+    logging.DEBUG: LOG.debug,
+}
+
+
+class ActionTrack(object, metaclass=abc.ABCMeta):
+    """Base class for the 'trace' api.
+
+    The purpose of this trace facility is to be able to
+    keep track of critical parts of operations against resources.
+    This will create a standardized object/log entry for troubleshooting
+    actions against resources.
+
+    This is not for performance tracing, but for action/operation tracking.
+    by default it will simply format a log entry such that the entries are
+    easy to find with a standard format and information.
+    """
+
+    @staticmethod
+    @abc.abstractmethod
+    def track(context, action, resource, message, loglevel=logging.INFO):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def track_with_file_info(context, action, resource, message,
+                             filename, line_number, function,
+                             loglevel=logging.INFO):
+        pass
+
+
+class LogActionTrack(ActionTrack):
+    @staticmethod
+    def _track_with_info(context, action, resource, message,
+                         filename, line_number, function,
+                         loglevel=logging.INFO):
+        entry = f"ACTION:'{action}' "
+        if loglevel == logging.ERROR or loglevel == logging.CRITICAL:
+            # The action failed and this trace is the reason
+            entry += "FAILED "
+
+        msg = message.replace("\n", "")
+
+        entry += (
+            f"MSG:'{msg}' "
+            f"FILE:{filename}:{line_number}:{function} "
+            f"RSC:{resource} "
+        )
+        log_func = log_level_map[loglevel]
+        log_func(entry, resource=resource)
+
+    @staticmethod
+    def track(context, action, resource, message, loglevel=logging.INFO):
+        # Do not call this directly.   Call action_track.track() instead.
+
+        # We only want the frame of the caller
+        # we should always be called from the trace() method in this module
+        # not called directly in this static method
+        info = list(traceback.walk_stack(None))[1][0]
+        LogActionTrack._track_with_info(context, action, resource, message,
+                                        info.f_code.co_filename,
+                                        info.f_lineno,
+                                        info.f_code.co_name,
+                                        loglevel=loglevel)
+
+    @staticmethod
+    def track_with_file_info(context, action, resource, message,
+                             filename, line_number, function,
+                             loglevel=logging.INFO):
+        # Do not call this directly.
+        # Call action_track.track_with_file_info() instead.
+        LogActionTrack._track_with_info(
+            context, action, resource, message,
+            filename, line_number, function, loglevel=loglevel
+        )
+
+
+def track(context, action, resource, message, loglevel=logging.INFO):
+    """For now we only implement LogActionTrack.
+
+    TODO(waboring): add rabbitmq trace? to send entries to a msg queue
+    or add: DBtrace to send traces to the DB instead?
+    """
+    LogActionTrack.track(context, action, resource, message,
+                         loglevel=loglevel)
+
+
+def track_with_info(context, action, resource, message, file, line_number,
+                    function, loglevel=logging.INFO):
+    """For now we only implement LogActionTrack.
+
+    TODO(waboring): add rabbitmq trace? to send entries to a msg queue
+    or add: DBtrace to send traces to the DB instead?
+    """
+    LogActionTrack.track_with_file_info(context, action, resource, message,
+                                        file, line_number, function,
+                                        loglevel=loglevel)
+
+
+def track_decorator(action):
+    """Decorator to automatically handle exceptions raised as failures.
+
+       Place this decorator on a function that you want to mark as an
+       action failure and the action_track tracing will get called
+       for the action.
+
+       @track_decorator(action_track.ACTION_VOLUME_ATTACH)
+       def initialize_connection(....)
+       If initialize_connection raises an exception then you will get a
+       action_track.track called with action of ACTION_VOLUME_ATTACH
+       and a failure.
+
+    """
+    @decorator.decorator
+    def inner(func, *args, **kwargs):
+        # Find the context and the volume/backup object
+        resource = None
+        context = None
+        call_args = inspect.getcallargs(func, *args, **kwargs)
+        for key in call_args:
+            if key in VALID_RESOURCE_NAMES:
+                resource = call_args[key]
+            elif (key in VALID_CONTEXT_NAMES and
+                    isinstance(call_args[key], cinder_context.RequestContext)):
+                context = call_args[key]
+
+        track(context, action, resource, "called")
+
+        try:
+            return func(*args, **kwargs)
+        except Exception:
+            with excutils.save_and_reraise_exception() as exc:
+                # We only want the frame of the caller
+                tl = traceback.extract_tb(exc.tb)
+                i = tl[1]
+                message = str(exc.value)
+                track_with_info(
+                    context, action, resource, message,
+                    i.filename, i.lineno, i.name,
+                    loglevel=logging.ERROR
+                )
+    return inner

cinder/api/common.py

@@ -54,6 +54,8 @@
 
 METADATA_TYPES = enum.Enum('METADATA_TYPES', 'user image')
 
+SAP_HIDDEN_METADATA_KEY = "__cinder_internal"
+
 
 def get_pagination_params(params, max_limit=None):
     """Return marker, limit, offset tuple from request.

cinder/api/contrib/services.py

@@ -153,6 +153,15 @@ def _failover(self, req, context, clustered, body):
                                cluster_name, body.get('backend_id'))
         return webob.Response(status_int=HTTPStatus.ACCEPTED)
 
+    @validation.schema(os_services.recount_host_stats)
+    def _recount_host_stats(self, req, context, body):
+        """Ask the volume manager to recount allocated capacity for host."""
+        cluster_name, host = common.get_cluster_host(req, body,
+                                                     mv.REPLICATION_CLUSTER)
+        self._volume_api_proxy(self.volume_api.recount_host_stats, context,
+                               host)
+        return webob.Response(status_int=HTTPStatus.ACCEPTED)
+
     def _log_params_binaries_services(self, context, body):
         """Get binaries and services referred by given log set/get request."""
         query_filters = {'is_up': True}
@@ -273,6 +282,8 @@ def update(self, req, id, body):
             return self._set_log(req, context, body=body)
         elif support_dynamic_log and id == 'get-log':
             return self._get_log(req, context, body=body)
+        elif id == "recount_host_stats":
+            return self._recount_host_stats(req, context, body=body)
         else:
             raise exception.InvalidInput(reason=_("Unknown action"))
 

cinder/api/contrib/vmware_migrate.py

@@ -0,0 +1,74 @@
+# Copyright (c) 2021 SAP Corporation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""The Migrate by connector API."""
+
+
+from oslo_log import log as logging
+from oslo_utils import strutils
+from six.moves import http_client
+
+from cinder.api.contrib import admin_actions
+from cinder.api import extensions
+from cinder.api.openstack import wsgi
+from cinder.api.schemas import vmware_extension_actions as vmware_actions
+from cinder.api import validation
+
+
+LOG = logging.getLogger(__name__)
+
+
+class VMWareVolumeExtensionsController(admin_actions.VolumeAdminController):
+
+    collection = 'volumes'
+
+    @wsgi.response(http_client.ACCEPTED)
+    @wsgi.action('os-migrate_volume_by_connector')
+    @validation.schema(vmware_actions.migrate_volume_by_connector)
+    def _migrate_volume_by_connector(self, req, id, body):
+        """Migrate a volume based on connector.
+
+        This is an SAP VMWare extension that requires
+        the connector of the vmware vcenter to be provided.
+        The connector will contain the correct vcenter uuid
+        so that the scheduler can find the right cinder backend
+        to migrate the volume.
+        """
+        context = req.environ['cinder.context']
+        # Not found exception will be handled at the wsgi level
+        volume = self._get(context, id)
+        self.authorize(context, 'migrate_volume', target_obj=volume)
+        params = body['os-migrate_volume_by_connector']
+        connector = params.get('connector', {})
+        lock_volume = strutils.bool_from_string(
+            params.get('lock_volume', False),
+            strict=True)
+
+        self.volume_api.migrate_volume_by_connector(
+            context, volume, connector, lock_volume)
+
+
+class Vmware_migrate(extensions.ExtensionDescriptor):
+    """Enable admin actions."""
+
+    name = "Vmware_migrate"
+    alias = "os-vmware-admin-actions"
+    updated = "2021-09-25T00:00:00+00:00"
+
+    def get_controller_extensions(self):
+        controller = VMWareVolumeExtensionsController()
+        extension = extensions.ControllerExtension(
+            self, controller.collection, controller)
+        return [extension]

cinder/api/contrib/volume_actions.py

@@ -12,13 +12,15 @@
 #   License for the specific language governing permissions and limitations
 #   under the License.
 from http import HTTPStatus
+import logging
 
 from castellan import key_manager
 from oslo_config import cfg
 import oslo_messaging as messaging
 from oslo_utils import strutils
 import webob
 
+from cinder import action_track
 from cinder.api import extensions
 from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
@@ -77,11 +79,20 @@ def _attach(self, req, id, body):
                 msg = _("Error attaching volume - %(err_type)s: "
                         "%(err_msg)s") % {
                     'err_type': error.exc_type, 'err_msg': error.value}
+                action_track.track(
+                    context, action_track.ACTION_VOLUME_ATTACH,
+                    volume, msg, loglevel=logging.ERROR
+                )
                 raise webob.exc.HTTPBadRequest(explanation=msg)
             else:
                 # There are also few cases where attach call could fail due to
                 # db or volume driver errors. These errors shouldn't be exposed
                 # to the user and in such cases it should raise 500 error.
+                action_track.track(
+                    context, action_track.ACTION_VOLUME_ATTACH,
+                    volume, f"Attach failed because {error}",
+                    loglevel=logging.ERROR
+                )
                 raise
 
     @wsgi.response(HTTPStatus.ACCEPTED)
@@ -159,16 +170,40 @@ def _initialize_connection(self, req, id, body):
         volume = self.volume_api.get(context, id)
         connector = body['os-initialize_connection']['connector']
         try:
+            action_track.track(
+                context, action_track.ACTION_VOLUME_ATTACH,
+                volume, "Call initialize_connection",
+            )
             info = self.volume_api.initialize_connection(context,
                                                          volume,
                                                          connector)
         except exception.InvalidInput as err:
+            action_track.track(
+                context, action_track.ACTION_VOLUME_ATTACH,
+                volume, "Invalid Input", loglevel=logging.ERROR
+            )
             raise webob.exc.HTTPBadRequest(
                 explanation=err.msg)
+        except exception.ConnectorRejected:
+            msg = _("Volume needs to be migrated before attaching to this "
+                    "instance")
+            action_track.track(
+                context, action_track.ACTION_VOLUME_ATTACH,
+                volume, msg
+            )
+            raise webob.exc.HTTPNotAcceptable(explanation=msg)
         except exception.VolumeBackendAPIException:
             msg = _("Unable to fetch connection information from backend.")
+            action_track.track(
+                context, action_track.ACTION_VOLUME_ATTACH,
+                volume, msg, loglevel=logging.ERROR
+            )
             raise webob.exc.HTTPInternalServerError(explanation=msg)
         except messaging.RemoteError as error:
+            action_track.track(
+                context, action_track.ACTION_VOLUME_ATTACH,
+                volume, f"Failed because {error}", loglevel=logging.ERROR
+            )
             if error.exc_type == 'InvalidInput':
                 raise exception.InvalidInput(reason=error.value)
             raise