quay/data/model/blob.py

from uuid import uuid4

from data.model import (tag, _basequery, BlobDoesNotExist, InvalidBlobUpload, db_transaction,
                        storage as storage_model, InvalidImageException)
from data.database import (Repository, Namespace, ImageStorage, Image, ImageStorageLocation,
                           ImageStoragePlacement, BlobUpload)


def get_repo_blob_by_digest(namespace, repo_name, blob_digest):
  """ Find the content-addressable blob linked to the specified repository.
  """
  try:
    storage_id_query = (ImageStorage
                        .select(ImageStorage.id)
                        .join(Image)
                        .join(Repository)
                        .join(Namespace, on=(Namespace.id == Repository.namespace_user))
                        .where(Repository.name == repo_name, Namespace.username == namespace,
                               ImageStorage.content_checksum == blob_digest,
                               ImageStorage.uploading == False)
                        .limit(1))

    return storage_model.get_storage_by_subquery(storage_id_query)
  except InvalidImageException:
    raise BlobDoesNotExist('Blob does not exist with digest: {0}'.format(blob_digest))


def store_blob_record_and_temp_link(namespace, repo_name, blob_digest, location_obj, byte_count,
                                    link_expiration_s, uncompressed_byte_count=None):
  """ Store a record of the blob and temporarily link it to the specified repository.
  """
  random_image_name = str(uuid4())
  with db_transaction():
    repo = _basequery.get_existing_repository(namespace, repo_name)
    try:
      storage = ImageStorage.get(content_checksum=blob_digest)
      storage.image_size = byte_count

      if uncompressed_byte_count is not None:
        storage.uncompressed_size = uncompressed_byte_count

      storage.save()

      ImageStoragePlacement.get(storage=storage, location=location_obj)
    except ImageStorage.DoesNotExist:
      storage = ImageStorage.create(content_checksum=blob_digest, uploading=False,
                                    image_size=byte_count,
                                    uncompressed_size=uncompressed_byte_count)
      ImageStoragePlacement.create(storage=storage, location=location_obj)
    except ImageStoragePlacement.DoesNotExist:
      ImageStoragePlacement.create(storage=storage, location=location_obj)

    # Create a temporary link into the repository, to be replaced by the v1 metadata later
    # and create a temporary tag to reference it
    image = Image.create(storage=storage, docker_image_id=random_image_name, repository=repo)
    tag.create_temporary_hidden_tag(repo, image, link_expiration_s)

  return storage


def get_blob_upload(namespace, repo_name, upload_uuid):
  """ Load the upload which is already in progress.
  """
  try:
    return (BlobUpload
            .select()
            .join(Repository)
            .join(Namespace, on=(Namespace.id == Repository.namespace_user))
            .where(Repository.name == repo_name, Namespace.username == namespace,
                   BlobUpload.uuid == upload_uuid)
            .get())
  except BlobUpload.DoesNotExist:
    raise InvalidBlobUpload()


def initiate_upload(namespace, repo_name, uuid, location_name, storage_metadata):
  repo = _basequery.get_existing_repository(namespace, repo_name)
  location = ImageStorageLocation.get(name=location_name)
  return BlobUpload.create(repository=repo, location=location, uuid=uuid,
                           storage_metadata=storage_metadata)