mstore/app/operator/blob.go

package operator

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"strconv"

	"mstore/pkg/auxuuid"
)

type BlobExistsParams struct {
	Name   string
	Digest string
}
type BlobExistsResult struct {
	DockerContentDigest string
	ContentLength       string
	Exists              bool
}

func (oper *Operator) BlobExists(ctx context.Context, params *BlobExistsParams) (*BlobExistsResult, int, error) {
	var err error
	res := &BlobExistsResult{}
	oper.logg.Debugf("Call BlobExists")
	if params.Digest == "" {
		err = fmt.Errorf("Empty reference")
		return res, http.StatusBadRequest, err
	}
	if params.Name == "" {
		err = fmt.Errorf("Empty name")
		return res, http.StatusBadRequest, err
	}
	exists, blobDescr, err := oper.mdb.GetBlobByDigest(ctx, params.Digest)
	if err != nil {
		return res, http.StatusInternalServerError, err
	}
	if !exists {
		return res, http.StatusNotFound, err
	}
	res.ContentLength = strconv.FormatInt(blobDescr.Size, 10)
	res.DockerContentDigest = params.Digest
	res.Exists = exists

	return res, http.StatusOK, err
}

// https://github.com/opencontainers/distribution-spec/blob/v1.1.1/spec.md
//
// PostUpload
//
// POST then PUT
//
// To push a blob monolithically by using a POST request followed by a PUT request, there are two steps:
//
// - Obtain a session id (upload URL)
// - Upload the blob to said URL
//
// A chunked blob upload is accomplished in three phases:
//
// - Obtain a session ID (upload URL) (POST)
// - Upload the chunks (PATCH)
// Close the session (PUT)

type PostUploadParams struct {
	Name   string
	Digest string
	Mount  string
	From   string
}
type PostUploadResult struct {
	DockerUploadUUID string
	Location         string
	ContentLength    string
}

func (oper *Operator) PostUpload(ctx context.Context, params *PostUploadParams) (*PostUploadResult, int, error) {
	var err error
	res := &PostUploadResult{}
	oper.logg.Debugf("PostUpload")

	if params.Digest == "" {
		uuid := auxuuid.NewUUID()
		location := fmt.Sprintf("/v2/%s/blobs/uploads/%s", params.Name, uuid)
		res.DockerUploadUUID = uuid
		res.Location = location
		res.ContentLength = strconv.FormatInt(0, 10)
		return res, http.StatusAccepted, err
	} else {
		err = fmt.Errorf("PostUpload: Not empty digest header")
		return res, http.StatusInternalServerError, err
	}
	return res, http.StatusOK, err
}

type PatchUploadParams struct {
	ContentType   string
	ContentLength string
	ContentRange  string
	Name          string
	Reference     string
	Reader        io.Reader
}
type PatchUploadResult struct {
	Location string
	Range    string
}

// The response for each successful chunk upload MUST be 202 Accepted, and MUST have the following headers:
//
//   Location: <location>
//   Range: 0-<end-of-range>

func (oper *Operator) PatchUpload(ctx context.Context, params *PatchUploadParams) (*PatchUploadResult, int, error) {
	var err error
	res := &PatchUploadResult{}
	oper.logg.Debugf("Call PatchUpload")

	if params.Reference == "" {
		err = fmt.Errorf("Empty reference")
		return res, http.StatusBadRequest, err
	}
	if params.Name == "" {
		err = fmt.Errorf("Empty name")
		return res, http.StatusBadRequest, err
	}

	exists, uploadSize, err := oper.store.UploadExists(params.Name, params.Reference)
	if err != nil {
		return res, http.StatusInternalServerError, err
	}
	if exists {
		res.Location = fmt.Sprintf("/v2/%s/uploads/%s", params.Name, params.Reference)
		res.Range = fmt.Sprintf("0-%d", uploadSize-1)
		return res, http.StatusNoContent, err
	}

	if params.ContentType != "application/octet-stream" {
		err = fmt.Errorf("Wrong Conten-Type header: %s", params.ContentType)
		return res, http.StatusBadRequest, err
	}
	var contentLength int64

	// Unfortunately, podman & github.com/containers/image don't set Content-length header for docker transport
	if params.ContentLength != "" {
		contentLength, err = strconv.ParseInt(params.ContentLength, 10, 64)
		if err != nil {
			err = fmt.Errorf("Wrong Content-length header")
			return res, http.StatusBadRequest, err
		}
	}

	recsize, _, err := oper.store.WriteUpload(params.Reference, params.Reader)
	if err != nil {
		return res, http.StatusInternalServerError, err
	}
	if contentLength != 0 && recsize != contentLength {
		oper.store.RemoveUpload(params.Reference)
		err = fmt.Errorf("Mismatch upload recorded size and content length")
		return res, http.StatusInternalServerError, err
	}
	res.Location = fmt.Sprintf("/v2/%s/uploads/%s", params.Name, params.Reference)
	res.Range = fmt.Sprintf("0-%d", recsize-1)
	return res, http.StatusAccepted, err
}

type PutUploadParams struct {
	ContentType   string
	ContentLength string
	ContentRange  string
	Name          string
	Reference     string
	Digest        string
	Reader        io.Reader
}
type PutUploadResult struct {
	Location string
}

func (oper *Operator) PutUpload(ctx context.Context, params *PutUploadParams) (*PutUploadResult, int, error) {
	var err error
	res := &PutUploadResult{}
	oper.logg.Debugf("Call PutUpload")

	if params.Reference == "" {
		err = fmt.Errorf("Empty reference")
		return res, http.StatusBadRequest, err
	}
	if params.Name == "" {
		err = fmt.Errorf("Empty name")
		return res, http.StatusBadRequest, err
	}
	if params.Digest == "" {
		err = fmt.Errorf("Empty digest")
		return res, http.StatusBadRequest, err
	}
	if params.ContentType != "application/octet-stream" {
		err = fmt.Errorf("Wrong conten type: %s", params.ContentType)
		return res, http.StatusBadRequest, err
	}

	var contentLength int64
	if params.ContentLength != "" {
		contentLength, err = strconv.ParseInt(params.ContentLength, 10, 64)
		if err != nil {
			err = fmt.Errorf("Cannot convert Content-Length=%s to integer: %v", params.ContentLength, err)
			return res, http.StatusBadRequest, err
		}

	}
	if contentLength != 0 {
		// TODO
		err = fmt.Errorf("Unexpected Content-Length header: %s", params.ContentLength)
		return res, http.StatusInternalServerError, err
	}

	err = oper.store.LinkUpload(params.Reference, params.Digest)
	if err != nil {
		err = fmt.Errorf("Failed to link upload %s, err: %v", params.Reference, err)
		return res, http.StatusInternalServerError, err
	}

	res.Location = fmt.Sprintf("/v2/%s/blobs/%s", params.Name, params.Digest)
	return res, http.StatusCreated, err
}