def new(cls, user: User, repo_name: str, quota_gb: int = None) -> 'Repository':
if quota_gb is None:
quota_gb = math.floor(_cfg['default_repo_quota'] / 1000 / 1000 / 1000)
repo = None
if len(repo_name) > 20:
raise DatabaseError("Repository name has to be 20 characters or less")
with _db.atomic():
count = cls.select().where(cls.user == user).count()
if count >= user.max_repo_count:
raise DatabaseError("Too many repositories")
repo = cls._create(user=user, name=repo_name, _quota_gb=quota_gb)
return repo
def parse_ssh_key(key_string: str) -> SSHKey:
try:
key = SSHKey(key_string)
key.parse()
if not key.comment:
raise ValueError("No name set. Please add a name to your key.")
return key
except InvalidKeyError as err:
raise DatabaseError(f"Invalid SSH key: {err}")
def _create(cls, **query):
name = query['name']
if len(name) > 20:
raise DatabaseError("User name has to be 20 characters or less")
if not _name_regex.match(name):
raise DatabaseError("Name may only contain these characters: [a-zA-Z0-9_]")
try:
cls.get(cls.name == name)
raise DatabaseError(f"User already exists: '{name}'")
except DoesNotExist:
pass
try:
_storage.create_user(name)
with _db.atomic():
user = super().create(**query)
UserLog.log(user, LogOperation.CREATE_USER, name)
except IntegrityError:
_storage.delete_user(name)
raise
return user
def quota(self, new_quota: int):
try:
if new_quota < 1:
raise DatabaseError("Quota must be bigger than 0")
repos = Repository.select().where(Repository.user == self.user)
combined_size = 0
for iter_repo in repos:
combined_size += iter_repo.quota
new_size = combined_size - self.quota + new_quota
if new_size > self.user.quota:
max_size = self.user.quota - (combined_size - self.quota)
raise DatabaseError("Proposed repo size would be too large to fit user quota. "
f"Maximum size would be {math.floor(max_size / 1000 / 1000 / 1000)}")
if new_size < self.quota_used:
raise DatabaseError("Proposed repo size would be too small to fix the current repo size. "
f"Minimum size would be {self.size_gb}")
_storage.set_new_quota(self, new_quota)
self._quota = new_quota
self.save()
except StorageError as e:
raise DatabaseError(e)
def _create(cls, **query):
user = query['user']
name = query['name']
if not _name_regex.match(name):
raise DatabaseError("Name may only contain these characters: [a-zA-Z0-9_]")
quota_gb = query['_quota_gb']
with _db.atomic() as transaction:
_storage.create_repo(user.name, name)
repo = super().create(**query)
try:
repo.quota_gb = quota_gb
except DatabaseError:
transaction.rollback()
_storage.delete_repo(user.name, name)
raise
RepoLog.log(repo, LogOperation.CREATE_REPO, name)
return repo
def get_by_id(cls, id: int) -> 'Repository':
try:
return cls.get((cls.id == id))
except DoesNotExist:
raise DatabaseError(f"Repository with id '{id}' does not exist")
def get_by_name(cls, name: str, user: User) -> 'Repository':
try:
return cls.get((cls.name == name) & (cls.user == user))
except DoesNotExist:
raise DatabaseError(f"Repository with name '{name}' does not exist for user '{user.name}'")
def get_repo_by_name(self, repo_name) -> 'Repository':
try:
return Repository.get((Repository.user == self) & (Repository.name == repo_name))
except DoesNotExist:
raise DatabaseError(f"Repo with name '{repo_name}' for user '{self.name}' does not exist")
def get_by_id(cls, uid: int) -> 'User':
try:
return cls.get(cls.id == uid)
except DoesNotExist:
raise DatabaseError(f"User with id '{uid}' does not exist")
def get_by_name(cls, name: str) -> 'User':
try:
return cls.get(cls.name == name)
except DoesNotExist:
raise DatabaseError(f"User '{name}' does not exist")