コード例 #1
0
 def instance_root_create(self,
                          req,
                          body,
                          instance_id,
                          cluster_instances=None):
     LOG.info(_LI("Enabling root for instance '%s'.") % instance_id)
     LOG.info(_LI("req : '%s'\n\n") % req)
     context = req.environ[wsgi.CONTEXT_KEY]
     user_name = context.user
     if body:
         password = body['password'] if 'password' in body else None
     else:
         password = None
     root = models.VerticaRoot.create(context, instance_id, user_name,
                                      password, cluster_instances)
     return wsgi.Result(views.RootCreatedView(root).data(), 200)
コード例 #2
0
 def create(self, req, body, tenant_id):
     LOG.info(_("Creating a backup for tenant %s"), tenant_id)
     context = req.environ[wsgi.CONTEXT_KEY]
     data = body['backup']
     instance = data['instance']
     name = data['name']
     desc = data.get('description')
     parent = data.get('parent_id')
     incremental = data.get('incremental')
     context.notification = notification.DBaaSBackupCreate(context,
                                                           request=req)
     with StartNotification(context, name=name, instance_id=instance,
                            description=desc, parent_id=parent):
         backup = Backup.create(context, instance, name, desc,
                                parent_id=parent, incremental=incremental)
     return wsgi.Result(views.BackupView(backup).data(), 202)
コード例 #3
0
    def edit(self, req, id, body, tenant_id):
        """
        Updates the instance to set or unset one or more attributes.
        """
        LOG.info(_("Editing instance for tenant id %s.") % tenant_id)
        LOG.debug(logging.mask_password("req: %s"), req)
        LOG.debug(logging.mask_password("body: %s"), body)
        context = req.environ[wsgi.CONTEXT_KEY]

        instance = models.Instance.load(context, id)

        if 'slave_of' in body['instance']:
            LOG.debug("Detaching replica from source.")
            instance.detach_replica()

        return wsgi.Result(None, 202)
コード例 #4
0
 def delete(self, req, tenant_id, instance_id, user_id, id):
     """Revoke access for a user."""
     LOG.info(_("Revoking user access for instance '%s'") % instance_id)
     LOG.info(_("req : '%s'\n\n") % req)
     context = req.environ[wsgi.CONTEXT_KEY]
     user = self._get_user(context, instance_id, user_id)
     if not user:
         LOG.error(_("No such user: %(user)s " % {'user': user}))
         raise exception.UserNotFound(uuid=user)
     username, hostname = unquote_user_host(user_id)
     access = models.User.access(context, instance_id, username, hostname)
     databases = [db.name for db in access.databases]
     if id not in databases:
         raise exception.DatabaseNotFound(uuid=id)
     models.User.revoke(context, instance_id, username, hostname, id)
     return wsgi.Result(None, 202)
コード例 #5
0
    def rpc_ping(self, req, tenant_id, id):
        """Checks if instance is reachable via rpc."""
        LOG.info(
            "Sending RPC PING for a database "
            "instance %(id)s for tenant '%(tenant_id)s'\n"
            "req : '%(req)s'\n\n", {
                "tenant_id": tenant_id,
                "req": req,
                "id": id
            })

        context = req.environ[wsgi.CONTEXT_KEY]
        instance = models.MgmtInstance.load(context=context, id=id)

        instance.rpc_ping()
        return wsgi.Result(None, 204)
コード例 #6
0
ファイル: service.py プロジェクト: imandhan/trove
    def update(self, req, id, body, tenant_id):
        """Updates the instance to attach/detach configuration."""
        LOG.info(_LI("Updating database instance '%(instance_id)s' for tenant "
                     "'%(tenant_id)s'"),
                 {'instance_id': id, 'tenant_id': tenant_id})
        LOG.debug("req: %s", req)
        LOG.debug("body: %s", body)
        context = req.environ[wsgi.CONTEXT_KEY]

        instance = models.Instance.load(context, id)

        # Make sure args contains a 'configuration_id' argument,
        args = {}
        args['configuration_id'] = self._configuration_parse(context, body)
        self._modify_instance(context, req, instance, **args)
        return wsgi.Result(None, 202)
コード例 #7
0
ファイル: service.py プロジェクト: ISCAS-VDI/trove-base
    def delete(self, req, tenant_id, id):
        """Delete a cluster."""
        LOG.debug(("Deleting a Cluster for Tenant '%(tenant_id)s'\n"
                   "req : '%(req)s'\n\nid : '%(id)s'\n\n") % {
                       "req": req,
                       "id": id,
                       "tenant_id": tenant_id
                   })

        context = req.environ[wsgi.CONTEXT_KEY]
        cluster = models.Cluster.load(context, id)
        context.notification = notification.DBaaSClusterDelete(context,
                                                               request=req)
        with StartNotification(context, cluster_id=id):
            cluster.delete()
        return wsgi.Result(None, 202)
コード例 #8
0
    def index(self, req, tenant_id, instance_id):
        """Return all schemas."""
        LOG.info(
            _("Listing schemas for instance '%(id)s'\n"
              "req : '%(req)s'\n\n") % {
                  "id": instance_id,
                  "req": req
              })

        context = req.environ[wsgi.CONTEXT_KEY]
        self.authorize_target_action(context, 'database:index', instance_id)
        schemas, next_marker = models.Schemas.load(context, instance_id)
        view = views.SchemasView(schemas)
        paged = pagination.SimplePaginatedDataView(req.url, 'databases', view,
                                                   next_marker)
        return wsgi.Result(paged.data(), 200)
コード例 #9
0
ファイル: service.py プロジェクト: raman-mystack/tesora-trove
 def create(self, req, body, tenant_id, instance_id):
     """Creates a set of schemas."""
     LOG.info(_("Creating schema for instance '%s'") % instance_id)
     LOG.info(_("req : '%s'\n\n") % req)
     LOG.info(_("body : '%s'\n\n") % body)
     context = req.environ[wsgi.CONTEXT_KEY]
     schemas = body['databases']
     context.notification = notification.DBaaSDatabaseCreate(context,
                                                             request=req)
     with StartNotification(context,
                            instance_id=instance_id,
                            dbname=".".join([db['name']
                                             for db in schemas])):
         model_schemas = populate_validated_databases(schemas)
         models.Schema.create(context, instance_id, model_schemas)
     return wsgi.Result(None, 202)
コード例 #10
0
ファイル: service.py プロジェクト: qingyufei/trove
 def delete(self, req, tenant_id, id):
     LOG.info(
         'Deleting backup for tenant %(tenant_id)s '
         'ID: %(backup_id)s', {
             'tenant_id': tenant_id,
             'backup_id': id
         })
     context = req.environ[wsgi.CONTEXT_KEY]
     backup = Backup.get_by_id(context, id)
     policy.authorize_on_target(context, 'backup:delete',
                                {'tenant': backup.tenant_id})
     context.notification = notification.DBaaSBackupDelete(context,
                                                           request=req)
     with StartNotification(context, backup_id=id):
         Backup.delete(context, id)
     return wsgi.Result(None, 202)
コード例 #11
0
ファイル: service.py プロジェクト: vdialani/trove
 def show(self, req, tenant_id, instance_id, id):
     """Return a single user."""
     LOG.info(_("Showing a user for instance '%s'") % instance_id)
     LOG.info(_("req : '%s'\n\n") % req)
     context = req.environ[wsgi.CONTEXT_KEY]
     id = correct_id_with_req(id, req)
     username, host = unquote_user_host(id)
     user = None
     try:
         user = models.User.load(context, instance_id, username, host)
     except (ValueError, AttributeError) as e:
         raise exception.BadRequest(msg=str(e))
     if not user:
         raise exception.UserNotFound(uuid=id)
     view = views.UserView(user)
     return wsgi.Result(view.data(), 200)
コード例 #12
0
    def create(self, req, body, tenant_id, instance_id):
        """Creates a set of schemas."""
        LOG.info(
            _("Creating schema for instance '%(id)s'\n"
              "req : '%(req)s'\n\n"
              "body: '%(body)s'\n'n") % {
                  "id": instance_id,
                  "req": req,
                  "body": body
              })

        context = req.environ[wsgi.CONTEXT_KEY]
        schemas = body['databases']
        model_schemas = populate_validated_databases(schemas)
        models.Schema.create(context, instance_id, model_schemas)
        return wsgi.Result(None, 202)
コード例 #13
0
    def hwinfo(self, req, tenant_id, id):
        """Return a single instance hardware info."""
        LOG.info(
            "Showing hardware info for a database "
            "instance %(id)s for tenant '%(tenant_id)s'\n"
            "req : '%(req)s'\n\n", {
                "tenant_id": tenant_id,
                "req": req,
                "id": id
            })

        context = req.environ[wsgi.CONTEXT_KEY]
        instance = models.MgmtInstance.load(context=context, id=id)

        hwinfo = instance.get_hwinfo()
        return wsgi.Result(HwInfoView(id, hwinfo).data(), 200)
コード例 #14
0
ファイル: service.py プロジェクト: hejianle/trove
 def module_apply(self, req, body, tenant_id, id):
     """Apply modules to an instance."""
     context = req.environ[wsgi.CONTEXT_KEY]
     instance = models.Instance.load(context, id)
     if not instance:
         raise exception.NotFound(uuid=id)
     self.authorize_instance_action(context, 'module_apply', instance)
     module_ids = [mod['id'] for mod in body.get('modules', [])]
     modules = module_models.Modules.load_by_ids(context, module_ids)
     module_models.Modules.validate(
         modules, instance.datastore.id, instance.datastore_version.id)
     module_list = module_views.convert_modules_to_list(modules)
     client = create_guest_client(context, id)
     result_list = client.module_apply(module_list)
     models.Instance.add_instance_modules(context, id, modules)
     return wsgi.Result({'modules': result_list}, 200)
コード例 #15
0
ファイル: service.py プロジェクト: vdialani/trove
 def instances(self, req, tenant_id, id):
     context = req.environ[wsgi.CONTEXT_KEY]
     configuration = models.Configuration.load(context, id)
     instances = instances_models.DBInstance.find_all(
         tenant_id=context.tenant,
         configuration_id=configuration.id,
         deleted=False)
     limit = int(context.limit or CONF.instances_page_size)
     if limit > CONF.instances_page_size:
         limit = CONF.instances_page_size
     data_view = instances_models.DBInstance.find_by_pagination(
         'instances', instances, "foo", limit=limit, marker=context.marker)
     view = views.DetailedConfigurationInstancesView(data_view.collection)
     paged = pagination.SimplePaginatedDataView(req.url, 'instances', view,
                                                data_view.next_page_marker)
     return wsgi.Result(paged.data(), 200)
コード例 #16
0
    def diagnostics(self, req, tenant_id, id):
        """Return instance diagnostics for a single instance."""
        LOG.info(
            "Showing diagnostic info for a database "
            "instance %(id)s for tenant '%(tenant_id)s'\n"
            "req : '%(req)s'\n\n", {
                "tenant_id": tenant_id,
                "req": req,
                "id": id
            })

        context = req.environ[wsgi.CONTEXT_KEY]
        instance = models.MgmtInstance.load(context=context, id=id)

        diagnostics = instance.get_diagnostics()
        return wsgi.Result(DiagnosticsView(id, diagnostics).data(), 200)
コード例 #17
0
ファイル: service.py プロジェクト: konstar/tesora-trove
 def module_remove(self, req, tenant_id, id, module_id):
     """Remove module from an instance."""
     context = req.environ[wsgi.CONTEXT_KEY]
     instance = models.Instance.load(context, id)
     if not instance:
         raise exception.NotFound(uuid=id)
     self.authorize_instance_action(context, 'module_remove', instance)
     module = module_models.Module.load(context, module_id)
     module_info = module_views.DetailedModuleView(module).data()
     client = create_guest_client(context, id)
     client.module_remove(module_info)
     instance_module = module_models.InstanceModule.load(
         context, instance_id=id, module_id=module_id)
     if instance_module:
         module_models.InstanceModule.delete(context, instance_module)
     return wsgi.Result(None, 200)
コード例 #18
0
 def show(self, req, tenant_id, id):
     """Return a single instance."""
     LOG.info(_("req : '%s'\n\n") % req)
     LOG.info(_("Showing a database instance for tenant '%s'") % tenant_id)
     LOG.info(_("id : '%s'\n\n") % id)
     context = req.environ[wsgi.CONTEXT_KEY]
     deleted_q = req.GET.get('deleted', '').lower()
     include_deleted = deleted_q == 'true'
     server = models.DetailedMgmtInstance.load(context, id, include_deleted)
     root_history = mysql_models.RootHistory.load(context=context,
                                                  instance_id=id)
     return wsgi.Result(
         views.MgmtInstanceDetailView(server,
                                      req=req,
                                      root_history=root_history).data(),
         200)
コード例 #19
0
ファイル: service.py プロジェクト: qingyufei/trove
    def index(self, req, tenant_id):
        context = req.environ[wsgi.CONTEXT_KEY]
        instance_id = req.GET.get('instance_id')
        tenant_id = req.GET.get('project_id', context.project_id)
        LOG.info("Listing backup strateies for tenant %s", tenant_id)

        if tenant_id != context.project_id and not context.is_admin:
            raise exception.TroveOperationAuthError(
                tenant_id=context.project_id)
        policy.authorize_on_tenant(context, 'backup_strategy:index')

        result = BackupStrategy.list(context,
                                     tenant_id,
                                     instance_id=instance_id)
        view = views.BackupStrategiesView(result)
        return wsgi.Result(view.data(), 200)
コード例 #20
0
ファイル: service.py プロジェクト: khanhct/trove
    def show(self, req, tenant_id, id):
        """Return a single instance."""
        LOG.info(
            "Showing database instance '%(instance_id)s' for tenant "
            "'%(tenant_id)s'", {
                'instance_id': id,
                'tenant_id': tenant_id
            })
        LOG.debug("req : '%s'\n\n", req)

        context = req.environ[wsgi.CONTEXT_KEY]
        server = models.load_instance_with_info(models.DetailInstance, context,
                                                id)
        self.authorize_instance_action(context, 'show', server)
        return wsgi.Result(
            views.InstanceDetailView(server, req=req).data(), 200)
コード例 #21
0
ファイル: service.py プロジェクト: vmazur/trove
    def index(self, req, tenant_id):
        """Return a list of clusters."""
        LOG.debug(("Showing a list of clusters for Tenant '%(tenant_id)s'\n"
                   "req : '%(req)s'\n\n") % {"req": req,
                                             "tenant_id": tenant_id})

        context = req.environ[wsgi.CONTEXT_KEY]
        if not context.is_admin and context.tenant != tenant_id:
            raise exception.TroveOperationAuthError(tenant_id=context.tenant)

        # load all clusters and instances for the tenant
        clusters, marker = models.Cluster.load_all(context, tenant_id)
        view = views.ClustersView(clusters, req=req)
        paged = pagination.SimplePaginatedDataView(req.url, 'clusters', view,
                                                   marker)
        return wsgi.Result(paged.data(), 200)
コード例 #22
0
    def show(self, req, tenant_id, id):
        LOG.debug("Showing configuration group %(id)s on tenant %(tenant)s"
                  % {"tenant": tenant_id, "id": id})
        context = req.environ[wsgi.CONTEXT_KEY]
        configuration = models.Configuration.load(context, id)
        self.authorize_config_action(context, 'show', configuration)
        configuration_items = models.Configuration.load_items(context, id)

        configuration.instance_count = instances_models.DBInstance.find_all(
            tenant_id=context.tenant,
            configuration_id=configuration.id,
            deleted=False).count()

        return wsgi.Result(views.DetailedConfigurationView(
                           configuration,
                           configuration_items).data(), 200)
コード例 #23
0
    def delete(self, req, tenant_id, id):
        LOG.debug("Delete Security Group Rule called %s, %s" % (tenant_id, id))

        context = req.environ[wsgi.CONTEXT_KEY]
        sec_group_rule = models.SecurityGroupRule.find_by(id=id, deleted=False)
        sec_group = sec_group_rule.get_security_group(tenant_id)

        if sec_group is None:
            LOG.error(
                _("Attempting to delete Group Rule that does not "
                  "exist or does not belong to tenant %s") % tenant_id)
            raise exception.Forbidden("Unauthorized")

        sec_group_rule.delete(context, CONF.os_region_name)
        sec_group.save()
        return wsgi.Result(None, 204)
コード例 #24
0
    def create(self, req, body, tenant_id):
        LOG.debug("req : '%s'\n\n" % req)
        LOG.debug("body : '%s'\n\n" % req)

        context = req.environ[wsgi.CONTEXT_KEY]
        policy.authorize_on_tenant(context, 'configuration:create')
        context.notification = notification.DBaaSConfigurationCreate(
            context, request=req)
        name = body['configuration']['name']
        description = body['configuration'].get('description')
        values = body['configuration']['values']

        msg = _("Creating configuration group on tenant "
                "%(tenant_id)s with name: %(cfg_name)s")
        LOG.info(msg % {"tenant_id": tenant_id, "cfg_name": name})

        datastore_args = body['configuration'].get('datastore', {})
        datastore, datastore_version = (
            ds_models.get_datastore_version(**datastore_args))

        with StartNotification(context, name=name, datastore=datastore.name,
                               datastore_version=datastore_version.name):
            configItems = []
            if values:
                # validate that the values passed in are permitted by the
                # operator.
                ConfigurationsController._validate_configuration(
                    body['configuration']['values'],
                    datastore_version,
                    models.DatastoreConfigurationParameters.load_parameters(
                        datastore_version.id))

                for k, v in values.items():
                    configItems.append(DBConfigurationParameter(
                        configuration_key=k,
                        configuration_value=v))

            cfg_group = models.Configuration.create(name, description,
                                                    tenant_id, datastore.id,
                                                    datastore_version.id)
            with EndNotification(context, configuration_id=cfg_group.id):
                cfg_group_items = models.Configuration.create_items(
                    cfg_group.id, values)

        view_data = views.DetailedConfigurationView(cfg_group,
                                                    cfg_group_items)
        return wsgi.Result(view_data.data(), 200)
コード例 #25
0
    def create(self, req, body, tenant_id):
        LOG.debug("Creating a Cluster for Tenant '%s'" % tenant_id)
        LOG.info(_("req : '%s'\n\n") % req)
        LOG.info(_("body : '%s'\n\n") % body)

        context = req.environ[wsgi.CONTEXT_KEY]
        name = body['cluster']['name']
        datastore_args = body['cluster'].get('datastore', {})
        datastore, datastore_version = (
            datastore_models.get_datastore_version(**datastore_args))

        # TODO(saurabhs): add extended_properties to apischema
        extended_properties = body['cluster'].get('extended_properties', {})

        try:
            clusters_enabled = (CONF.get(datastore_version.manager)
                                .get('cluster_support'))
        except NoSuchOptError:
            clusters_enabled = False

        if not clusters_enabled:
            raise exception.ClusterDatastoreNotSupported(
                datastore=datastore.name,
                datastore_version=datastore_version.name)

        nodes = body['cluster']['instances']
        instances = []
        for node in nodes:
            flavor_id = utils.get_id_from_href(node['flavorRef'])
            volume_size = nics = availability_zone = None
            if 'volume' in node:
                volume_size = int(node['volume']['size'])
            if 'nics' in node:
                nics = node['nics']
            if 'availability_zone' in node:
                availability_zone = node['availability_zone']

            instances.append({"flavor_id": flavor_id,
                              "volume_size": volume_size,
                              "nics": nics,
                              "availability_zone": availability_zone})

        cluster = models.Cluster.create(context, name, datastore,
                                        datastore_version, instances,
                                        extended_properties)
        view = views.load_view(cluster, req=req, load_servers=False)
        return wsgi.Result(view.data(), 200)
コード例 #26
0
ファイル: service.py プロジェクト: qingyufei/trove
    def update(self, req, id, body, tenant_id):
        """Updates the instance.

        - attach/detach configuration.
        - detach from primary.
        - access information.
        """
        LOG.info(
            "Updating database instance '%(instance_id)s' for tenant "
            "'%(tenant_id)s'", {
                'instance_id': id,
                'tenant_id': tenant_id
            })
        LOG.debug("req: %s", req)
        LOG.debug("body: %s", body)
        context = req.environ[wsgi.CONTEXT_KEY]

        name = body['instance'].get('name')
        if ((name and len(body['instance'].keys()) > 2)
                or (not name and len(body['instance'].keys()) >= 2)):
            raise exception.BadRequest("Only one attribute (except 'name') is "
                                       "allowed to update.")

        instance = models.Instance.load(context, id)
        self.authorize_instance_action(context, 'update', instance)

        args = {}
        if name:
            instance.update_db(name=name)

        detach_replica = ('replica_of' in body['instance']
                          or 'slave_of' in body['instance'])
        if detach_replica:
            args['detach_replica'] = detach_replica

        configuration_id = self._configuration_parse(context, body)
        if configuration_id is not None:
            args['configuration_id'] = configuration_id

        if 'access' in body['instance']:
            args['access'] = body['instance']['access']

        if 'datastore_version' in body['instance']:
            args['datastore_version'] = body['instance']['datastore_version']

        self._modify_instance(context, req, instance, **args)
        return wsgi.Result(None, 202)
コード例 #27
0
ファイル: service.py プロジェクト: khanhct/trove
    def configuration(self, req, tenant_id, id):
        """
        Returns the default configuration template applied to the instance.
        """
        LOG.info("Getting default configuration for instance %s", id)
        context = req.environ[wsgi.CONTEXT_KEY]
        instance = models.Instance.load(context, id)
        self.authorize_instance_action(context, 'configuration', instance)

        LOG.debug("Server: %s", instance)
        config = instance.get_default_configuration_template()
        LOG.debug("Default config for instance %(instance_id)s is %(config)s",
                  {
                      'instance_id': id,
                      'config': config
                  })
        return wsgi.Result(views.DefaultConfigurationView(config).data(), 200)
コード例 #28
0
ファイル: service.py プロジェクト: hejianle/trove
    def guest_log_list(self, req, tenant_id, id):
        """Return all information about all logs for an instance."""
        LOG.debug("Listing logs for tenant %s", tenant_id)
        context = req.environ[wsgi.CONTEXT_KEY]

        try:
            backup_model.verify_swift_auth_token(context)
        except exception.SwiftNotFound:
            raise exception.LogsNotAvailable()

        instance = models.Instance.load(context, id)
        if not instance:
            raise exception.NotFound(uuid=id)
        self.authorize_instance_action(context, 'guest_log_list', instance)
        client = create_guest_client(context, id)
        guest_log_list = client.guest_log_list()
        return wsgi.Result({'logs': guest_log_list}, 200)
コード例 #29
0
 def update(self, req, body, tenant_id, instance_id, id):
     """Change attributes for one user."""
     LOG.info(_("Updating user attributes for instance '%s'") % instance_id)
     LOG.info(_("req : '%s'\n\n") % req)
     context = req.environ[wsgi.CONTEXT_KEY]
     username, hostname = unquote_user_host(id)
     user = None
     user_attrs = body['user']
     try:
         user = models.User.load(context, instance_id, username, hostname)
     except (ValueError, AttributeError) as e:
         raise exception.BadRequest(msg=str(e))
     if not user:
         raise exception.UserNotFound(uuid=id)
     models.User.update_attributes(context, instance_id, username, hostname,
                                   user_attrs)
     return wsgi.Result(None, 202)
コード例 #30
0
ファイル: service.py プロジェクト: viettelidc-oss/trove
    def create(self, req, body, tenant_id):
        """Adds a new datastore version."""
        context = req.environ[wsgi.CONTEXT_KEY]
        datastore_name = body['version']['datastore_name']
        version_name = body['version']['name']
        manager = body['version']['datastore_manager']
        image_id = body['version']['image']
        packages = body['version']['packages']
        if type(packages) is list:
            packages = ','.join(packages)
        active = body['version']['active']
        default = body['version']['default']

        LOG.info("Tenant: '%(tenant)s' is adding the datastore "
                 "version: '%(version)s' to datastore: '%(datastore)s'",
                 {'tenant': tenant_id, 'version': version_name,
                  'datastore': datastore_name})

        client = clients.create_glance_client(context)
        try:
            client.images.get(image_id)
        except glance_exceptions.HTTPNotFound:
            raise exception.ImageNotFound(uuid=image_id)

        try:
            datastore = models.Datastore.load(datastore_name)
        except exception.DatastoreNotFound:
            # Create the datastore if datastore_name does not exists.
            LOG.info("Creating datastore %s", datastore_name)
            datastore = models.DBDatastore()
            datastore.id = utils.generate_uuid()
            datastore.name = datastore_name
            datastore.save()

        try:
            models.DatastoreVersion.load(datastore, version_name)
            raise exception.DatastoreVersionAlreadyExists(name=version_name)
        except exception.DatastoreVersionNotFound:
            models.update_datastore_version(datastore.name, version_name,
                                            manager, image_id, packages,
                                            active)

        if default:
            models.update_datastore(datastore.name, version_name)

        return wsgi.Result(None, 202)