class Artifact(RepositoryBoundMixin, StandardAttributes, db.Model):
job_id = db.Column(GUID,
db.ForeignKey('job.id', ondelete='CASCADE'),
nullable=False)
testcase_id = db.Column(GUID,
db.ForeignKey('testcase.id', ondelete='CASCADE'),
nullable=True)
name = db.Column(db.String(length=256), nullable=False)
type = db.Column(Enum(ArtifactType),
default=ArtifactType.UNKNOWN,
nullable=False,
server_default='0')
file = db.Column(
File(path='artifacts'),
nullable=False,
# TODO(dcramer): this is super hacky but not sure a better way to
# do it with SQLAlchemy
default=lambda: FileData({}, default_path='artifacts'))
status = db.Column(Enum(Status), nullable=False, default=Status.unknown)
job = db.relationship('Job', innerjoin=True, uselist=False)
testcase = db.relationship('TestCase', uselist=False)
__tablename__ = 'artifact'
def save_base64_content(self, base64):
content = b64decode(base64)
self.file.save(
BytesIO(content), '{0}/{1}_{2}'.format(self.job_id.hex,
self.id.hex, self.name))
class Build(ProjectBoundMixin, StandardAttributes, db.Model):
"""
A single build linked to a source.
Each Build contains many Jobs.
"""
source_id = db.Column(
GUID, db.ForeignKey('source.id', ondelete='CASCADE'), nullable=False, index=True
)
number = db.Column(db.Integer, nullable=False)
label = db.Column(db.String, nullable=False)
status = db.Column(Enum(Status), nullable=False, default=Status.unknown)
result = db.Column(Enum(Result), nullable=False, default=Result.unknown)
date_started = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
date_finished = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
data = db.Column(JSONEncodedDict, nullable=True)
provider = db.Column(db.String, nullable=True)
external_id = db.Column(db.String(64), nullable=True)
source = db.relationship('Source')
stats = db.relationship(
'ItemStat',
foreign_keys='[ItemStat.item_id]',
primaryjoin='ItemStat.item_id == Build.id',
lazy='subquery',
viewonly=True,
uselist=True
)
__tablename__ = 'build'
__table_args__ = (
db.UniqueConstraint('project_id', 'number', name='unq_build_number'),
db.UniqueConstraint('project_id', 'provider', 'external_id', name='unq_build_provider')
)
__repr__ = model_repr('number', 'status', 'result')
class Repository(OrganizationBoundMixin, StandardAttributes, db.Model):
"""
Represents a single repository.
"""
query_class = RepositoryAccessBoundQuery
provider = db.Column(StrEnum(RepositoryProvider),
default=RepositoryProvider.native,
nullable=False)
external_id = db.Column(db.String(64))
url = db.Column(db.String(200), nullable=False)
backend = db.Column(Enum(RepositoryBackend),
default=RepositoryBackend.unknown,
nullable=False)
status = db.Column(Enum(RepositoryStatus),
default=RepositoryStatus.inactive,
nullable=False)
data = db.Column(JSONEncodedDict, nullable=True)
last_update = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
last_update_attempt = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
options = db.relationship(
'ItemOption',
foreign_keys='[ItemOption.item_id]',
primaryjoin='ItemOption.item_id == Repository.id',
lazy='subquery',
viewonly=True,
uselist=True)
__tablename__ = 'repository'
__table_args__ = (db.UniqueConstraint('organization_id',
'provider',
'external_id',
name='unq_external_id'), )
__repr__ = model_repr('url', 'provider', 'external_id')
def get_vcs(self):
from zeus.models import ItemOption
from zeus.vcs.git import GitVcs
options = dict(
db.session.query(ItemOption.name, ItemOption.value).filter(
ItemOption.item_id == self.id,
ItemOption.name.in_([
'auth.username',
])))
kwargs = {
'path': os.path.join(current_app.config['REPO_ROOT'], self.id.hex),
'url': self.url,
'username': options.get('auth.username'),
}
if self.backend == RepositoryBackend.git:
return GitVcs(**kwargs)
else:
raise NotImplementedError('Invalid backend: {}'.format(
self.backend))
class Job(RepositoryBoundMixin, StandardAttributes, db.Model):
"""
A single job, which is the actual execution unit for a build.
"""
id = db.Column(GUID, primary_key=True, default=GUID.default_value)
build_id = db.Column(GUID,
db.ForeignKey("build.id", ondelete="CASCADE"),
nullable=False,
index=True)
number = db.Column(db.Integer, nullable=False)
label = db.Column(db.String, nullable=True)
status = db.Column(Enum(Status), nullable=False, default=Status.unknown)
result = db.Column(Enum(Result), nullable=False, default=Result.unknown)
allow_failure = db.Column(db.Boolean,
nullable=False,
default=False,
server_default="0")
date_started = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
date_updated = db.Column(db.TIMESTAMP(timezone=True),
nullable=True,
onupdate=timezone.now)
date_finished = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
data = db.Column(JSONEncodedDict, nullable=True)
provider = db.Column(db.String, nullable=True)
external_id = db.Column(db.String(64), nullable=True)
url = db.Column(db.String, nullable=True)
build = db.relationship("Build",
backref=db.backref("jobs",
order_by="Job.date_created"),
innerjoin=True)
stats = db.relationship(
"ItemStat",
foreign_keys="[ItemStat.item_id]",
primaryjoin="ItemStat.item_id == Job.id",
viewonly=True,
uselist=True,
)
failures = db.relationship(
"FailureReason",
foreign_keys="[FailureReason.job_id]",
primaryjoin="FailureReason.job_id == Job.id",
viewonly=True,
uselist=True,
)
__tablename__ = "job"
__table_args__ = (
db.UniqueConstraint("build_id", "number", name="unq_job_number"),
db.UniqueConstraint("build_id",
"provider",
"external_id",
name="unq_job_provider"),
)
__repr__ = model_repr("build_id", "number", "status", "result")
class Build(RepositoryBoundMixin, StandardAttributes, db.Model):
"""
A single build linked to a source.
Each Build contains many Jobs.
"""
source_id = db.Column(GUID,
db.ForeignKey("source.id", ondelete="CASCADE"),
nullable=False,
index=True)
number = db.Column(db.Integer, nullable=False)
label = db.Column(db.String, nullable=False)
status = db.Column(Enum(Status), nullable=False, default=Status.unknown)
result = db.Column(Enum(Result), nullable=False, default=Result.unknown)
date_created = db.Column(
db.TIMESTAMP(timezone=True),
nullable=False,
default=timezone.now,
server_default=func.now(),
index=True,
)
date_started = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
date_finished = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
data = db.Column(JSONEncodedDict, nullable=True)
provider = db.Column(db.String, nullable=True)
external_id = db.Column(db.String(64), nullable=True)
url = db.Column(db.String, nullable=True)
source = db.relationship("Source", innerjoin=True)
stats = db.relationship(
"ItemStat",
foreign_keys="[ItemStat.item_id]",
primaryjoin="ItemStat.item_id == Build.id",
viewonly=True,
uselist=True,
)
__tablename__ = "build"
__table_args__ = (
db.UniqueConstraint("repository_id", "number",
name="unq_build_number"),
db.UniqueConstraint("repository_id",
"provider",
"external_id",
name="unq_build_provider"),
)
__repr__ = model_repr("number", "status", "result")
class Artifact(RepositoryBoundMixin, StandardAttributes, db.Model):
job_id = db.Column(
GUID, db.ForeignKey("job.id", ondelete="CASCADE"), nullable=False
)
testcase_id = db.Column(
GUID, db.ForeignKey("testcase.id", ondelete="CASCADE"), nullable=True
)
name = db.Column(db.String(length=256), nullable=False)
type = db.Column(db.String(length=64), nullable=True)
file = db.Column(
File(path="artifacts"),
nullable=False,
# TODO(dcramer): this is super hacky but not sure a better way to
# do it with SQLAlchemy
default=lambda: FileData({}, default_path="artifacts"),
)
status = db.Column(Enum(Status), nullable=False, default=Status.unknown)
date_started = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
date_updated = db.Column(
db.TIMESTAMP(timezone=True), nullable=True, onupdate=timezone.now
)
date_finished = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
job = db.relationship("Job", innerjoin=True, uselist=False)
testcase = db.relationship("TestCase", uselist=False)
__tablename__ = "artifact"
__table_args__ = (db.Index("idx_artifact_job", "repository_id", "job_id"),)
def save_base64_content(self, base64):
content = b64decode(base64)
self.file.save(
BytesIO(content),
"{0}/{1}_{2}".format(self.job_id.hex, self.id.hex, self.name),
)
class Job(RepositoryBoundMixin, StandardAttributes, db.Model):
"""
A single job, which is the actual execution unit for a build.
"""
id = db.Column(GUID, primary_key=True, default=GUID.default_value)
build_id = db.Column(GUID,
db.ForeignKey('build.id', ondelete='CASCADE'),
nullable=False,
index=True)
number = db.Column(db.Integer, nullable=False)
label = db.Column(db.String, nullable=True)
status = db.Column(Enum(Status), nullable=False, default=Status.unknown)
result = db.Column(Enum(Result), nullable=False, default=Result.unknown)
date_started = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
date_finished = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
data = db.Column(JSONEncodedDict, nullable=True)
provider = db.Column(db.String, nullable=True)
external_id = db.Column(db.String(64), nullable=True)
url = db.Column(db.String, nullable=True)
build = db.relationship('Build',
backref=db.backref('jobs',
order_by='Job.date_created'),
innerjoin=True)
stats = db.relationship('ItemStat',
foreign_keys='[ItemStat.item_id]',
primaryjoin='ItemStat.item_id == Job.id',
viewonly=True,
uselist=True)
failures = db.relationship(
'FailureReason',
foreign_keys='[FailureReason.job_id]',
primaryjoin='FailureReason.job_id == Job.id',
viewonly=True,
uselist=True,
)
__tablename__ = 'job'
__table_args__ = (db.UniqueConstraint('build_id',
'number',
name='unq_job_number'),
db.UniqueConstraint('build_id',
'provider',
'external_id',
name='unq_job_provider'))
__repr__ = model_repr('build_id', 'number', 'status', 'result')
class RepositoryAccess(RepositoryMixin, db.Model):
user_id = db.Column(
GUID, db.ForeignKey("user.id", ondelete="CASCADE"), primary_key=True
)
permission = db.Column(
Enum(Permission), nullable=False, default=Permission.read, server_default="1"
)
user = db.relationship("User", innerjoin=True, uselist=False)
__tablename__ = "repository_access"
__repr__ = model_repr("repository_id", "user_id")
class ApiTokenRepositoryAccess(db.Model):
repository_id = db.Column(
GUID, db.ForeignKey("repository.id", ondelete="CASCADE"), primary_key=True
)
api_token_id = db.Column(
GUID, db.ForeignKey("api_token.id", ondelete="CASCADE"), primary_key=True
)
permission = db.Column(Enum(Permission), nullable=False, default=Permission.read)
repository = db.relationship("Repository", innerjoin=True, uselist=False)
api_token = db.relationship("ApiToken", innerjoin=True, uselist=False)
__tablename__ = "api_token_repository_access"
__repr__ = model_repr("repository_id", "api_token_id")
class StyleViolation(RepositoryBoundMixin, StandardAttributes, db.Model):
"""
A single style violation.
"""
job_id = db.Column(
GUID, db.ForeignKey("job.id", ondelete="CASCADE"), nullable=False
)
filename = db.Column(db.Text, nullable=False)
severity = db.Column(Enum(Severity), default=Severity.error, nullable=False)
message = db.Column(db.Text, nullable=False)
lineno = db.Column(db.Integer, nullable=True)
colno = db.Column(db.Integer, nullable=True)
source = db.Column(db.Text, nullable=True)
job = db.relationship("Job")
__tablename__ = "styleviolation"
__repr__ = model_repr("repository_id", "job_id", "filename", "message")
class TestCase(RepositoryBoundMixin, db.Model):
"""
A single run of a single test.
"""
id = db.Column(GUID,
nullable=False,
primary_key=True,
default=GUID.default_value)
job_id = db.Column(GUID,
db.ForeignKey("job.id", ondelete="CASCADE"),
nullable=False)
hash = db.Column(db.String(40), nullable=False)
name = db.Column(db.Text, nullable=False)
result = db.Column(Enum(Result), default=Result.unknown, nullable=False)
# duration, in milliseconds
duration = db.Column(db.Integer, default=0, nullable=True)
message = db.deferred(db.Column(db.Text, nullable=True))
job = db.relationship("Job")
__tablename__ = "testcase"
__table_args__ = (db.UniqueConstraint("job_id",
"hash",
name="unq_testcase_hash"), )
__repr__ = model_repr("repository_id", "job_id", "name", "result")
@classmethod
def calculate_sha(self, name):
assert name
return sha1(name.encode("utf-8")).hexdigest()
@property
def sep(self):
name = self.name
# handle the case where it might begin with some special character
if not re.match(r"^[a-zA-Z0-9]", name):
return "/"
elif "/" in name:
return "/"
return "."
class StyleViolation(RepositoryBoundMixin, StandardAttributes, db.Model):
"""
A single style violation.
"""
job_id = db.Column(GUID,
db.ForeignKey('job.id', ondelete='CASCADE'),
nullable=False)
filename = db.Column(db.Text, nullable=False)
severity = db.Column(Enum(Severity),
default=Severity.error,
nullable=False)
message = db.Column(db.Text, nullable=False)
lineno = db.Column(db.Integer, nullable=True)
colno = db.Column(db.Integer, nullable=True)
source = db.Column(db.Text, nullable=True)
job = db.relationship('Job')
__tablename__ = 'styleviolation'
__repr__ = model_repr('repository_id', 'job_id', 'filename', 'message')
class TestCase(ProjectBoundMixin, db.Model):
"""
A single run of a single test.
"""
id = db.Column(GUID,
nullable=False,
primary_key=True,
default=GUID.default_value)
job_id = db.Column(GUID,
db.ForeignKey('job.id', ondelete="CASCADE"),
nullable=False)
hash = db.Column(db.String(40), nullable=False)
name = db.Column(db.Text, nullable=False)
result = db.Column(Enum(Result), default=Result.unknown, nullable=False)
# duration, in milliseconds
duration = db.Column(db.Integer, default=0, nullable=True)
message = db.deferred(db.Column(db.Text, nullable=True))
job = db.relationship('Job')
__tablename__ = 'testcase'
__table_args__ = (db.UniqueConstraint('job_id',
'hash',
name='unq_testcase_hash'), )
__repr__ = model_repr('job_id', 'name', 'result')
@classmethod
def calculate_sha(self, name):
assert name
return sha1(name.encode('utf-8')).hexdigest()
@property
def sep(self):
name = self.name
# handle the case where it might begin with some special character
if not re.match(r'^[a-zA-Z0-9]', name):
return '/'
elif '/' in name:
return '/'
return '.'
class Repository(StandardAttributes, db.Model):
"""
Represents a single repository.
"""
# TODO(dcramer): we dont want to be coupled to GitHub (the concept of orgs)
# but right now we simply dont care, and this can be refactored later (URLs
# are tricky)
owner_name = db.Column(db.String(200), nullable=False)
name = db.Column(db.String(200), nullable=False)
url = db.Column(db.String(200), nullable=False)
backend = db.Column(
Enum(RepositoryBackend), default=RepositoryBackend.unknown, nullable=False
)
status = db.Column(
Enum(RepositoryStatus), default=RepositoryStatus.inactive, nullable=False
)
provider = db.Column(StrEnum(RepositoryProvider), nullable=False)
external_id = db.Column(db.String(64))
data = db.Column(JSONEncodedDict, nullable=True)
public = db.Column(
db.Boolean, default=False, server_default="false", nullable=False, index=True
)
last_update = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
last_update_attempt = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
options = db.relationship(
"ItemOption",
foreign_keys="[ItemOption.item_id]",
primaryjoin="ItemOption.item_id == Repository.id",
viewonly=True,
uselist=True,
)
query_class = RepositoryAccessBoundQuery
__tablename__ = "repository"
__table_args__ = (
db.UniqueConstraint("provider", "external_id", name="unq_repo_external_id"),
db.UniqueConstraint("provider", "owner_name", "name", name="unq_repo_name"),
)
__repr__ = model_repr("name", "url", "provider")
def get_vcs(self):
from zeus.models import ItemOption
from zeus.vcs.git import GitVcs
options = dict(
db.session.query(ItemOption.name, ItemOption.value).filter(
ItemOption.item_id == self.id, ItemOption.name.in_(["auth.username"])
)
)
kwargs = {
"path": os.path.join(current_app.config["REPO_ROOT"], self.id.hex),
"id": self.id.hex,
"url": self.url,
"username": options.get("auth.username"),
}
if self.backend == RepositoryBackend.git:
return GitVcs(**kwargs)
else:
raise NotImplementedError("Invalid backend: {}".format(self.backend))
def get_full_name(self):
return "{}/{}/{}".format(self.provider, self.owner_name, self.name)
class Repository(StandardAttributes, db.Model):
"""
Represents a single repository.
"""
# TODO(dcramer): we dont want to be coupled to GitHub (the concept of orgs)
# but right now we simply dont care, and this can be refactored later (URLs
# are tricky)
owner_name = db.Column(db.String(200), nullable=False)
name = db.Column(db.String(200), nullable=False)
url = db.Column(db.String(200), nullable=False)
backend = db.Column(Enum(RepositoryBackend),
default=RepositoryBackend.unknown,
nullable=False)
status = db.Column(Enum(RepositoryStatus),
default=RepositoryStatus.inactive,
nullable=False)
provider = db.Column(StrEnum(RepositoryProvider), nullable=False)
external_id = db.Column(db.String(64))
data = db.Column(JSONEncodedDict, nullable=True)
last_update = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
last_update_attempt = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
options = db.relationship(
'ItemOption',
foreign_keys='[ItemOption.item_id]',
primaryjoin='ItemOption.item_id == Repository.id',
viewonly=True,
uselist=True)
query_class = RepositoryAccessBoundQuery
__tablename__ = 'repository'
__table_args__ = (
db.UniqueConstraint('provider',
'external_id',
name='unq_repo_external_id'),
db.UniqueConstraint('provider',
'owner_name',
'name',
name='unq_repo_name'),
)
__repr__ = model_repr('name', 'url', 'provider')
def get_vcs(self):
from zeus.models import ItemOption
from zeus.vcs.git import GitVcs
options = dict(
db.session.query(ItemOption.name, ItemOption.value).filter(
ItemOption.item_id == self.id,
ItemOption.name.in_([
'auth.username',
])))
kwargs = {
'path': os.path.join(current_app.config['REPO_ROOT'], self.id.hex),
'id': self.id.hex,
'url': self.url,
'username': options.get('auth.username'),
}
if self.backend == RepositoryBackend.git:
return GitVcs(**kwargs)
else:
raise NotImplementedError('Invalid backend: {}'.format(
self.backend))
def get_full_name(self):
return '{}/{}/{}'.format(self.provider, self.owner_name, self.name)
class Build(RepositoryBoundMixin, StandardAttributes, db.Model):
"""
A single build.
Each Build contains many Jobs.
"""
ref = db.Column(db.String, nullable=True)
revision_sha = db.Column(db.String(40), nullable=True)
number = db.Column(db.Integer, nullable=False)
label = db.Column(db.String, nullable=True)
status = db.Column(Enum(Status), nullable=False, default=Status.unknown)
result = db.Column(Enum(Result), nullable=False, default=Result.unknown)
date_created = db.Column(
db.TIMESTAMP(timezone=True),
nullable=False,
default=timezone.now,
server_default=func.now(),
index=True,
)
date_started = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
date_finished = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
data = db.Column(JSONEncodedDict, nullable=True)
provider = db.Column(db.String, nullable=True)
external_id = db.Column(db.String(64), nullable=True)
hook_id = db.Column(GUID,
db.ForeignKey("hook.id", ondelete="CASCADE"),
nullable=True,
index=True)
url = db.Column(db.String, nullable=True)
author_id = db.Column(
GUID,
db.ForeignKey("author.id", ondelete="SET NULL"),
index=False,
nullable=True,
)
authors = db.relationship("Author",
secondary=build_author_table,
backref="builds")
revision = db.relationship(
"Revision",
foreign_keys="[Build.repository_id, Build.revision_sha]",
viewonly=True,
)
hook = db.relationship("Hook")
stats = db.relationship(
"ItemStat",
foreign_keys="[ItemStat.item_id]",
primaryjoin="ItemStat.item_id == Build.id",
viewonly=True,
uselist=True,
)
failures = db.relationship(
"FailureReason",
foreign_keys="[FailureReason.build_id]",
primaryjoin="FailureReason.build_id == Build.id",
viewonly=True,
uselist=True,
)
__tablename__ = "build"
__table_args__ = (
db.UniqueConstraint("repository_id", "number",
name="unq_build_number"),
db.UniqueConstraint("repository_id",
"provider",
"external_id",
name="unq_build_provider"),
db.ForeignKeyConstraint(
("repository_id", "revision_sha"),
("revision.repository_id", "revision.sha"),
),
db.Index("idx_build_repo_sha", "repository_id", "revision_sha"),
db.Index("idx_build_author_date", "author_id", "date_created"),
db.Index("idx_build_outcomes", "repository_id", "status", "result",
"date_created"),
)
__repr__ = model_repr("number", "status", "result")
class Repository(StandardAttributes, db.Model):
"""
Represents a single repository.
"""
# TODO(dcramer): we dont want to be coupled to GitHub (the concept of orgs)
# but right now we simply dont care, and this can be refactored later (URLs
# are tricky)
owner_name = db.Column(db.String(200), nullable=False)
name = db.Column(db.String(200), nullable=False)
url = db.Column(db.String(200), nullable=False)
backend = db.Column(Enum(RepositoryBackend),
default=RepositoryBackend.unknown,
nullable=False)
status = db.Column(Enum(RepositoryStatus),
default=RepositoryStatus.inactive,
nullable=False)
provider = db.Column(StrEnum(RepositoryProvider), nullable=False)
external_id = db.Column(db.String(64))
data = db.Column(JSONEncodedDict, nullable=True)
public = db.Column(db.Boolean,
default=False,
server_default="false",
nullable=False,
index=True)
last_update = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
last_update_attempt = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
next_update = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
options = db.relationship(
"ItemOption",
foreign_keys="[ItemOption.item_id]",
primaryjoin="ItemOption.item_id == Repository.id",
viewonly=True,
uselist=True,
)
query_class = RepositoryAccessBoundQuery
__tablename__ = "repository"
__table_args__ = (
db.UniqueConstraint("provider",
"external_id",
name="unq_repo_external_id"),
db.UniqueConstraint("provider",
"owner_name",
"name",
name="unq_repo_name"),
)
__repr__ = model_repr("name", "url", "provider")
def get_full_name(self):
return "{}/{}/{}".format(self.provider, self.owner_name, self.name)
@staticmethod
def get_lock_key(provider: str, owner_name: str, repo_name: str) -> str:
return "repo:{provider}/{owner_name}/{repo_name}".format(
provider=provider, owner_name=owner_name, repo_name=repo_name)
@classmethod
def from_full_name(cls, full_name):
provider, owner_name, name = full_name.split("/", 2)
return cls.query.filter_by(provider=RepositoryProvider(provider),
owner_name=owner_name,
name=name).first()
