+ """add module table

+ 

+ Revision ID: 3fdedd58ac73

+ Revises: 414a86b37a0f

+ Create Date: 2016-10-26 22:01:09.361070

+ 

+ """

+ 

+ # revision identifiers, used by Alembic.

+ revision = '3fdedd58ac73'

+ down_revision = '414a86b37a0f'

+ 

+ from alembic import op

+ import sqlalchemy as sa

+ 

+ from coprs.models import Module, Action, Copr, User, Group

+ from sqlalchemy.orm import sessionmaker

+ 

+ import json

+ import base64

+ import modulemd

+ from coprs.logic.coprs_logic import CoprsLogic

+ from coprs.logic.actions_logic import ActionsLogic

+ from coprs.helpers import ActionTypeEnum

+ 

+ 

+ def upgrade():

+     bind = op.get_bind()

+     Session = sessionmaker()

+     session = Session(bind=bind)

+ 

+     op.create_table(

+         "module",

+         sa.Column("id", sa.Integer, primary_key=True),

+         sa.Column("name", sa.String(100), nullable=False),

+         sa.Column("version", sa.String(100), nullable=False),

+         sa.Column("release", sa.Integer, nullable=False),

+         sa.Column("summary", sa.String(100), nullable=False),

+         sa.Column("description", sa.Text),

+         sa.Column("created_on", sa.Integer, nullable=True),

+         sa.Column("yaml_b64", sa.Text),

+         sa.Column("copr_id", sa.Integer, sa.ForeignKey("copr.id")),

+     )

+     op.create_unique_constraint("pk_module", "module",

+                                 ["name", "version", "release", "copr_id"])

+     session.commit()

+ 

+     # Now, let's seed the table with existing modules which are violently stored in the `action` table

+     added_modules = set()

+     for action in ActionsLogic.get_many(ActionTypeEnum("build_module")).order_by(Action.id.desc()):

+         data = json.loads(action.data)

+         copr = get_copr(session, data["ownername"], data["projectname"])

+         yaml = base64.b64decode(data["modulemd_b64"])

+         mmd = modulemd.ModuleMetadata()

+         mmd.loads(yaml)

+ 

+         module_kwargs = {

+             "name": mmd.name,

+             "version": mmd.version,

+             "release": mmd.release,

+             "summary": mmd.summary,

+             "description": mmd.description,

+             "yaml_b64": data["modulemd_b64"],

+             "created_on": action.created_on,

+             "copr_id": copr.id,

+         }

+ 

+         # There is no constraint for currently existing modules, but in new table, there

+         # must be unique (copr, nvr). Therefore in the case of duplicit modules,

+         # we will add only the newest one

+         if full_module_name(copr, mmd) in added_modules:

+             print("Skipping {}; Already exists".format(full_module_name(copr, mmd)))

+             continue

+ 

+         session.add(Module(**module_kwargs))

+         added_modules.add(full_module_name(copr, mmd))

+ 

+ 

+ def downgrade():

+     ### commands auto generated by Alembic - please adjust! ###

+     op.drop_table('module')

+     ### end Alembic commands ###

+ 

+ 

+ def full_module_name(copr, mmd):

+     return "{}/{}-{}-{}".format(copr.full_name, mmd.name, mmd.version, mmd.release)

+ 

+ 

+ def get_copr(session, ownername, projectname):

+     if ownername[0] == "@":

+         coprs = CoprsLogic.filter_by_group_name(session.query(Copr), ownername[1:])

+     else:

+         coprs = CoprsLogic.filter_by_user_name(session.query(Copr), ownername)

+     return CoprsLogic.filter_by_name(coprs, projectname).first()

+ from jinja2 import Markup

+ from coprs.logic.modules_logic import ModulesLogic

+     release = wtforms.IntegerField("Release")

+     def __init__(self, copr=None, *args, **kwargs):

+         self.copr = copr

+         super(CreateModuleForm, self).__init__(*args, **kwargs)

+ 

+         # User/nvr should be unique

+         module = ModulesLogic.get_by_nvr(self.copr, self.name.data, self.version.data, self.release.data).first()

+         if module:

+             self.errors["nvr"] = [Markup("Module <a href='{}'>{}</a> already exists".format(

+                 helpers.copr_url("coprs_ns.copr_module", module.copr, id=module.id), module.full_name))]

+             return False

+ 

+     def send_build_module(cls, user, copr, module):

+             object_type="module",

+             object_id=module.id,

+ import time

+ import base64

+ import modulemd

+ from sqlalchemy import and_

+ from coprs import db

+ from coprs import exceptions

+         return models.Module.query.filter(models.Module.id == module_id)

+ 

+     @classmethod

+     def get_by_nvr(cls, copr, name, version, release):

+         return models.Module.query.filter(

+             and_(models.Module.name == name,

+                  models.Module.version == version,

+                  models.Module.release == release,

+                  models.Module.copr_id == copr.id))

+         return models.Module.query.order_by(models.Module.id.desc())

+         return cls.get_multiple().filter(models.Module.copr_id == copr.id)

+ 

+     @classmethod

+     def from_modulemd(cls, yaml):

+         mmd = modulemd.ModuleMetadata()

+         mmd.loads(yaml)

+         return models.Module(name=mmd.name, version=mmd.version, release=mmd.release, summary=mmd.summary,

+                              description=mmd.description, yaml_b64=base64.b64encode(yaml))

+ 

+     @classmethod

+     def add(cls, user, copr, module):

+         if not user.can_build_in(copr):

+             raise exceptions.InsufficientRightsException("You don't have permissions to build in this copr.")

+ 

+         module.copr_id = copr.id

+         module.copr = copr

+         module.created_on = time.time()

+ 

+         db.session.add(module)

+         return module

+     def to_dict(self, **kwargs):

+         d = super(Action, self).to_dict()

+         if d.get("object_type") == "module":

+             module = Module.query.filter(Module.id == d["object_id"]).first()

+             data = json.loads(d["data"])

+             data.update({

+                 "projectname": module.copr.name,

+                 "ownername": module.copr.owner_name,

+                 "modulemd_b64": module.yaml_b64,

+             })

+             d["data"] = json.dumps(data)

+         return d

+ 

+ class Module(db.Model, helpers.Serializer):

+     id = db.Column(db.Integer, primary_key=True)

+     name = db.Column(db.String(100), nullable=False)

+     version = db.Column(db.String(100), nullable=False)

+     release = db.Column(db.Integer, nullable=False)

+     summary = db.Column(db.String(100), nullable=False)

+     description = db.Column(db.Text)

+     created_on = db.Column(db.Integer, nullable=True)

+ 

+     # When someone submits YAML (not generate one on the copr modules page), we might want to use that exact file.

+     # Yaml produced by deconstructing into pieces and constructed back can look differently,

+     # which is not desirable (Imo)

+     #

+     # Also if there are fields which are not covered by this model, we will be able to add them in the future

+     # and fill them with data from this blob

+     yaml_b64 = db.Column(db.Text)

+ 

+     # relations

+     copr_id = db.Column(db.Integer, db.ForeignKey("copr.id"))

+     copr = db.relationship("Copr", backref=db.backref("modules"))

+     @property

+     def yaml(self):

+         return base64.b64decode(self.yaml_b64)

+ 

+     @property

+     def modulemd(self):

+         mmd.loads(self.yaml)

+         return mmd

+ 

+     @property

+     def nvr(self):

+         return "-".join([self.name, self.version, str(self.release)])

+ 

+     @property

+     def full_name(self):

+         return "{}/{}".format(self.copr.owner_name, self.nvr)

+ 

+     @property

+     def action(self):

+         return Action.query.filter(Action.object_type == "module").filter(Action.object_id == self.id).first()

+   {% if module.action %}

+     {{ build_state_text(module.action.result | module_state_from_num) }}

+   {% else %}

+     -

+   {% endif %}

+                   <input type="hidden" value="{{ copr.name }}" name="name">

+ {% if copr.id != module.copr.id %}

+         <a class="btn btn-primary btn-lg" href="{{ copr_url('coprs_ns.copr_create_module', copr) }}"> Create a New Module </a>

+ import sqlalchemy

+ from coprs.logic.modules_logic import ModulesLogic

+     module = ModulesLogic.from_modulemd(modulemd)

+     try:

+         module = ModulesLogic.add(flask.g.user, copr, module)

+         db.session.flush()

+         ActionsLogic.send_build_module(flask.g.user, copr, module)

+         db.session.commit()

+         return flask.jsonify({

+             "output": "ok",

+             "message": "Module build was submitted",

+             "modulemd": modulemd,

+         })

+ 

+     except sqlalchemy.exc.IntegrityError:

+         raise LegacyApiError({"nvr": ["Module {} already exists".format(module.nvr)]})

+     modules = ModulesLogic.get_multiple_by_copr(copr=copr).all()

+     return flask.render_template("coprs/detail/modules.html", copr=copr, modules=modules)

+     form = forms.CreateModuleForm(copr=copr, csrf_enabled=False)

+     module = ModulesLogic.add(flask.g.user, copr, ModulesLogic.from_modulemd(mmd.dumps()))

+     db.session.flush()

+     actions_logic.ActionsLogic.send_build_module(flask.g.user, copr, module)

+         "filename={}.yaml".format("-".join([str(module.id), module.name, module.version, str(module.release)]))