- from coprs.rest_api import rest_api_bp, register_api_error_handler, URL_PREFIX

- register_api_error_handler(app)

- app.register_blueprint(rest_api_bp, url_prefix=URL_PREFIX)

- # register_api(app, db)

-     def get_multiple_by_user(cls, user):

-         """ Get collection of builds in copr sorted by build_id descending

-         form the copr belonging to `user`

-         """

-         return cls.get_multiple().join(models.Build.copr).filter(

-             models.Copr.user == user)

- 

-     @classmethod

-     def get_by_results(cls, **kwargs):

-         """

-         Query all `BuildChroot` instances whose `results` corresponds with the

-         specified `kwargs`.

- 

-         Supported parameter names:

- 

-             name, epoch, version, release, arch

- 

-         Example usage:

- 

-             cls.get_by_results(name="hello")

-             cls.get_by_results(name="foo", arch="x86_64")

-         """

-         return (models.BuildChroot.query

-                 .filter(models.BuildChroot.results.any(**kwargs)))

- 

-     @classmethod

-     def filter_by_name(cls, query, name):

-         return query.filter(models.Copr.name == name)

- 

-     @classmethod

- def slice_query(query, limit=100, offset=0):

-     """

-     :param Query query:

-     :param int limit:

-     :param int offset:

-     :rtype: Query

-     """

-     return query.limit(limit).offset(offset)

-     def user_name(self):

-         return self.user.name

- 

-     @property

-     def source_metadata(self):

-         if self.source_json is None:

-             return None

- 

-         try:

-             return json.loads(self.source_json)

-         except (TypeError, ValueError):

-             return None

- 

-     @property

-     def comps_len(self):

-         if self.comps_zlib:

-             return len(zlib.decompress(self.comps_zlib))

-         else:

-             return 0

- 

-     @property

- # coding: utf-8

- import json

- from flask import Response, url_for, Blueprint, make_response

- from flask_restful import Resource, Api

- 

- from coprs.exceptions import InsufficientRightsException

- 

- from coprs.rest_api.exceptions import ApiError

- from coprs.rest_api.resources.build import BuildListR, BuildR

- from coprs.rest_api.resources.build_task import BuildTaskListR, BuildTaskR

- from coprs.rest_api.resources.mock_chroot import MockChrootListR, MockChrootR

- from coprs.rest_api.resources.project import ProjectListR, ProjectR

- from coprs.rest_api.resources.project_chroot import ProjectChrootListR, ProjectChrootR

- 

- URL_PREFIX = "/api_2"

- 

- 

- class RootR(Resource):

-     @classmethod

-     def get(cls):

-         return {

-             "_links": {

-                 "self": {"href": url_for(".rootr")},

-                 "projects": {

-                     "href": url_for(".projectlistr"),

-                     "query_params": [

-                         {

-                             "name": u"owner",

-                             "type": u"string",

-                             "description": u"Select only project owned by the user"

-                         }

-                     ]

-                 },

-                 "mock_chroots": {"href": url_for(".mockchrootlistr")},

-                 "builds": {"href": url_for(".buildlistr")},

-                 "build_tasks": {"href": url_for(".buildtasklistr")},

-             }

-         }

- 

- 

- class MyApi(Api):

-     # flask-restfull error handling quite buggy right now

-     def error_router(self, original_handler, e):

-         return original_handler(e)

- #     # def handle_error(self, e):

- #     #

- #     #     if isinstance(e, sqlalchemy.orm.exc.NoResultFound):

- #     #         return self.make_response(str(e), 404)

- #     #

- #     #

- #     #     super(MyApi, self).handle_error(e)

- 

- 

- # def register_api(app, db):

- 

- 

- rest_api_bp = Blueprint("rest_api_bp", __name__)

- api = MyApi(rest_api_bp, catch_all_404s=True)

- 

- api.add_resource(RootR, "/")

- api.add_resource(ProjectListR, "/projects")

- api.add_resource(ProjectR, "/projects/<int:project_id>")

- 

- api.add_resource(MockChrootListR, "/mock_chroots")

- api.add_resource(MockChrootR, "/mock_chroots/<name>")

- 

- api.add_resource(BuildListR, "/builds")

- api.add_resource(BuildR, "/builds/<int:build_id>")

- 

- api.add_resource(ProjectChrootListR, "/projects/<int:project_id>/chroots")

- api.add_resource(ProjectChrootR, "/projects/<int:project_id>/chroots/<name>")

- 

- 

- api.add_resource(BuildTaskListR, "/build_tasks")

- # todo: add redirect from /build_tasks/<int:build_id> -> /build_tasks?build_id=<build_id>

- api.add_resource(BuildTaskR, "/build_tasks/<int:build_id>/<name>")

- 

- 

- def register_api_error_handler(app):

-     @app.errorhandler(ApiError)

-     def handle_api_error(error):

-         """

-         :param ApiError error:

-         """

- 

-         content = {

-             "message": error.msg,

-         }

-         if error.data:

-             content["data"] = error.data

- 

-         response = make_response(json.dumps(content), error.code)

-         response.headers["Content-Type"] = "application/json"

-         return response

- # coding: utf-8

- import base64

- import datetime

- import functools

- 

- from flask import url_for

- import flask

- 

- from ..logic.users_logic import UsersLogic

- from ..logic.builds_logic import BuildsLogic

- from ..logic.coprs_logic import CoprsLogic

- from ..rest_api.schemas import BuildTaskSchema

- from ..rest_api.util import mm_serialize_one, get_one_safe

- 

- from .exceptions import AuthFailed

- from .schemas import CoprChrootSchema, BuildSchema, ProjectSchema

- from .util import mm_serialize_one

- from coprs import app

- 

- 

- def render_copr_chroot(chroot):

-     return {

-         "chroot": mm_serialize_one(CoprChrootSchema, chroot),

-         "_links": {

-             "project": {"href": url_for(".projectr", project_id=chroot.copr.id)},

-             "self": {"href": url_for(".projectchrootr",

-                                      project_id=chroot.copr.id,

-                                      name=chroot.name)},

-         }

-     }

- 

- 

- def render_build(build, self_params=None):

-     if self_params is None:

-         self_params = {}

-     return {

-         "build": mm_serialize_one(BuildSchema, build),

-         "_links": {

-             "self": {"href": url_for(".buildr", build_id=build.id, **self_params)},

-             "project": {"href": url_for(".projectr", project_id=build.copr_id)},

-             "build_tasks": {"href": url_for(".buildtasklistr", build_id=build.id)}

-         }

-     }

- 

- 

- def render_project(project, self_params=None):

-     """

-     :param Copr project:

-     """

-     if self_params is None:

-         self_params = {}

- 

-     return {

-         "project": mm_serialize_one(ProjectSchema, project),

-         "_links": {

-             "self": {"href": url_for(".projectr", project_id=project.id, **self_params)},

-             "builds": {"href": url_for(".buildlistr", project_id=project.id)},

-             "chroots": {"href": url_for(".projectchrootlistr", project_id=project.id)},

-             "build_tasks": {"href":url_for(".buildtasklistr", project_id=project.id) }

-         },

-     }

- 

- 

- def render_build_task(chroot):

-     """

-     :type chroot: BuildChroot

-     """

-     return {

-         "build_task": mm_serialize_one(BuildTaskSchema, chroot),

-         "_links": {

-             "project": {"href": url_for(".projectr", project_id=chroot.build.copr_id)},

-             "build": {"href": url_for(".buildr", build_id=chroot.build_id)},

-             "self": {"href": url_for(".buildtaskr",

-                                      build_id=chroot.build.id,

-                                      name=chroot.name)},

-         }

-     }

- 

- 

- def rest_api_auth_required(f):

-     # todo: move to common.py and test this

-     @functools.wraps(f)

-     def decorated_function(*args, **kwargs):

-         token = None

-         api_login = None

-         try:

-             if "Authorization" in flask.request.headers:

-                 base64string = flask.request.headers["Authorization"]

-                 base64string = base64string.split()[1].strip()

-                 userstring = base64.b64decode(base64string)

-                 (api_login, token) = userstring.decode("utf-8").split(":")

-         except Exception:

-             app.logger.exception("Failed to get auth token from headers")

-             api_login = token = None

- 

-         token_auth = False

-         if token and api_login:

-             user = UsersLogic.get_by_api_login(api_login).first()

-             if (user and user.api_token == token and

-                     user.api_token_expiration >= datetime.date.today()):

- 

-                 token_auth = True

-                 flask.g.user = user

-         if not token_auth:

-             message = (

-                 "Login invalid/expired. "

-                 "Please visit {0}/api "

-                 "get or renew your API token.")

- 

-             raise AuthFailed(message.format(app.config["PUBLIC_COPR_HOSTNAME"]))

-         return f(*args, **kwargs)

-     return decorated_function

- 

- 

- def get_project_safe(project_id):

-     """

-     :param int project_id:

-     :rtype: Copr

-     """

-     return get_one_safe(

-         CoprsLogic.get_by_id(project_id),

-         msg="Project with id `{}` not found".format(project_id),

-         data={"project_id": project_id}

-     )

- 

- 

- def get_build_safe(build_id):

-     """

-     :param int build_id:

-     :rtype: Build

-     """

-     return get_one_safe(

-         BuildsLogic.get(build_id),

-         msg="Build with id `{}` not found".format(build_id),

-         data={"build_id": build_id}

-     )

- 

- 

- def get_user_safe(username):

-     """

-     :param str username:

-     :rtype: User

-     """

-     return get_one_safe(

-         UsersLogic.get(username),

-         msg="User `{}` doesn't have any project".format(username),

-         data={"username": username}

-     )

- # coding: utf-8

- 

- class ApiError(Exception):

-     def __init__(self, code, msg, data=None, **kwargs):

-         super(ApiError, self).__init__(**kwargs)

- 

-         self.code = code

-         self.data = data

-         self.msg = msg

- 

-         self.headers = kwargs.get("headers", {})

- 

-     def __str__(self):

-         return str(self.data)

- 

- 

- class AuthFailed(ApiError):

-     def __init__(self, msg=None, data=None, **kwargs):

-         if msg is None:

-             msg = "Authorization failed"

-         super(AuthFailed, self).__init__(401, msg=msg, data=data, **kwargs)

-         self.headers["Authorization"] = "Basic"

- 

- 

- class AccessForbidden(ApiError):

-     def __init__(self, msg=None, data=None, **kwargs):

-         if msg is None:

-             msg = "Access forbidden"

-         super(AccessForbidden, self).__init__(403, msg=msg, data=data, **kwargs)

- 

- 

- class ObjectNotFoundError(ApiError):

-     def __init__(self, msg=None, data=None, **kwargs):

-         if msg is None:

-             msg = "Requested object wasn't found"

-         super(ObjectNotFoundError, self).__init__(404, msg=msg, data=data, **kwargs)

- 

- 

- class ObjectAlreadyExists(ApiError):

-     def __init__(self, msg=None, data=None, **kwargs):

-         if msg is None:

-             msg = "Operational error, trying to create existing object"

- 

-         super(ObjectAlreadyExists, self).__init__(409, msg=msg, data=data, **kwargs)

- 

- 

- class MalformedRequest(ApiError):

-     def __init__(self, msg=None, data=None, **kwargs):

-         if msg is None:

-             msg = "Given request contains errors or couldn't be executed in the current context"

- 

-         super(MalformedRequest, self).__init__(400, msg=msg, data=data, **kwargs)

- 

- 

- class CannotProcessRequest(ApiError):

-     def __init__(self, msg=None, data=None, **kwargs):

-         if msg is None:

-             msg = "Cannot process given request"

- 

-         super(CannotProcessRequest, self).__init__(400, msg=msg, data=data, **kwargs)

- 

- 

- class ServerError(ApiError):

-     def __init__(self, msg=None, data=None, **kwargs):

-         if msg is None:

-             msg = "Unhandled server error, please contact site administrator"

-         super(ServerError, self).__init__(500, msg=msg, data=data, **kwargs)

- # coding: utf-8

- # coding: utf-8

- 

- import flask

- from flask import url_for, make_response

- from flask_restful import Resource

- 

- from ... import db

- from ...exceptions import (

-     ActionInProgressException,

-     ConflictingRequest,

-     InsufficientRightsException,

- )

- from ...logic.builds_logic import BuildsLogic

- from ..common import get_project_safe

- from ..exceptions import MalformedRequest, CannotProcessRequest, AccessForbidden

- from ..common import render_build, rest_api_auth_required, render_build_task, get_build_safe, get_user_safe

- from ..schemas import BuildSchema, BuildCreateSchema, BuildCreateFromUrlSchema

- from ..util import mm_deserialize, get_request_parser, arg_bool

- 

- 

- class BuildListR(Resource):

- 

-     @classmethod

-     def get(cls):

- 

-         parser = get_request_parser()

- 

-         parser.add_argument('owner', type=str,)

-         parser.add_argument('project_id', type=int)

-         parser.add_argument('group', type=str)

- 

-         parser.add_argument('limit', type=int)

-         parser.add_argument('offset', type=int)

- 

-         parser.add_argument('is_finished', type=arg_bool)

-         # parser.add_argument('package', type=str)

- 

-         req_args = parser.parse_args()

- 

-         if req_args["project_id"] is not None:

-             project = get_project_safe(req_args["project_id"])

-             query = BuildsLogic.get_multiple_by_copr(project)

-         elif req_args["owner"] is not None:

-             user = get_user_safe(req_args["owner"])

-             query = BuildsLogic.get_multiple_by_user(user)

-         else:

-             query = BuildsLogic.get_multiple()

- 

-         if req_args["group"]:

-             query = BuildsLogic.filter_by_group_name(query, req_args["group"])

- 

-         if req_args["is_finished"] is not None:

-             is_finished = req_args["is_finished"]

-             query = BuildsLogic.filter_is_finished(query, is_finished)

- 

-         if req_args["limit"] is not None:

-             limit = req_args["limit"]

-             if limit <= 0 or limit > 100:

-                 limit = 100

-         else:

-             limit = 100

- 

-         query = query.limit(limit)

- 

-         if req_args["offset"] is not None:

-             query = query.offset(req_args["offset"])

- 

-         builds = query.all()

- 

-         self_params = dict(req_args)

-         self_params["limit"] = limit

-         return {

-             "builds": [

-                 render_build(build) for build in builds

-             ],

-             "_links": {

-                 "self": {"href": url_for(".buildlistr", **self_params)},

-             },

-         }

- 

-     @staticmethod

-     def handle_post_json(req):

-         """

-         :return: if of the created build or raise Exception

-         """

-         build_params = mm_deserialize(BuildCreateFromUrlSchema(), req.data.decode("utf-8"))

-         project = get_project_safe(build_params["project_id"])

- 

-         chroot_names = build_params.pop("chroots")

-         srpm_url = build_params.pop("srpm_url")

-         try:

-             build = BuildsLogic.create_new_from_url(

-                 flask.g.user, project,

-                 url=srpm_url,

-                 chroot_names=chroot_names,

-                 **build_params

-             )

-             db.session.commit()

-         except ActionInProgressException as err:

-             db.session.rollback()

-             raise CannotProcessRequest("Cannot create new build due to: {}"

-                                        .format(err))

-         except InsufficientRightsException as err:

-             db.session.rollback()

-             raise AccessForbidden("User {} cannot create build in project {}: {}"

-                                   .format(flask.g.user.username,

-                                           project.full_name, err))

-         return build.id

- 

-     @staticmethod

-     def handle_post_multipart(req):

-         """

-         :return: if of the created build or raise Exception

-         """

-         try:

-             metadata = req.form["metadata"]

-         except KeyError:

-             raise MalformedRequest("Missing build metadata in the request")

- 

-         if "srpm" not in req.files:

-             raise MalformedRequest("Missing srpm file in the request")

-         srpm_handle = req.files["srpm"]

- 

-         build_params = mm_deserialize(BuildCreateSchema(), metadata)

-         project_id = build_params["project_id"]

- 

-         project = get_project_safe(project_id)

- 

-         chroot_names = build_params.pop("chroots")

-         try:

-             build = BuildsLogic.create_new_from_upload(

-                 flask.g.user, project,

-                 f_uploader=lambda path: srpm_handle.save(path),

-                 orig_filename=srpm_handle.filename,

-                 chroot_names=chroot_names,

-                 **build_params

-             )

-             db.session.commit()

-         except ActionInProgressException as err:

-             db.session.rollback()

-             raise CannotProcessRequest("Cannot create new build due to: {}"

-                                        .format(err))

-         except InsufficientRightsException as err:

-             db.session.rollback()

-             raise AccessForbidden("User {} cannon create build in project {}: {}"

-                                   .format(flask.g.user.username,

-                                           project.full_name, err))

- 

-         return build.id

- 

-     @rest_api_auth_required

-     def post(self):

- 

-         req = flask.request

-         if req.content_type is None:

-             raise MalformedRequest("Got request without content type header")

- 

-         if "application/json" in req.content_type:

-             build_id = self.handle_post_json(req)

-         elif "multipart/form-data" in req.content_type:

-             build_id = self.handle_post_multipart(req)

-         else:

-             raise MalformedRequest("Got unexpected content type: {}"

-                                    .format(req.content_type))

-         resp = make_response("", 201)

-         resp.headers["Location"] = url_for(".buildr", build_id=build_id)

- 

-         return resp

- 

- 

- class BuildR(Resource):

- 

-     @classmethod

-     def get(cls, build_id):

-         parser = get_request_parser()

-         parser.add_argument('show_build_tasks', type=arg_bool, default=False)

-         req_args = parser.parse_args()

- 

-         build = get_build_safe(build_id)

- 

-         self_params = {}

-         if req_args["show_build_tasks"]:

-             self_params["show_build_tasks"] = req_args["show_build_tasks"]

- 

-         result = render_build(build, self_params)

-         if req_args["show_build_tasks"]:

-             result["build_tasks"] = [

-                 render_build_task(chroot)

-                 for chroot in build.build_chroots

-             ]

- 

-         return result

- 

-     @classmethod

-     @rest_api_auth_required

-     def delete(cls, build_id):

-         build = get_build_safe(build_id)

-         try:

-             BuildsLogic.delete_build(flask.g.user, build)

-             db.session.commit()

-         except ActionInProgressException as err:

-             db.session.rollback()

-             raise CannotProcessRequest("Cannot delete build due to: {}"

-                                        .format(err))

-         except InsufficientRightsException as err:

-             raise AccessForbidden("Failed to delete build: {}".format(err))

- 

-         return "", 204

- 

-     @classmethod

-     @rest_api_auth_required

-     def put(self, build_id):

-         build = get_build_safe(build_id)

-         build_dict = mm_deserialize(BuildSchema(), flask.request.data.decode("utf-8"))

-         try:

-             if not build.canceled and build_dict["state"] == "canceled":

-                 BuildsLogic.cancel_build(flask.g.user, build)

-                 db.session.commit()

-         except (ActionInProgressException, ConflictingRequest) as err:

-             db.session.rollback()

-             raise CannotProcessRequest("Cannot update build due to: {}"

-                                        .format(err))

-         except InsufficientRightsException as err:

-             raise AccessForbidden("Failed to update build: {}".format(err))

- 

-         resp = make_response("", 201)

-         resp.headers["Location"] = url_for(".buildr", build_id=build_id)

-         return resp

- # coding: utf-8

- 

- from flask import url_for

- from flask_restful import Resource

- 

- from copr_common.enums import StatusEnum

- from coprs.rest_api.common import render_build_task

- from ...exceptions import MalformedArgumentException

- from ...logic.builds_logic import BuildChrootsLogic

- from ..exceptions import MalformedRequest

- from ..util import get_one_safe, get_request_parser

- 

- 

- # todo: add redirect from /build_tasks/<int:build_id> -> /build_tasks?build_id=<build_id>

- # class BuildTaskListRedirectBuildIdR(Resource):

- #     def get(self, build_id):

- #         resp = make_response("", 302)

- #         resp.headers["Location"] ==  url_for(".buildtasklistr", build_id=build_id)

- 

- 

- class BuildTaskListR(Resource):

-     state_choices = StatusEnum.vals.keys()

- 

-     def get(self):

- 

-         parser = get_request_parser()

- 

-         parser.add_argument('owner', type=str,)

-         parser.add_argument('project_id', type=int)

-         parser.add_argument('build_id', type=int)

-         parser.add_argument('group', type=str)

- 

-         parser.add_argument('limit', type=int)

-         parser.add_argument('offset', type=int)

- 

-         parser.add_argument(

-             'state', type=str, choices=self.state_choices,

-             help=u"allowed states: {}".format(" ".join(self.state_choices)))

- 

-         req_args = parser.parse_args()

- 

-         self_params = dict(req_args)

- 

-         query = BuildChrootsLogic.get_multiply()

-         if self_params.get("build_id") is not None:

-             query = BuildChrootsLogic.filter_by_build_id(

-                 query, self_params["build_id"])

-         elif self_params.get("project_id") is not None:

-             query = BuildChrootsLogic.filter_by_project_id(

-                 query, self_params["project_id"])

-         elif self_params.get("owner") is not None:

-             query = BuildChrootsLogic.filter_by_project_user_name(

-                 query, self_params["owner"])

-         elif self_params.get("group") is not None:

-             query = BuildChrootsLogic.filter_by_group_name(query, req_args["group"])

- 

-         state = self_params.get("state")

-         if state:

-             query = BuildChrootsLogic.filter_by_state(query, state)

- 

-         if req_args["limit"] is not None:

-             limit = req_args["limit"]

-             if limit <= 0 or limit > 100:

-                 limit = 100

-         else:

-             limit = 100

-         self_params["limit"] = limit

-         query = query.limit(limit)

- 

-         if "offset" in self_params is not None:

-             query = query.offset(self_params["offset"])

- 

-         build_chroots = query.all()

-         return {

-             "build_tasks": [

-                 render_build_task(chroot)

-                 for chroot in build_chroots

-             ],

-             "_links": {

-                 "self": {"href": url_for(".buildtasklistr", **self_params)}

-             }

-         }

- 

- 

- class BuildTaskR(Resource):

- 

-     @staticmethod

-     def _get_chroot_safe(build_id, name):

-         try:

-             chroot = get_one_safe(

-                 BuildChrootsLogic.get_by_build_id_and_name(build_id, name),

-                 "Build task {} for build {} not found"

-             )

-         except MalformedArgumentException as err:

-             raise MalformedRequest("Bad mock chroot name: {}".format(err))

-         return chroot

- 

-     def get(self, build_id, name):

-         chroot = self._get_chroot_safe(build_id, name)

-         return render_build_task(chroot)

- 

-     # todo: add put method: allows only to pass status: cancelled to cancel build

- 

- # coding: utf-8

- 

- from flask import url_for

- from flask_restful import Resource

- 

- from ...logic.coprs_logic import MockChrootsLogic

- 

- from ..schemas import MockChrootSchema

- from ..util import get_one_safe, get_request_parser, arg_bool, mm_serialize_one

- 

- 

- def render_mock_chroot(chroot):

-     return {

-         "chroot": mm_serialize_one(MockChrootSchema, chroot),

-         "_links": {

-             "self": {"href": url_for(".mockchrootr", name=chroot.name)},

-         },

-     }

- 

- 

- class MockChrootListR(Resource):

- 

-     @classmethod

-     def get(cls):

-         parser = get_request_parser()

-         parser.add_argument('active_only', type=arg_bool)

-         req_args = parser.parse_args()

-         active_only = False

-         if req_args["active_only"]:

-             active_only = True

- 

-         chroots = MockChrootsLogic.get_multiple(active_only=active_only).all()

- 

-         self_extra = {}

-         if active_only:

-             self_extra["active_only"] = active_only

-         return {

-             "_links": {

-                 "self": {"href": url_for(".mockchrootlistr", **self_extra)},

-             },

-             "chroots": [

-                 render_mock_chroot(chroot)

-                 for chroot in chroots

-             ]

-         }

- 

- 

- class MockChrootR(Resource):

-     @classmethod

-     def get(cls, name):

-         chroot = get_one_safe(MockChrootsLogic.get_from_name(name))

-         return render_mock_chroot(chroot)

- import flask

- from flask import url_for, make_response

- from flask_restful import Resource

- 

- from ... import db

- from ...logic.builds_logic import BuildsLogic

- from ...logic.complex_logic import ComplexLogic

- from ...logic.helpers import slice_query

- from ...logic.coprs_logic import CoprsLogic

- from ...exceptions import ActionInProgressException, InsufficientRightsException

- 

- from ...exceptions import DuplicateException

- 

- from ..common import rest_api_auth_required, render_copr_chroot, render_build, render_project, get_project_safe

- from ..schemas import ProjectSchema, ProjectCreateSchema

- from ..exceptions import ObjectAlreadyExists, CannotProcessRequest, AccessForbidden

- from ..util import mm_deserialize, get_request_parser, arg_bool

-