def cache_namespace_repository_sizes(namespace_name): namespace = user.get_user_or_org(namespace_name) now_ms = get_epoch_timestamp_ms() subquery = (Tag.select(Tag.repository_id).where( Tag.hidden == False).where((Tag.lifetime_end_ms >> None) | (Tag.lifetime_end_ms > now_ms)).group_by( Tag.repository_id).having( fn.Count(Tag.name) > 0)) namespace_repo_sizes = (Manifest.select( (Repository.id).alias("repository_id"), (Repository.name).alias("repository_name"), fn.sum(Manifest.layers_compressed_size).alias("repository_size"), ).join(Repository).join( subquery, on=(subquery.c.repository_id == Repository.id)).where( Repository.namespace_user == namespace.id).group_by(Repository.id)) insert_query = (namespace_repo_sizes.select( Repository.id, fn.sum(Manifest.layers_compressed_size)).join_from( Repository, RepositorySize, JOIN.LEFT_OUTER).where(RepositorySize.repository_id.is_null())) RepositorySize.insert_from( insert_query, fields=[RepositorySize.repository_id, RepositorySize.size_bytes], ).execute()
def _latest_logs_query(selections, performer=None, repository=None, namespace=None, ignore=None, model=LogEntry3, size=None): """ Returns a query for selecting the latest logs from the table, with various options and filters. """ query = (model.select(*selections).switch(model)) if repository: query = query.where(model.repository == repository) if performer: query = query.where(model.repository == repository) if namespace and not repository: namespace_user = user.get_user_or_org(namespace) if namespace_user is None: raise DataModelException('Invalid namespace requested') query = query.where(model.account == namespace_user.id) if ignore: kind_map = get_log_entry_kinds() ignore_ids = [kind_map[kind_name] for kind_name in ignore] query = query.where(~(model.kind << ignore_ids)) query = query.order_by(model.datetime.desc(), model.id) if size: query = query.limit(size) return query
def delete(self, namespace, quota_id): if SuperUserPermission().can(): namespace_user = user.get_user_or_org(namespace) quota = get_quota(namespace_user.username, quota_id) namespacequota.delete_namespace_quota(quota) return "", 204 raise Unauthorized()
def _logs_query( selections, start_time=None, end_time=None, performer=None, repository=None, namespace=None, ignore=None, model=LogEntry3, id_range=None, namespace_id=None, ): """ Returns a query for selecting logs from the table, with various options and filters. """ if namespace is not None: assert namespace_id is None if namespace_id is not None: assert namespace is None assert (start_time is not None and end_time is not None) or (id_range is not None) joined = model.select(*selections).switch(model) if id_range is not None: joined = joined.where(model.id >= id_range[0], model.id <= id_range[1]) else: joined = joined.where(model.datetime >= start_time, model.datetime < end_time) if repository: joined = joined.where(model.repository == repository) if performer: joined = joined.where(model.performer == performer) if namespace and not repository: namespace_user = user.get_user_or_org(namespace) if namespace_user is None: raise DataModelException("Invalid namespace requested: %s" % namespace) joined = joined.where(model.account == namespace_user.id) if namespace_id is not None and not repository: joined = joined.where(model.account == namespace_id) if ignore: kind_map = get_log_entry_kinds() ignore_ids = [kind_map[kind_name] for kind_name in ignore] joined = joined.where(~(model.kind << ignore_ids)) return joined
def get_namespace_size(namespace_name): namespace = user.get_user_or_org(namespace_name) now_ms = get_epoch_timestamp_ms() subquery = (Tag.select(Tag.repository_id).where( Tag.hidden == False).where((Tag.lifetime_end_ms >> None) | (Tag.lifetime_end_ms > now_ms)).group_by( Tag.repository_id).having( fn.Count(Tag.name) > 0)) namespace_size = (Manifest.select(fn.sum( Manifest.layers_compressed_size)).join(Repository).join( subquery, on=(subquery.c.repository_id == Repository.id)).where( Repository.namespace_user == namespace.id)).scalar() return namespace_size or 0
def put(self, namespace, quota_id): if SuperUserPermission().can(): quota_data = request.get_json() namespace_user = user.get_user_or_org(namespace) quota = get_quota(namespace_user.username, quota_id) try: if "limit_bytes" in quota_data: limit_bytes = quota_data["limit_bytes"] namespacequota.update_namespace_quota_size( quota, limit_bytes) except DataModelException as ex: raise request_error(exception=ex) return quota_view(quota) raise Unauthorized()
def post(self, namespace): if SuperUserPermission().can(): quota_data = request.get_json() limit_bytes = quota_data["limit_bytes"] namespace_user = user.get_user_or_org(namespace) quotas = namespacequota.get_namespace_quota_list( namespace_user.username) if quotas: raise request_error(message="Quota for '%s' already exists" % namespace) try: newquota = namespacequota.create_namespace_quota( namespace_user, limit_bytes) return "Created", 201 except DataModelException as ex: raise request_error(exception=ex) raise Unauthorized()
def delete_notifications_by_kind(self, target_username, kind_name): target = get_user_or_org(target_username) delete_notifications_by_kind(target, kind_name)
def create_unique_notification(self, kind_name, target_username, metadata={}): target = get_user_or_org(target_username) create_unique_notification(kind_name, target, metadata)