PackSearchController

Complexity

Total Complexity

2

Size/Duplication

Total Lines	8
Duplicated Lines	0 %

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
A	post()	0	6	2

# Licensed to the StackStorm, Inc ('StackStorm') under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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 pecan
from pecan.rest import RestController
import six

import st2common
from st2common import log as logging
from st2common.bootstrap.triggersregistrar import TriggersRegistrar
from st2common.bootstrap.sensorsregistrar import SensorsRegistrar
from st2common.bootstrap.actionsregistrar import ActionsRegistrar
from st2common.bootstrap.aliasesregistrar import AliasesRegistrar
from st2common.bootstrap.policiesregistrar import PolicyRegistrar
import st2common.bootstrap.policiesregistrar as policies_registrar
import st2common.bootstrap.runnersregistrar as runners_registrar
from st2common.bootstrap.rulesregistrar import RulesRegistrar
import st2common.bootstrap.ruletypesregistrar as rule_types_registrar
from st2common.bootstrap.configsregistrar import ConfigsRegistrar
import st2common.content.utils as content_utils
from st2common.models.api.base import jsexpose
from st2api.controllers.resource import ResourceController
from st2api.controllers.v1.actionexecutions import ActionExecutionsControllerMixin
from st2common.models.api.action import LiveActionCreateAPI
from st2common.models.api.pack import PackAPI
from st2common.models.api.pack import PackInitRequestAPI
from st2common.models.api.pack import PackInstallRequestAPI
from st2common.models.api.pack import PackRegisterRequestAPI
from st2common.models.api.pack import PackSearchRequestAPI
from st2common.models.api.pack import PackAsyncAPI
from st2common.persistence.pack import Pack
from st2common.rbac.types import PermissionType
from st2common.rbac.decorators import request_user_has_permission
from st2common.rbac.decorators import request_user_has_resource_db_permission
from st2common.services import packs as packs_service

http_client = six.moves.http_client

__all__ = [
    'PacksController',
    'BasePacksController'
]

LOG = logging.getLogger(__name__)

ENTITIES = {
    'action': (ActionsRegistrar, 'actions'),
    'trigger': (TriggersRegistrar, 'triggers'),
    'sensor': (SensorsRegistrar, 'sensors'),
    'rule': (RulesRegistrar, 'rules'),
    'alias': (AliasesRegistrar, 'aliases'),
    'policy': (PolicyRegistrar, 'policy'),
    'config': (ConfigsRegistrar, 'config')
}


class PackInitController(ActionExecutionsControllerMixin, RestController):

    @jsexpose(body_cls=PackInitRequestAPI, status_code=http_client.ACCEPTED)
    def post(self, args):
        parameters = vars(args)

        new_liveaction_api = LiveActionCreateAPI(action='packs.create',
                                                 parameters=parameters,
                                                 user=None)

        execution = self._handle_schedule_execution(liveaction_api=new_liveaction_api)

        return PackAsyncAPI(execution_id=execution.id)


class PackInstallController(ActionExecutionsControllerMixin, RestController):

    @jsexpose(body_cls=PackInstallRequestAPI, status_code=http_client.ACCEPTED)
    def post(self, pack_install_request):
        parameters = {
            'packs': pack_install_request.packs
        }

        new_liveaction_api = LiveActionCreateAPI(action='packs.install',
                                                 parameters=parameters,
                                                 user=None)

        execution = self._handle_schedule_execution(liveaction_api=new_liveaction_api)

        return PackAsyncAPI(execution_id=execution.id)


class PackUninstallController(ActionExecutionsControllerMixin, RestController):

    @jsexpose(body_cls=PackInstallRequestAPI, arg_types=[str], status_code=http_client.ACCEPTED)
    def post(self, pack_uninstall_request, ref_or_id=None):
        if ref_or_id:
            parameters = {
                'packs': [ref_or_id]
            }
        else:
            parameters = {
                'packs': pack_uninstall_request.packs
            }

        new_liveaction_api = LiveActionCreateAPI(action='packs.uninstall',
                                                 parameters=parameters,
                                                 user=None)

        execution = self._handle_schedule_execution(liveaction_api=new_liveaction_api)

        return PackAsyncAPI(execution_id=execution.id)


class PackRegisterController(RestController):

    @jsexpose(body_cls=PackRegisterRequestAPI)
    def post(self, pack_register_request):
        if pack_register_request and hasattr(pack_register_request, 'types'):
            types = pack_register_request.types
        else:
            types = ['runner', 'action', 'trigger', 'sensor', 'rule', 'rule_type', 'alias',
                     'policy_type', 'policy', 'config']

        if pack_register_request and hasattr(pack_register_request, 'packs'):
            packs = pack_register_request.packs
        else:
            packs = None

        result = {}

        if 'runner' in types or 'action' in types:
            result['runners'] = runners_registrar.register_runners(experimental=True)
        if 'rule_type' in types or 'rule' in types:
            result['rule_types'] = rule_types_registrar.register_rule_types()
        if 'policy_type' in types or 'policy' in types:
            result['policy_types'] = policies_registrar.register_policy_types(st2common)

        use_pack_cache = True

        for type, (Registrar, name) in six.iteritems(ENTITIES):

This seems to re-define the built-in type.

            if type in types:
                registrar = Registrar(use_pack_cache=use_pack_cache,
                                      fail_on_failure=False)
                if packs:
                    for pack in packs:
                        pack_path = content_utils.get_pack_base_path(pack)
                        result[name] = registrar.register_from_pack(pack_dir=pack_path)
                else:
                    packs_base_paths = content_utils.get_packs_base_paths()
                    result[name] = registrar.register_from_packs(base_dirs=packs_base_paths)

        return result


class PackSearchController(RestController):

    @jsexpose(body_cls=PackSearchRequestAPI)
    def post(self, pack_search_request):
        if hasattr(pack_search_request, 'query'):
            return packs_service.search_pack_index(pack_search_request.query)
        else:
            return packs_service.get_pack_from_index(pack_search_request.pack)


class IndexHealthController(RestController):

    @jsexpose()
    def get(self):
        return packs_service.check_index_health()


class BasePacksController(ResourceController):
    model = PackAPI
    access = Pack

    def _get_one_by_ref_or_id(self, ref_or_id, exclude_fields=None):
        LOG.info('GET %s with ref_or_id=%s', pecan.request.path, ref_or_id)

        instance = self._get_by_ref_or_id(ref_or_id=ref_or_id, exclude_fields=exclude_fields)

        if not instance:
            msg = 'Unable to identify resource with ref_or_id "%s".' % (ref_or_id)
            pecan.abort(http_client.NOT_FOUND, msg)
            return

        from_model_kwargs = self._get_from_model_kwargs_for_request(request=pecan.request)
        result = self.model.from_model(instance, **from_model_kwargs)
        LOG.debug('GET %s with ref_or_id=%s, client_result=%s', pecan.request.path, ref_or_id,
                  result)

        return result

    def _get_by_ref_or_id(self, ref_or_id, exclude_fields=None):
        resource_db = self._get_by_id(resource_id=ref_or_id, exclude_fields=exclude_fields)

        if not resource_db:
            # Try ref
            resource_db = self._get_by_ref(ref=ref_or_id, exclude_fields=exclude_fields)

        return resource_db

    def _get_by_ref(self, ref, exclude_fields=None):
        """
        Note: In this case "ref" is pack name and not StackStorm's ResourceReference.
        """
        resource_db = self.access.query(ref=ref, exclude_fields=exclude_fields).first()
        return resource_db


class PacksController(BasePacksController):
    from st2api.controllers.v1.packviews import PackViewsController

    model = PackAPI
    access = Pack
    supported_filters = {
        'name': 'name',
        'ref': 'ref'
    }

    query_options = {
        'sort': ['ref']
    }

    # Nested controllers
    init = PackInitController()
    install = PackInstallController()
    uninstall = PackUninstallController()
    register = PackRegisterController()
    search = PackSearchController()
    views = PackViewsController()
    health = IndexHealthController()

    @request_user_has_permission(permission_type=PermissionType.PACK_LIST)
    @jsexpose()
    def get_all(self, **kwargs):
        return super(PacksController, self)._get_all(**kwargs)

    @request_user_has_resource_db_permission(permission_type=PermissionType.PACK_VIEW)
    @jsexpose(arg_types=[str])
    def get_one(self, ref_or_id):
        return self._get_one_by_ref_or_id(ref_or_id=ref_or_id)