def get_all_workers(cls, ):
"""
Returns a list of all the workers currently in the database
:returns list of Worker
"""
session = meta.Session()
return session.query(cls).all()
def get_worker_by_name(cls, name):
"""
Returns an Worker with the given name.
returns: Worker
"""
session = meta.Session()
return session.query(Worker).filter(cls.name == name).first()
def get_jobs(cls, users=None, statuses: List[JobStatus] = None, days=None, storages=None):
"""
Returns Jobs, filter by:
:param days: how many days in the past
:param users: List of users they may belong to
:param statuses: their status
:param storages: List of storage aliases
:type storages: List<String>
:type days: int
:type users: List<User>
"""
session = meta.Session()
jobs = session.query(cls)
intersection = []
if days is not None:
days = int(days)
intersection = jobs.filter(cls.ended_at >= datetime.date.today() - datetime.timedelta(days=days)).all()
if users is not None:
jobs = jobs.filter(cls.user.in_(users))
intersection = jobs if not intersection else list(set(intersection) & set(jobs.all()))
if statuses is not None:
jobs = jobs.filter(cls.status.in_(statuses))
intersection = jobs if not intersection else list(set(intersection) & set(jobs.all()))
if storages is not None:
jobs = jobs.filter(or_(cls.source_alias.in_(storages), cls.target_alias.in_(storages)))
intersection = jobs if not intersection else list(set(intersection) & set(jobs.all()))
return intersection
def get_worker_by_id(cls, id):
"""
Returns a worker with the given id or None
:param id: id to look for
:type id: int
:returns Worker or None
"""
session = meta.Session()
return session.query(cls).filter(cls.id == id).one_or_none()
def get_storage_by_name(cls, name):
"""
Returns a Storage with the given Name or None
:param name: the alias to search
:type name: String
:returns a Storage or None
"""
session = meta.Session()
return session.query(cls).filter(cls.alias == name).one_or_none()
def get_job_by_id(cls, job_id):
"""
Returns a Job with the given id or None
:param id: id to look for
:type id: int
:returns Job or None
"""
session = meta.Session()
job = session.query(cls).filter(cls.id==job_id).one_or_none()
if job is None:
raise JobNotFoundException("Job with ID " + str(job_id) + " doesn't exist")
return job
def get_users(cls, roles=None, names=None):
"""
Returns users with the given parameters:
:param roles: List of roles (User,Admin,...)
:param names: List of Names
"""
session = meta.Session()
users = session.query(cls)
if role is not None:
users = users.filter(cls.user_type.in_(roles))
if name is not None:
users = users.filter(cls.name.in_(names))
def calc_counter(cls, label, username) -> int:
session = meta.Session()
workspaces = session.query(cls).filter(cls.label == label).filter(
cls.username == username).all()
numbers = [x.counter for x in workspaces]
if not numbers: numbers = [-1]
for i in range(0, max(numbers) + 3):
if i in numbers:
continue
else:
return i
def get_user_by_username(cls, username):
"""
Returns a user with the given Name or None
:param username: name to look for
:type username: String
:returns: User or None
"""
session = meta.Session()
user = session.query(cls).filter(cls.name == username).one_or_none()
if user is None:
raise UserNotFoundException("User " + username + " does not exist")
else:
return user
def __init__(self, name, token=None):
"""
Default Constructor
:param name: name of the user
:param token: secret
:type name: String
:type token: String
"""
self.name = name
self.token = token
session = meta.Session()
session.add(self)
session.commit()
def get_idle_workers_for_storages(cls, source, target):
"""
Returns the first worker which can acces both storages
:param source: alias of the source
:param target: alias of the target
:type source: String
:type target: String
returns: Worker
"""
session = meta.Session()
return session.query(cls).filter(
and_(cls.storages.any(Storage.alias == source)),
(cls.storages.any(Storage.alias == target)),
(cls.status == WorkerStatus.WAITING.name)).all()
def get_job_by_priority(cls, priority):
session = meta.Session()
return session.query(cls).filter(cls.status=='QUEUED', cls.priority==priority).one_or_none()
def get_worker_by_job_id(cls, id):
session = meta.Session()
return session.query(Worker).filter(
cls.current_job_id == id).one_or_none()
def get_by_full_name(cls, full_name):
session = meta.Session()
workspaces = session.query(cls).filter(
cls.full_name == full_name).one_or_none()
return workspaces
def get_by_triple(cls, username, label, counter):
session = meta.Session()
w = session.query(cls).filter(Workspaces.username == username)\
.filter(Workspaces.label == label)\
.filter(Workspaces.counter==counter).first()
return w
def get_storage_by_mountpoint(cls, mnt):
session = meta.Session()
return session.query(cls).filter(cls.mountpoint == mnt).one_or_none()
def get_home_storages(cls):
session = meta.Session()
return session.query(cls).filter(cls.has_home_dir == True).all()
def get_storages(cls):
session = meta.Session()
return session.query(cls).all()
def get_job_highest_priority(cls):
session = meta.Session()
return session.query(cls).filter(cls.status=='QUEUED').order_by(cls.priority.desc()).first()
def get_by_path(cls, path):
session = meta.Session()
workspaces = session.query(cls).filter(
cls.full_path == path).one_or_none()
return workspaces
def get_by_username(cls, username):
session = meta.Session()
workspaces = session.query(cls).filter(cls.username == username).all()
return workspaces
def get_all(cls):
session = meta.Session()
workspaces = session.query(cls)
return workspaces.all()