quay/buildtrigger/basehandler.py

import os
from abc import ABCMeta, abstractmethod
from jsonschema import validate
from six import add_metaclass

from endpoints.building import PreparedBuild
from data import model
from buildtrigger.triggerutil import get_trigger_config, InvalidServiceException

NAMESPACES_SCHEMA = {
    "type": "array",
    "items": {
        "type": "object",
        "properties": {
            "personal": {
                "type": "boolean",
                "description": "True if the namespace is the user's personal namespace",
            },
            "score": {"type": "number", "description": "Score of the relevance of the namespace",},
            "avatar_url": {
                "type": ["string", "null"],
                "description": "URL of the avatar for this namespace",
            },
            "url": {"type": "string", "description": "URL of the website to view the namespace",},
            "id": {"type": "string", "description": "Trigger-internal ID of the namespace",},
            "title": {"type": "string", "description": "Human-readable title of the namespace",},
        },
        "required": ["personal", "score", "avatar_url", "id", "title"],
    },
}

BUILD_SOURCES_SCHEMA = {
    "type": "array",
    "items": {
        "type": "object",
        "properties": {
            "name": {
                "type": "string",
                "description": "The name of the repository, without its namespace",
            },
            "full_name": {
                "type": "string",
                "description": "The name of the repository, with its namespace",
            },
            "description": {
                "type": "string",
                "description": "The description of the repository. May be an empty string",
            },
            "last_updated": {
                "type": "number",
                "description": "The date/time when the repository was last updated, since epoch in UTC",
            },
            "url": {
                "type": "string",
                "description": "The URL at which to view the repository in the browser",
            },
            "has_admin_permissions": {
                "type": "boolean",
                "description": "True if the current user has admin permissions on the repository",
            },
            "private": {"type": "boolean", "description": "True if the repository is private",},
        },
        "required": [
            "name",
            "full_name",
            "description",
            "last_updated",
            "has_admin_permissions",
            "private",
        ],
    },
}

METADATA_SCHEMA = {
    "type": "object",
    "properties": {
        "commit": {
            "type": "string",
            "description": "first 7 characters of the SHA-1 identifier for a git commit",
            "pattern": "^([A-Fa-f0-9]{7,})$",
        },
        "git_url": {"type": "string", "description": "The GIT url to use for the checkout",},
        "ref": {
            "type": "string",
            "description": "git reference for a git commit",
            "pattern": r"^refs\/(heads|tags|remotes)\/(.+)$",
        },
        "default_branch": {
            "type": "string",
            "description": "default branch of the git repository",
        },
        "commit_info": {
            "type": "object",
            "description": "metadata about a git commit",
            "properties": {
                "url": {"type": "string", "description": "URL to view a git commit",},
                "message": {"type": "string", "description": "git commit message",},
                "date": {"type": "string", "description": "timestamp for a git commit"},
                "author": {
                    "type": "object",
                    "description": "metadata about the author of a git commit",
                    "properties": {
                        "username": {"type": "string", "description": "username of the author",},
                        "url": {
                            "type": "string",
                            "description": "URL to view the profile of the author",
                        },
                        "avatar_url": {
                            "type": "string",
                            "description": "URL to view the avatar of the author",
                        },
                    },
                    "required": ["username"],
                },
                "committer": {
                    "type": "object",
                    "description": "metadata about the committer of a git commit",
                    "properties": {
                        "username": {"type": "string", "description": "username of the committer",},
                        "url": {
                            "type": "string",
                            "description": "URL to view the profile of the committer",
                        },
                        "avatar_url": {
                            "type": "string",
                            "description": "URL to view the avatar of the committer",
                        },
                    },
                    "required": ["username"],
                },
            },
            "required": ["message"],
        },
    },
    "required": ["commit", "git_url"],
}


@add_metaclass(ABCMeta)
class BuildTriggerHandler(object):
    def __init__(self, trigger, override_config=None):
        self.trigger = trigger
        self.config = override_config or get_trigger_config(trigger)

    @property
    def auth_token(self):
        """ Returns the auth token for the trigger. """
        # NOTE: This check is for testing.
        if hasattr(self.trigger, "auth_token"):
            return self.trigger.auth_token

        if self.trigger.secure_auth_token is not None:
            return self.trigger.secure_auth_token.decrypt()

        return None

    @abstractmethod
    def load_dockerfile_contents(self):
        """
    Loads the Dockerfile found for the trigger's config and returns them or None if none could
    be found/loaded.
    """
        pass

    @abstractmethod
    def list_build_source_namespaces(self):
        """
    Take the auth information for the specific trigger type and load the
    list of namespaces that can contain build sources.
    """
        pass

    @abstractmethod
    def list_build_sources_for_namespace(self, namespace):
        """
    Take the auth information for the specific trigger type and load the
    list of repositories under the given namespace.
    """
        pass

    @abstractmethod
    def list_build_subdirs(self):
        """
    Take the auth information and the specified config so far and list all of
    the possible subdirs containing dockerfiles.
    """
        pass

    @abstractmethod
    def handle_trigger_request(self, request):
        """
    Transform the incoming request data into a set of actions. Returns a PreparedBuild.
    """
        pass

    @abstractmethod
    def is_active(self):
        """
    Returns True if the current build trigger is active. Inactive means further
    setup is needed.
    """
        pass

    @abstractmethod
    def activate(self, standard_webhook_url):
        """
    Activates the trigger for the service, with the given new configuration.
    Returns new public and private config that should be stored if successful.
    """
        pass

    @abstractmethod
    def deactivate(self):
        """
    Deactivates the trigger for the service, removing any hooks installed in
    the remote service. Returns the new config that should be stored if this
    trigger is going to be re-activated.
    """
        pass

    @abstractmethod
    def manual_start(self, run_parameters=None):
        """
    Manually creates a repository build for this trigger. Returns a PreparedBuild.
    """
        pass

    @abstractmethod
    def list_field_values(self, field_name, limit=None):
        """
    Lists all values for the given custom trigger field. For example, a trigger might have a
    field named "branches", and this method would return all branches.
    """
        pass

    @abstractmethod
    def get_repository_url(self):
        """ Returns the URL of the current trigger's repository. Note that this operation
        can be called in a loop, so it should be as fast as possible. """
        pass

    @classmethod
    def filename_is_dockerfile(cls, file_name):
        """ Returns whether the file is named Dockerfile or follows the convention <name>.Dockerfile"""
        return file_name.endswith(".Dockerfile") or u"Dockerfile" == file_name

    @classmethod
    def service_name(cls):
        """
    Particular service implemented by subclasses.
    """
        raise NotImplementedError

    @classmethod
    def get_handler(cls, trigger, override_config=None):
        for subc in cls.__subclasses__():
            if subc.service_name() == trigger.service.name:
                return subc(trigger, override_config)

        raise InvalidServiceException("Unable to find service: %s" % trigger.service.name)

    def put_config_key(self, key, value):
        """ Updates a config key in the trigger, saving it to the DB. """
        self.config[key] = value
        model.build.update_build_trigger(self.trigger, self.config)

    def set_auth_token(self, auth_token):
        """ Sets the auth token for the trigger, saving it to the DB. """
        model.build.update_build_trigger(self.trigger, self.config, auth_token=auth_token)

    def get_dockerfile_path(self):
        """ Returns the normalized path to the Dockerfile found in the subdirectory
        in the config. """
        dockerfile_path = self.config.get("dockerfile_path") or "Dockerfile"
        if dockerfile_path[0] == "/":
            dockerfile_path = dockerfile_path[1:]
        return dockerfile_path

    def prepare_build(self, metadata, is_manual=False):
        # Ensure that the metadata meets the scheme.
        validate(metadata, METADATA_SCHEMA)

        config = self.config
        ref = metadata.get("ref", None)
        commit_sha = metadata["commit"]
        default_branch = metadata.get("default_branch", None)
        prepared = PreparedBuild(self.trigger)
        prepared.name_from_sha(commit_sha)
        prepared.subdirectory = config.get("dockerfile_path", None)
        prepared.context = config.get("context", None)
        prepared.is_manual = is_manual
        prepared.metadata = metadata

        if ref is not None:
            prepared.tags_from_ref(ref, default_branch)
        else:
            prepared.tags = [commit_sha[:7]]

        return prepared

    @classmethod
    def build_sources_response(cls, sources):
        validate(sources, BUILD_SOURCES_SCHEMA)
        return sources

    @classmethod
    def build_namespaces_response(cls, namespaces_dict):
        namespaces = list(namespaces_dict.values())
        validate(namespaces, NAMESPACES_SCHEMA)
        return namespaces

    @classmethod
    def get_parent_directory_mappings(cls, dockerfile_path, current_paths=None):
        """ Returns a map of dockerfile_paths to it's possible contexts. """
        if dockerfile_path == "":
            return {}

        if dockerfile_path[0] != os.path.sep:
            dockerfile_path = os.path.sep + dockerfile_path

        dockerfile_path = os.path.normpath(dockerfile_path)
        all_paths = set()
        path, _ = os.path.split(dockerfile_path)
        if path == "":
            path = os.path.sep

        all_paths.add(path)
        for i in range(1, len(path.split(os.path.sep))):
            path, _ = os.path.split(path)
            all_paths.add(path)

        if current_paths:
            return dict({dockerfile_path: list(all_paths)}, **current_paths)

        return {dockerfile_path: list(all_paths)}