app_handler.py

# Copyright 2015 Rackspace Hosting
#
# 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 uuid

from solum.api.handlers import handler
from solum.api.handlers import workflow_handler
from solum.common import exception
from solum.common import keystone_utils
from solum import objects
from solum.openstack.common import log as logging


LOG = logging.getLogger(__name__)


class AppHandler(handler.Handler):
    """Fulfills a request on the app resource."""

    def get(self, id):
        """Return an app."""
        return objects.registry.App.get_by_uuid(self.context, id)

    def patch(self, id, data):
        """Update an app."""
        db_obj = objects.registry.App.get_by_uuid(self.context, id)

        data_dict = data.as_dict(objects.registry.App)
        obj_dict = db_obj.as_dict()

        # Source and workflow are a little tricky to update.
        new_source = obj_dict['source']
        new_source.update(data_dict.get('source', {}))
        data_dict['source'] = new_source

        new_wf = obj_dict['workflow_config']
        new_wf.update(data_dict.get('workflow_config', {}))
        data_dict['workflow_config'] = new_wf

        updated = objects.registry.App.update_and_save(self.context,
                                                       id, data_dict)
        return updated

    def delete(self, id):
        """Delete an existing app."""
        db_obj = objects.registry.App.get_by_uuid(self.context, id)
        db_obj.destroy(self.context)

    def create(self, data):
        """Create a new app."""
        db_obj = objects.registry.App()
        db_obj.id = str(uuid.uuid4())
        db_obj.user_id = self.context.user
        db_obj.project_id = self.context.tenant
        db_obj.deleted = False

        # create a delegation trust_id\token, if required
        db_obj.trust_id = keystone_utils.create_delegation_token(self.context)
        db_obj.trust_user = self.context.user_name

        db_obj.name = data.get('name')
        db_obj.description = data.get('description')
        db_obj.languagepack = data.get('languagepack')
        db_obj.stack_id = data.get('stack_id')
        db_obj.ports = data.get('ports')
        db_obj.source = data.get('source')
        db_obj.workflow_config = data.get('workflow_config')
        db_obj.trigger_uuid = str(uuid.uuid4())
        db_obj.trigger_actions = data.get('trigger_actions')

        db_obj.create(self.context)
        return db_obj

    def trigger_workflow(self, trigger_id, commit_sha='',
                         status_url=None, collab_url=None, workflow=None):
        """Get trigger by trigger id and start git workflow associated."""
        # Note: self.context will be None at this point as this is a
        # non-authenticated request.
        app_obj = objects.registry.App.get_by_trigger_id(None, trigger_id)
        # get the trust context and authenticate it.
        try:
            self.context = keystone_utils.create_delegation_context(
                app_obj, self.context)
            self.context.tenant = app_obj.project_id
            self.context.user = app_obj.user_id
            self.context.user_name = app_obj.trust_user

        except exception.AuthorizationFailure as auth_ex:
            LOG.warn(auth_ex)
            return

        # TODO(devkulkarni): Call repo_utils.verify_artifact
        # as we are calling it in the plan_handler to verify
        # the collaborator
        self._build_artifact(app_obj, commit_sha=commit_sha,
                             status_url=status_url, wf=workflow)

    def _build_artifact(self, app, commit_sha='',
                        status_url=None, wf=None):

        if wf is None:
            wf = ['unittest', 'build', 'deploy']
        wfhand = workflow_handler.WorkflowHandler(self.context)

        wfdata = {
            'app_id': app.id,
            'name': "%s" % app.name,
            'description': '',
            'source': app.source,
            'config': app.workflow_config,
            'actions': wf
            }
        wfhand.create(wfdata, commit_sha=commit_sha, status_url=status_url)

    def get_all(self):
        """Return all apps."""
        all_apps = objects.registry.AppList.get_all(self.context)
        return all_apps