class PeriodicTask(BaseTable):
__tablename__ = "periodic_task"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(length=120), unique=True)
task = db.Column(db.String(length=120))
crontab_id = db.Column(db.Integer, db.ForeignKey('crontab_schedule.id'))
crontab = relationship("CrontabSchedule", back_populates="periodic_tasks")
interval_id = db.Column(db.Integer, db.ForeignKey('interval_schedule.id'))
interval = relationship("IntervalSchedule", back_populates="periodic_tasks")
args = db.Column(db.String(length=120))
kwargs = db.Column(db.String(length=120))
last_run_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
total_run_count = db.Column(db.Integer, default=0)
enabled = db.Column(db.Boolean, default=True)
pull_mirrors = relationship("PullMirror", order_by="PullMirror.id", backref="periodic_task", lazy='dynamic')
no_changes = False
def __str__(self):
fmt = '{0.name}: {0.crontab}'
return fmt.format(self)
@property
def schedule(self):
if self.crontab:
return self.crontab.schedule
if self.interval:
return self.interval.schedule
class IntervalSchedule(BaseTable):
__tablename__ = "interval_schedule"
"""
PERIOD_CHOICES = (('days', 'Days'),
('hours', 'Hours'),
('minutes', 'Minutes'),
('seconds', 'Seconds'),
('microseconds', 'Microseconds'))
"""
id = db.Column(db.Integer, primary_key=True)
every = db.Column(db.Integer, nullable=False)
period = db.Column(db.Unicode(255))
periodic_tasks = relationship('PeriodicTask')
@property
def schedule(self):
return schedules.schedule(datetime.timedelta(**{self.period.code: self.every}))
@classmethod
def from_schedule(cls, session, schedule, period='seconds'):
every = max(schedule.run_every.total_seconds(), 0)
obj = cls.filter_by(session, every=every, period=period).first()
if obj is None:
return cls(every=every, period=period)
else:
return obj
def __str__(self):
if self.every == 1:
return 'every {0.period_singular}'.format(self)
return 'every {0.every} {0.period}'.format(self)
@property
def period_singular(self):
return self.period[:-1]
class PushMirror(Mirror):
__tablename__ = 'push_mirror'
id = db.Column(db.Integer, primary_key=True)
project_mirror = db.Column(db.String(255))
task_results = relationship("TaskResult",
backref="push_mirror",
lazy='dynamic',
order_by='desc(TaskResult.updated)')
class Fingerprint(BaseTable):
__tablename__ = 'fingerprint'
__table_args__ = (db.UniqueConstraint(
'user_id', 'hashed_hostname', name='_user_id_hashed_hostname_uc'), )
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), index=True)
hostname = db.Column(db.String(255))
sha256_fingerprint = db.Column(db.String(255))
hashed_hostname = db.Column(db.String(255), index=True)
class Group(BaseTable):
__tablename__ = 'group'
id = db.Column(db.Integer, primary_key=True)
gitlab_id = db.Column(db.Integer, unique=True)
name = db.Column(db.String(255))
pull_mirrors = relationship("PullMirror",
order_by="PullMirror.id",
backref="group",
lazy='dynamic')
class TaskSet(db.Model):
"""TaskSet result."""
__tablename__ = 'celery_tasksetmeta'
__table_args__ = {'sqlite_autoincrement': True}
id = db.Column(db.Integer,
db.Sequence('taskset_id_sequence'),
autoincrement=True,
primary_key=True)
taskset_id = db.Column(db.String(155), unique=True)
result = db.Column(db.PickleType, nullable=True)
date_done = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
nullable=True)
class Project(BaseTable):
__tablename__ = 'project'
id = db.Column(db.Integer, primary_key=True)
gitlab_id = db.Column(db.Integer, unique=True)
name = db.Column(db.String(255))
name_with_namespace = db.Column(db.String(255))
web_url = db.Column(db.String(255))
push_mirrors = relationship("PushMirror",
order_by="PushMirror.id",
backref="project",
lazy='dynamic')
pull_mirrors = relationship("PullMirror",
order_by="PullMirror.id",
backref="project",
lazy='dynamic')
class PeriodicTasks(BaseTable):
__tablename__ = "periodic_tasks"
id = db.Column(db.Integer, primary_key=True)
ident = db.Column(db.Integer, default=1, index=True)
last_update = db.Column(db.DateTime, default=datetime.datetime.utcnow)
@classmethod
def changed(cls):
found = PeriodicTasks.query.filter_by(ident=1).first()
if not found:
found = PeriodicTasks()
found.last_update = datetime.datetime.now()
db.session.add(found)
@classmethod
def last_change(cls, session):
obj = cls.filter_by(session, ident=1).first()
return obj.last_update if obj else None
class BaseTable(db.Model):
__abstract__ = True
updated = db.Column(db.DateTime,
default=func.now(),
onupdate=func.current_timestamp())
created = db.Column(db.DateTime, default=func.now())
@classmethod
def filter_by(cls, session, **kwargs):
"""
session.query(MyClass).filter_by(name = 'some name')
:param kwargs:
:param session:
"""
return session.query(cls).filter_by(**kwargs)
@classmethod
def get_or_create(cls, session_obj, defaults=None, **kwargs):
obj = session_obj.query(cls).filter_by(**kwargs).first()
if obj:
return obj, False
else:
params = dict((k, v) for k, v in kwargs.items())
params.update(defaults or {})
obj = cls(**params)
return obj, True
@classmethod
def update_or_create(cls, session_obj, defaults=None, **kwargs):
obj = session_obj.query(cls).filter_by(**kwargs).first()
if obj:
for key, value in defaults.items():
setattr(obj, key, value)
created = False
else:
params = dict((k, v) for k, v in kwargs.items())
params.update(defaults or {})
obj = cls(**params)
created = True
return obj, created
class Mirror(BaseTable):
__abstract__ = True
@declared_attr
def user_id(self):
return db.Column(db.Integer, db.ForeignKey('user.id'), index=True)
@declared_attr
def project_id(self):
return db.Column(db.Integer, db.ForeignKey('project.id'), index=True)
source = db.Column(db.String(255), nullable=True)
target = db.Column(db.String(255), nullable=True)
foreign_vcs_type = db.Column(db.Integer)
last_sync = db.Column(db.DateTime, nullable=True)
note = db.Column(db.String(255))
hook_token = db.Column(db.String(255))
is_force_update = db.Column(db.Boolean)
is_prune_mirrors = db.Column(db.Boolean)
is_deleted = db.Column(db.Boolean)
class TaskMeta(db.Model):
__tablename__ = 'celery_taskmeta'
__table_args__ = {'sqlite_autoincrement': True}
id = db.Column(db.Integer,
db.Sequence('task_id_sequence'),
primary_key=True,
autoincrement=True)
task_id = db.Column(db.String(155), unique=True)
status = db.Column(db.String(50), default=states.PENDING)
result = db.Column(db.PickleType, nullable=True)
date_done = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow,
nullable=True)
traceback = db.Column(db.Text, nullable=True)
task_result = relationship("TaskResult", backref="taskmeta", uselist=False)
class CrontabSchedule(BaseTable):
"""
Task result/status.
"""
__tablename__ = "crontab_schedule"
id = db.Column(db.Integer, primary_key=True)
minute = db.Column(db.String(length=120), default="*")
hour = db.Column(db.String(length=120), default="*")
day_of_week = db.Column(db.String(length=120), default="*")
day_of_month = db.Column(db.String(length=120), default="*")
month_of_year = db.Column(db.String(length=120), default="*")
periodic_tasks = relationship('PeriodicTask')
def __str__(self):
rfield = lambda f: f and str(f).replace(' ', '') or '*'
return '{0} {1} {2} {3} {4} (m/h/d/dM/MY)'.format(
rfield(self.minute),
rfield(self.hour),
rfield(self.day_of_week),
rfield(self.day_of_month),
rfield(self.month_of_year),
)
@property
def schedule(self):
return schedules.crontab(minute=self.minute,
hour=self.hour,
day_of_week=self.day_of_week,
day_of_month=self.day_of_month,
month_of_year=self.month_of_year)
@classmethod
def from_schedule(cls, session, schedule):
spec = {
'minute': schedule._orig_minute,
'hour': schedule._orig_hour,
'day_of_week': schedule._orig_day_of_week,
'day_of_month': schedule._orig_day_of_month,
'month_of_year': schedule._orig_month_of_year
}
obj = cls.filter_by(session, **spec).first()
if obj is None:
return cls(**spec)
else:
return obj
class TaskResult(BaseTable):
__tablename__ = 'task_result'
id = db.Column(db.Integer, primary_key=True)
pull_mirror_id = db.Column(db.Integer,
db.ForeignKey('pull_mirror.id'),
index=True,
nullable=True)
push_mirror_id = db.Column(db.Integer,
db.ForeignKey('push_mirror.id'),
index=True,
nullable=True)
task_name = db.Column(db.String(255))
invoked_by = db.Column(db.Integer, default=InvokedByEnum.UNKNOWN)
taskmeta_id = db.Column(db.Integer,
db.ForeignKey('celery_taskmeta.id'),
index=True,
nullable=False,
unique=True)
parent_id = db.Column(db.Integer,
db.ForeignKey('task_result.id'),
index=True,
nullable=True)
children = relationship("TaskResult",
backref=backref('parent', remote_side=[id]))
class User(BaseTable):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
gitlab_id = db.Column(db.Integer, unique=True, nullable=False)
gitlab_deploy_key_id = db.Column(db.Integer, unique=True, nullable=True)
is_rsa_pair_set = db.Column(db.Boolean)
name = db.Column(db.String(255))
avatar_url = db.Column(db.String(255))
access_token = db.Column(db.String(255), unique=True, nullable=True)
refresh_token = db.Column(db.String(255), unique=True, nullable=True)
expires = db.Column(db.DateTime, default=func.now())
pull_mirrors = relationship("PullMirror",
order_by="PullMirror.id",
backref="user",
lazy='dynamic')
push_mirrors = relationship("PushMirror",
order_by="PushMirror.id",
backref="user",
lazy='dynamic')
def is_active(self):
return True
def is_authenticated(self):
return True
def is_anonymous(self):
return False
def get_id(self):
try:
if isinstance(self.id, str):
return self.id
elif isinstance(self.id, int):
return self.id
else:
return self.id
except AttributeError:
raise NotImplementedError('No `id` attribute - override `get_id`')
def __eq__(self, other):
"""
Checks the equality of two `UserMixin` objects using `get_id`.
"""
if isinstance(other, User):
return self.get_id() == other.get_id()
return NotImplemented
def __ne__(self, other):
"""
Checks the inequality of two `UserMixin` objects using `get_id`.
"""
equal = self.__eq__(other)
if equal is NotImplemented:
return NotImplemented
return not equal
if sys.version_info[0] != 2: # pragma: no cover
# Python 3 implicitly set __hash__ to None if we override __eq__
# We set it back to its default implementation
__hash__ = object.__hash__
class OAuth2State(BaseTable):
__tablename__ = 'o_auth2_state'
id = db.Column(db.Integer, primary_key=True)
state = db.Column(db.String(255), unique=True)
def project_id(self):
return db.Column(db.Integer, db.ForeignKey('project.id'), index=True)
def user_id(self):
return db.Column(db.Integer, db.ForeignKey('user.id'), index=True)
class PushMirror(Mirror):
__tablename__ = 'push_mirror'
id = db.Column(db.Integer, primary_key=True)
project_mirror = db.Column(db.String(255))
class PullMirror(Mirror):
VISIBILITY_PRIVATE = 'private'
VISIBILITY_INTERNAL = 'internal'
VISIBILITY_PUBLIC = 'public'
__tablename__ = 'pull_mirror'
id = db.Column(db.Integer, primary_key=True)
group_id = db.Column(db.Integer, db.ForeignKey('group.id'), index=True)
periodic_task_id = db.Column(db.Integer,
db.ForeignKey('periodic_task.id'),
index=True,
nullable=True)
periodic_sync = db.Column(db.String(255), nullable=True)
project_name = db.Column(db.String(255))
project_mirror = db.Column(db.String(255))
is_no_create = db.Column(db.Boolean)
is_force_create = db.Column(db.Boolean)
is_no_remote = db.Column(db.Boolean)
is_issues_enabled = db.Column(db.Boolean)
is_wall_enabled = db.Column(db.Boolean)
is_wiki_enabled = db.Column(db.Boolean)
is_jobs_enabled = db.Column(db.Boolean, nullable=False)
is_snippets_enabled = db.Column(db.Boolean)
is_merge_requests_enabled = db.Column(db.Boolean)
visibility = db.Column(db.String(255), nullable=False)
class BaseTable(db.Model):
__abstract__ = True
updated = db.Column(db.DateTime,
default=func.now(),
onupdate=func.current_timestamp())
created = db.Column(db.DateTime, default=func.now())
