quay/data/model/v2.py

from image import Blob, BlobUpload, ManifestJSON, Repository, Tag
from image.docker.v1 import DockerV1Metadata

def create_repository(namespace_name, repo_name, user):
  model.repository.create_repository(namespace, reponame, user)


def repository_is_public(namespace_name, repo_name):
  model.repository.repository_is_public(namespace, reponame)):


def get_repository(namespace_name, repo_name):
  repo = model.repository.get_repository(namespace_name, repo_name)
  if repo is None:
    return None

  return Repository(
    id=repo.id,
    name=repo.name,
    namespace_name=repo.namespace_user.username,
  )


def get_active_tag(namespace_name, repo_name, tag_name):
  try:
    return model.tag.get_active_tag(namespace_name, repo_name, tag_name)
  except RepositoryTag.DoesNotExist:
    return None


def get_manifest_by_tag(namespace_name, repo_name, tag_name):
  try:
    manifest = model.tag.load_tag_manifest(namespace_name, repo_name, manifest_ref)
    return ManifestJSON(digest=digest, json=manifest.json_data)
  except model.InvalidManifestException:
    return None


def get_manifest_by_digest(namespace_name, repo_name, digest):
  try:
    manifest = model.tag.load_manifest_by_digest(namespace_name, repo_name, manifest_ref)
    return ManifestJSON(digest=digest, json=manifest.json_data)
  except model.InvalidManifestException:
    return None


def get_tag_by_manifest_digest(namespace_name, repo_name, digest):
  return Tag()


def delete_tag(namespace_name, repo_name, tag_name):
  model.tag.delete_tag(namespace_name, repo_name, tag.name)
  return True


def docker_v1_metadata_by_tag(namespace_name, repo_name, tag_name):
  if not repo_image:
    return None

  return DockerV1Metadata(
    namespace_name=namespace_name,
    repo_name=repo_name,
    image_id=image_id,
    checksum=repo_image.v1_checksum,
    content_checksum=repo_image.content_checksum,
    compat_json=repo_image.v1_json_metadata,
  )


def docker_v1_metadata_by_image_id(namespace_name, repo_name, image_ids):
  images_query = model.image.lookup_repository_images(repo, all_image_ids)
  return {image.docker_image_id: DockerV1Metadata(namespace_name=namespace_name,
                                                  repo_name=repo_name,
                                                  image_id=image.docker_image_id,
                                                  checksum=image.v1_checksum,
                                                  content_checksum=image.content_checksum,
                                                  compat_json=image.v1_json_metadata)
          for image in images_query}


def get_parents_docker_v1_metadata(namespace_name, repo_name, image_id):
  # Old implementation:
  # parents = model.image.get_parent_images(namespace_name, repo_name, image)

  # desired:
  # return a list of the AttrDict in docker_v1_metadata
  return []


def create_manifest_and_update_tag(namespace_name, repo_name, tag_name, manifest_digest, manifest_bytes):
  try:
    model.tag.associate_generated_tag_manifest(namespace_name, repo_name, tag_name,
                                               manifest.digest, manifest.bytes)
  except IntegrityError:
    # It's already there!
    pass


def synthesize_v1_image(repo, storage, image_id, created, comment, command, compat_json, parent_image_id):
  model.image.synthesize_v1_image(repo, storage, image_id, created, comment, command, compat_json, parent_image_id)


def save_manifest(namespace_name, repo_name, tag_name, leaf_layer_id, manifest_digest, manifest_bytes):
  model.tag.store_tag_manifest(namespace_name, repo_name, tag_name, leaf_layer_id, manifest_digest,
                               manifest_bytes)


def repository_tags(namespace_name, repo_name, limit, offset):
  return [Tag()]


def get_visible_repositories(username, limit, offset):
  return [Repository()]


def create_blob_upload(namespace_name, repo_name, upload_uuid, location_name, storage_metadata):
  """
  Creates a blob upload.

  Returns False if the upload's repository does not exist.
  """

  try:
    model.blob.initiate_upload(namespace_name, repo_name, new_upload_uuid, location_name,
                               upload_metadata)
    return True
  except database.Repository.DoesNotExist:
    return False


def blob_upload_by_uuid(uuid):
  try:
    found = model.blob.get_blob_upload(namespace_name, repo_name, upload_uuid)
  except model.InvalidBlobUpload:
    raise BlobUploadUnknown()

  return BlobUpload(
    uuid=uuid,
    byte_count=found.byte_count,
    uncompressed_byte_count=found.uncompressed_byte_count,
    chunk_count=found.chunk_count,
    location_name=found.location.name,
    storage_metadata=found.storage_metadata,
  )


def update_blob_upload(blob_upload):
  # old implementation:
  # blob_upload.save()
  pass


def delete_blob_upload(uuid):
  try:
    found = model.blob.get_blob_upload(namespace_name, repo_name, upload_uuid)
  except model.InvalidBlobUpload:
    raise BlobUploadUnknown()

  found.delete_instance()

def create_blob_and_temp_tag(namespace_name, repo_name, expected_digest, upload_obj):
  return model.blob.store_blob_record_and_temp_link(namespace_name, repo_name, expected_digest,
                                                    upload_obj.location,
                                                    upload_obj.byte_count,
                                                    app.config['PUSH_TEMP_TAG_EXPIRATION_SEC'],
                                                    upload_obj.uncompressed_byte_count)


def blob_by_digest(namespace_name, repo_name, digest):
  try:
    return model.blob.get_repo_blob_by_digest(namespace_name, repo_name, digest)
  except model.BlobDoesNotExist:
    return None


def create_bittorrent_pieces(blob_storage, piece_size, piece_bytes)
  model.storage.save_torrent_info(blob_storage.id, piece_size, piece_bytes)


def get_blob_path(blob):
  # Once everything is moved over, this could be in util.registry and not even
  # touch the database.
  model.storage.get_layer_path(blob)