class Job(Model):
"""Job cache model."""
__database__ = BaseCache.model_db
created_at = DateTimeField()
updated_at = DateTimeField()
job_id = TextField(primary_key=True, index=True)
user_id = TextField(index=True)
state = TextField()
extras = JSONField()
def in_progress(self):
"""Mark job in progress."""
self.state = USER_JOB_STATE_IN_PROGRESS
self.save()
def complete(self):
"""Mark job as completed."""
self.state = USER_JOB_STATE_COMPLETED
self.save()
def fail_job(self, error):
"""Mark job as failed."""
self.state = USER_JOB_STATE_FAILED
if not self.extras:
self.extras = {}
self.extras['error'] = error
self.save()
class File(Model):
"""User file object."""
__database__ = BaseCache.model_db
created_at = DateTimeField()
file_id = TextField(primary_key=True, index=True)
user_id = TextField(index=True)
content_type = TextField()
file_name = TextField()
file_size = IntegerField()
relative_path = TextField()
is_archive = BooleanField()
is_dir = BooleanField()
unpack_archive = BooleanField()
@property
def abs_path(self):
"""Full path of cached file."""
return CACHE_UPLOADS_PATH / self.user_id / self.relative_path
def valid_file(self):
"""Ensure a file exists."""
if self.abs_path.exists():
self.is_dir = self.abs_path.is_dir()
return True
return False
class Deploy(CustomModel):
__database__ = db
id = TextField(primary_key=True)
project_id = TextField(index=True)
build_id = TextField(index=True)
creation_date = DateTimeField(index=True, default=datetime.datetime.now)
def __init__(self, *args, **kwargs) -> None:
kwargs['id'] = deploy_id(kwargs['project_id'], kwargs['build_id'])
super().__init__(*args, **kwargs)
@property
def build(self) -> Build:
"""
Returns the build for this deployment
"""
return Build.get(Build.id == self.build_id)
@property
def project(self) -> Project:
"""
Returns the project for this deployment
"""
return Project.get(Project.id == self.project_id)
@property
def log_path(self) -> Path:
"""
Path to self.project.log_path/deploys/self.id
"""
return self.project.log_path / "deploys" / self.id
class Player(Model):
__database__ = db
name = TextField(
primary_key=True) ## combination of game, lobbyname and playername
lobby = TextField(index=True)
user = IntegerField()
data = JSONField()
class Score(Model):
__database__ = db
casa = TextField(index=True)
carta = TextField(index=True)
ponto = TextField(index=True)
move = TextField(index=True)
valor = IntegerField(index=True)
data = DateTimeField()
class Location(Model):
__database__ = WALRUS_DB
# __namespace__ = 'my-app'
name = TextField(primary_key=True)
county = TextField()
state = TextField(index=True)
country = TextField()
confirmed = HashField()
deaths = HashField()
class User(Model):
"""User cache model."""
__database__ = BaseCache.model_db
user_id = TextField(primary_key=True, index=True)
fullname = TextField()
email = TextField()
token = TextField()
class GroupSettings(RBase):
id = TextField(primary_key=True)
welcome_text = TextField(default=welcome_text)
invite_text = TextField(default=invite_text)
group_patterns = JSONField(default=group_patterns)
creators = ListField()
mp_forward = JSONField(default=[])
kick_quorum_n = IntegerField(default=5)
kick_period = IntegerField(default=5)
kick_text = TextField(default=kick_text)
class User(Model):
__database__ = db
user_id = TextField(primary_key=True)
nome = TextField(index=True, default=u"__NONE__")
escola = TextField(index=True, default=u"__NONE__")
genero = TextField(index=True, default=u"__NONE__")
serie = IntegerField(index=True, default=0)
idade = IntegerField(index=True, default=0)
score = ListField(as_json=True)
data = DateTimeField(default=datetime.datetime(1, 2, 1, 0, 0, 0, 0))
class Lobby(Model):
__database__ = db
name = TextField(primary_key=True)
timestamp = IntegerField()
mode = TextField()
password = TextField()
game = IntegerField(index=True)
setup = IntegerField()
owner = IntegerField()
class Issue(Model):
__database__ = db
issue_name = TextField(index=True)
id = TextField(primary_key=True, default=lambda: str(
time.time()).replace('.', ''))
date_created = DateField(default=datetime.datetime.now, index=True)
def serialize(self):
return dict(id=self.id,
name=self.issue_name,
date_created=str(self.date_created))
class Project(CustomModel):
__database__ = db
name = TextField(index=True)
org = TextField(index=True)
id = TextField(primary_key=True)
url = TextField(index=True)
creation_date = DateTimeField(index=True, default=datetime.datetime.now)
secrets = JSONField(default={})
def __init__(self, *args, **kwargs) -> None:
kwargs['id'] = project_id(kwargs['org'], kwargs['name'])
super().__init__(*args, **kwargs)
@property
def full_name(self) -> str:
"""
Munges org and name together to get a more unique name
"""
return f"{self.org}/{self.name}"
@property
def log_path(self) -> Path:
"""
Path to log_base/project.id
"""
return log_base / self.id
@property
def builds(self) -> Any:
"""
Returns a list of builds for this project ordered by their creation_date
"""
return Build.query(Build.project_id == self.id, order_by=Build.creation_date)
@property
def deploys(self) -> Any:
"""
Returns a list of deployments for this project ordered by their creation_date
"""
return Deploy.query(Deploy.project_id == self.id, order_by=Deploy.creation_date)
def build(self) -> None:
"""
Trys to bulid the project and creates new build record
"""
pass
class Project(Model):
"""User project object."""
__database__ = BaseCache.model_db
created_at = DateTimeField()
project_id = TextField(primary_key=True, index=True)
user_id = TextField(index=True)
clone_depth = IntegerField()
git_url = TextField()
name = TextField()
fullname = TextField()
email = TextField()
owner = TextField()
token = TextField()
@property
def abs_path(self):
"""Full path of cached project."""
return CACHE_PROJECTS_PATH / self.user_id / self.owner / self.name
def exists(self):
"""Ensure a project exists on file system."""
return self.abs_path.exists()
def ttl_expired(self, ttl=None):
"""Check if project time to live has expired."""
if not self.created_at:
# If record does not contain created_at,
# it means its an old record, and
# we should mark it for deletion.
return True
ttl = ttl or int(os.getenv('RENKU_SVC_CLEANUP_TTL_PROJECTS', 1800))
created_at = (self.created_at -
datetime.utcfromtimestamp(0)).total_seconds() * 1e+3
age = ((time.time() * 1e+3) - created_at) / 1e+3
return self.exists() and age >= ttl
def purge(self):
"""Removes project from file system and cache."""
shutil.rmtree(str(self.abs_path))
self.delete()
def is_locked(self, jobs):
"""Check if file locked by given jobs."""
return bool(
next((job for job in jobs if self.project_id in job.locked),
False))
class AutoBotSubmission(AutoBotBaseModel):
submission_id = TextField(primary_key=True)
author = TextField(index=True)
submission_time = IntegerField()
is_series = BooleanField()
sent_series_pm = BooleanField()
deleted = BooleanField()
@classmethod
def set_ttl(cls, submission, ttl=86400):
submission.to_hash().expire(ttl=ttl)
def set_index_ttls(self, ttl=86400):
'''Kind of a hacky way to get index keys to expire since they
are normally created without any TTL whatsoever.'''
for mi in self._indexes:
for index in mi.get_indexes():
key = index.get_key(index.field_value(self)).key
self.database.expire(key, ttl)
class Build(CustomModel):
__database__ = db
id = TextField(primary_key=True)
project_id = TextField(index=True)
commit_id = TextField(index=True)
branch = TextField(index=True)
creation_date = DateTimeField(index=True, default=datetime.datetime.now)
def __init__(self, *args, **kwargs) -> None:
kwargs['id'] = build_id(kwargs['project_id'], kwargs['commit_id'])
super().__init__(*args, **kwargs)
@property
def project(self) -> Project:
"""
Returns the project this build is for
"""
return Project.get(Project.id == self.project_id)
@property
def log_path(self) -> Path:
"""
Path to self.project.log_path/self.id
"""
return self.project.log_path / "builds" / self.id
@property
def logs(self) -> str:
"""
Reads the contents of a build log
"""
return self.log_path.open().read()
@property
def deploys(self) -> Any:
"""
Returns a list of Deploys for this build ordered by their creation_date
"""
return Deploy.query(Deploy.build_id == self.id, order_by=Deploy.creation_date)
class Player(walrus.Model):
database = db
name = TextField(primary_key=True)
bank_roll = IntegerField(default=100)
extra_bet = IntegerField(default=0)
def __repr__(self):
return u"%s: Bank$: %d" % (self.name, self.bank_roll)
def win(self, bet):
self.bank_roll += bet
def lose(self, bet):
self.bank_roll -= bet
class UploadCache(Model):
__database__ = redis_db
_id = 0
id = IntegerField(primary_key=True)
cache = ListField()
sequence_number = IntegerField(default=0)
max_sequence_number = IntegerField(default=0)
# store upload file information
size = IntegerField(default=0)
path = TextField(default='/')
md5 = TextField()
upload_date = DateTimeField()
file_name = TextField()
filetype = IntegerField()
user_id = IntegerField()
# store saving task information
saving_task_start = BooleanField(default=False)
@classmethod
def generate_id(cls):
rv = cls._id
cls._id += 1
return rv
class Services(Model):
name = TextField(primary_key=True)
_keys = [
'shell', 's_entry', 's_conf', 'collector', 'c_entry', 'c_conf', 'tasks'
]
collector = TextField()
c_entry = TextField()
c_conf = TextField()
shell = TextField()
s_entry = TextField()
s_conf = TextField()
tasks = PickledField()
class Project(Model):
"""User project object."""
__database__ = BaseCache.model_db
created_at = DateTimeField()
project_id = TextField(primary_key=True, index=True)
user_id = TextField(index=True)
clone_depth = IntegerField()
git_url = TextField()
name = TextField()
fullname = TextField()
email = TextField()
owner = TextField()
token = TextField()
@property
def abs_path(self):
"""Full path of cached project."""
return CACHE_PROJECTS_PATH / self.user_id / self.owner / self.name
class Job(Model):
"""Job cache model."""
__database__ = BaseCache.model_db
created_at = DateTimeField()
updated_at = DateTimeField()
job_id = TextField(primary_key=True, index=True)
user_id = TextField(index=True)
project_id = TextField(index=True)
renku_op = TextField()
state = TextField()
extras = JSONField()
client_extras = TextField()
locked = SetField()
def in_progress(self):
"""Mark job in progress."""
self.state = USER_JOB_STATE_IN_PROGRESS
self.save()
def complete(self):
"""Mark job as completed."""
self.state = USER_JOB_STATE_COMPLETED
self.save()
def fail_job(self, error):
"""Mark job as failed."""
self.state = USER_JOB_STATE_FAILED
if not self.extras:
self.extras = {}
self.extras["error"] = error
self.save()
def update_extras(self, key, value):
"""Update extras field."""
if not self.extras:
self.extras = {key: value}
else:
self.extras[key] = value
class CountdownTracker(Model):
__database__ = db
id = TextField(primary_key=True)
seconds = IntegerField()
desc = TextField()
created_at = DateTimeField(default=datetime.now)
class Params(Model):
name = TextField(primary_key=True)
data = HashField() # {'key': 'value, 'api_key': KEY}
class User(Model):
__database__ = db
nickname = TextField(primary_key=True)
class File(Model):
"""User file object."""
__database__ = BaseCache.model_db
created_at = DateTimeField()
file_id = TextField(primary_key=True, index=True)
user_id = TextField(index=True)
content_type = TextField()
file_name = TextField()
file_size = IntegerField()
relative_path = TextField()
is_archive = BooleanField()
is_dir = BooleanField()
unpack_archive = BooleanField()
@property
def abs_path(self):
"""Full path of cached file."""
return CACHE_UPLOADS_PATH / self.user_id / self.relative_path
def exists(self):
"""Ensure a file exists on file system."""
if self.abs_path.exists():
self.is_dir = self.abs_path.is_dir()
return True
return False
def ttl_expired(self, ttl=None):
"""Check if file time to live has expired."""
if not self.created_at:
# If record does not contain created_at,
# it means its an old record, and
# we should mark it for deletion.
return True
ttl = ttl or int(os.getenv("RENKU_SVC_CLEANUP_TTL_FILES", 1800))
created_at = (self.created_at -
datetime.utcfromtimestamp(0)).total_seconds() * 1e3
age = ((time.time() * 1e3) - created_at) / 1e3
return self.exists() and age >= ttl
def purge(self):
"""Removes file from file system and cache."""
if self.abs_path.is_file():
self.abs_path.unlink()
if self.abs_path.is_dir():
shutil.rmtree(str(self.abs_path))
self.delete()
def is_locked(self, jobs):
"""Check if file locked by given jobs."""
return bool(
next((job for job in jobs if self.file_id in job.locked), False))
