working commit

2026-02-05 14:37:54 +02:00
parent 2dfb4a88b8
commit e81037d75f
10 changed files with 408 additions and 119 deletions
@@ -24,6 +24,7 @@ func (oper *Operator) BlobExists(ctx context.Context, params *BlobExistsParams)
 	var err error
 	res := &BlobExistsResult{}
 	oper.logg.Debugf("Call BlobExists")
+
 	if params.Digest == "" {
 		err = fmt.Errorf("Empty reference")
 		return res, http.StatusBadRequest, err
@@ -224,3 +225,90 @@ func (oper *Operator) PutUpload(ctx context.Context, params *PutUploadParams) (*
 	res.Location = fmt.Sprintf("/v2/%s/blobs/%s", params.Name, params.Digest)
 	return res, http.StatusCreated, err
 }
+
+type GetBlobParams struct {
+	Name   string
+	Digest string
+}
+type GetBlobResult struct {
+	ContentLength       string
+	ContentType         string
+	DockerContentDigest string
+	ReadCloser          io.ReadCloser
+}
+
+func (oper *Operator) GetBlob(ctx context.Context, params *GetBlobParams) (*GetBlobResult, int, error) {
+	var err error
+	res := &GetBlobResult{}
+	oper.logg.Debugf("Calling GetBlob %s:%s", params.Name, params.Digest)
+
+	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
+	}
+
+	blobExists, blobSize, err := oper.store.BlobExists(params.Digest)
+	if err != nil {
+		return res, http.StatusInternalServerError, err
+	}
+	if !blobExists {
+		oper.logg.Debugf("Blob %s:%s not exists", params.Name, params.Digest)
+		return res, http.StatusNotFound, err
+	}
+
+	_, readCloser, err := oper.store.BlobReader(params.Digest)
+	if err != nil {
+		return res, http.StatusInternalServerError, err
+	}
+
+	res.ContentLength = strconv.FormatInt(blobSize, 10)
+	res.DockerContentDigest = params.Digest
+	res.ReadCloser = readCloser
+	return res, http.StatusOK, err
+}
+
+type DeleteBlobParams struct {
+	Name   string
+	Digest string
+}
+type DeleteBlobResult struct{}
+
+func (oper *Operator) DeleteBlob(ctx context.Context, params *DeleteBlobParams) (*DeleteBlobResult, int, error) {
+	var err error
+	res := &DeleteBlobResult{}
+	oper.logg.Debugf("DeleteBlob")
+
+	if params.Digest == "" {
+		err = fmt.Errorf("Empty digest")
+		return res, http.StatusBadRequest, err
+	}
+	if params.Name == "" {
+		err = fmt.Errorf("Empty name")
+		return res, http.StatusBadRequest, err
+	}
+	// Check namespace record
+	exists, _, err := oper.mdb.GetBlobByNameDigest(ctx, params.Name, params.Digest)
+	if err != nil {
+		return res, http.StatusInternalServerError, err
+	}
+	if !exists {
+		return res, http.StatusNotFound, err
+	}
+	err = oper.mdb.DeleteBlobByNameDigest(ctx, params.Name, params.Digest)
+	if err != nil {
+		return res, http.StatusInternalServerError, err
+	}
+	// Removing blob file if usage == 0
+	blobUsage, err := oper.mdb.GetBlobUsage(ctx, params.Digest)
+	if err != nil {
+		return res, http.StatusInternalServerError, err
+	}
+	if blobUsage == 0 {
+		oper.store.DeleteBlob(params.Digest)
+	}
+	return res, http.StatusOK, err
+}
@@ -90,8 +90,7 @@ type PutManifestResult struct {
 	Location string
 }

-// TODO: control size 413 Payload Too Large
-
+// TODO: lock for the name-reference or simular?
 func (oper *Operator) PutManifest(ctx context.Context, params *PutManifestParams) (*PutManifestResult, int, error) {
 	var err error
 	res := &PutManifestResult{}
@@ -128,6 +127,7 @@ func (oper *Operator) PutManifest(ctx context.Context, params *PutManifestParams
 	if err != nil {
 		return res, http.StatusInternalServerError, err
 	}
+
 	incomingManifestBytes := buffer.Bytes()
 	if int64(len(incomingManifestBytes)) != contentLength {
 		err = fmt.Errorf("Mismatch Content-Length and received manifest size: %d vs %d",
@@ -136,7 +136,12 @@ func (oper *Operator) PutManifest(ctx context.Context, params *PutManifestParams
 		return res, code, err
 	}

-	oper.logg.Debugf("Manifest data: [%s]", string(incomingManifestBytes))
+	if len(incomingManifestBytes) > (4 * 1024 * 1024) {
+		err = fmt.Errorf("Payload more 4M: %d bytes", len(incomingManifestBytes))
+		code := http.StatusRequestEntityTooLarge
+		return res, code, err
+	}
+	//oper.logg.Debugf("Manifest data: [%s]", string(incomingManifestBytes))

 	incomingManifest, err := auxoci.ParseOCIManifest(incomingManifestBytes)
 	if err != nil {
@@ -147,100 +152,76 @@ func (oper *Operator) PutManifest(ctx context.Context, params *PutManifestParams
 		incomingManifest.MediaType = params.ContentType
 	}

-	manifestExists, _, err := oper.mdb.GetManifestByReference(ctx, params.Name, params.Reference)
+	manifestExists, existengManifestDescr, err := oper.mdb.GetManifestByReference(ctx, params.Name, params.Reference)
 	if err != nil {
 		return res, http.StatusInternalServerError, err
 	}
-	if !manifestExists {
-		name := params.Name
-		reference := params.Reference
-		manifestDescr, layerDescrs, err := descrsFromManifest(name, reference, incomingManifest, incomingManifestBytes)
-		// Check layers
-		var blobError error
-		for _, layer := range layerDescrs {
-			layerExists, _, err := oper.store.BlobFileExists(layer.Digest)
-			if err != nil {
-				return res, http.StatusInternalServerError, err
-			}
-			if !layerExists {
-				err := fmt.Errorf("Layer %s not found", layer.Digest)
-				blobError = errors.Join(blobError, err)
-			}
-		}
-		if blobError != nil {
-			return res, http.StatusInternalServerError, blobError
-		}
-		// Store manifest and layesrs data
-		err = oper.mdb.InsertManifestWithLayers(ctx, &manifestDescr, layerDescrs)
+
+	name := params.Name
+	reference := params.Reference
+
+	incomingManifestDescr, incomingLayerDescrs, err := descrsFromManifest(name, reference, incomingManifest, incomingManifestBytes)
+	// Always check layer files for availability
+	var blobError error
+	for _, layer := range incomingLayerDescrs {
+		layerExists, _, err := oper.store.BlobExists(layer.Digest)
 		if err != nil {
 			return res, http.StatusInternalServerError, err
 		}
+		if !layerExists {
+			err := fmt.Errorf("Layer %s not found.", layer.Digest)
+			blobError = errors.Join(blobError, err)
+		}
 	}
+	if blobError != nil {
+		return res, http.StatusInternalServerError, blobError
+	}
+	if !manifestExists {
+		// Store manifest and layesrs data
+		err = oper.mdb.InsertManifestWithLayers(ctx, &incomingManifestDescr, incomingLayerDescrs)
+		if err != nil {
+			return res, http.StatusInternalServerError, err
+		}
+	} else {
+		/* TODO: only update descr
+		   if bytes.Equal(existingManifestBytes, incomingManifestBytes) {
+		      return res, http.StatusCreated, err
+		   }
+		*/

-	/*
-	   exists, existingManifestDescr, err := lg.mdb.GetManifestByReference(params.Name, params.Reference)
-	   if err != nil {
-	           return res, http.StatusInternalServerError, err
-	   }
-
-	   if exists {
-	           existingManifestBytes := []byte(existingManifestDescr.Payload)
-	           // Exist if incoming and existing manyfest is equal
-	           if bytes.Equal(existingManifestBytes, incomingManifestBytes) {
-	                   return res, http.StatusCreated, err
-	           }
-	           name := params.Name
-	           reference := params.Reference
-	           manifestDescr, newBlobDescrs, delBlobDescrs, err := blobsDiff(name, reference, existingManifestBytes, incomingManifestBytes)
-	           if err != nil {
-	                   return res, http.StatusInternalServerError, err
-	           }
-	           err = lg.maindb.UpdateManifest(ctx, &manifestDescr, newBlobDescrs, delBlobDescrs)
-	           if err != nil {
-	                   return res, http.StatusInternalServerError, err
-	           }
-	           // Clean blobs
-	           for _, blob := range delBlobDescrs {
-	                   exists, _, err = lg.st.BlobFileExists(blob.Digest)
-	                   if err != nil {
-	                           return res, http.StatusInternalServerError, err
-	                   }
-	                   blobUsage, err := lg.maindb.GetBlobUsage(blob.Digest)
-	                   if err != nil {
-	                           return res, http.StatusInternalServerError, err
-	                   }
-	                   if exists && blobUsage == 0 {
-	                           lg.log.Debugf("Delete file %s:%s blob %s", params.Name, params.Reference, blob.Digest)
-	                           err = lg.st.DeleteBlobFile(blob.Digest)
-	                           if err != nil {
-	                                   return res, http.StatusInternalServerError, err
-	                           }
-	                   }
-	           }
-	   } else {
-	           name := params.Name
-	           reference := params.Reference
-	           manifestDescr, configDescr, layerDescrs, err := descrsFromManifestBytes(name, reference, incomingManifestBytes)
-	           // Check layer blobs
-	           var blobError error
-	           for _, layer := range layerDescrs {
-	                   exists, _, err = lg.st.BlobFileExists(layer.Digest)
-	                   if !exists {
-	                           err := fmt.Errorf("Blob %s not exists", layer.Digest)
-	                           blobError = errors.Join(blobError, err)
-	                   }
-	           }
-	           if blobError != nil {
-	                   return res, http.StatusInternalServerError, blobError
-	           }
-	           // Store manifest and blobs data
-	           err = lg.maindb.InsertManifest(ctx, &manifestDescr, &configDescr, layerDescrs)
-	           if err != nil {
-	                   return res, http.StatusInternalServerError, err
-	           }
-	   }
-
-	*/
+		existingManifestBytes := []byte(existengManifestDescr.Payload)
+		existingManifest, err := auxoci.ParseOCIManifest(existingManifestBytes)
+		if err != nil {
+			return res, http.StatusInternalServerError, err
+		}
+		addedBlobDescrs, uselessBlobDescrs, err := layersDiff(name, reference,
+			existingManifest, incomingManifest, incomingManifestBytes)
+		if err != nil {
+			return res, http.StatusInternalServerError, err
+		}
+		// Starting manifest and blobs transaction
+		err = oper.mdb.UpdateManifestWithBlobs(ctx, &incomingManifestDescr, addedBlobDescrs, uselessBlobDescrs)
+		if err != nil {
+			return res, http.StatusInternalServerError, err
+		}
+		for _, blob := range uselessBlobDescrs {
+			exists, _, err := oper.store.BlobExists(blob.Digest)
+			if err != nil {
+				return res, http.StatusInternalServerError, err
+			}
+			blobUsage, err := oper.mdb.GetBlobUsage(ctx, blob.Digest)
+			if err != nil {
+				return res, http.StatusInternalServerError, err
+			}
+			if exists && blobUsage == 0 {
+				oper.logg.Debugf("Delete file %s:%s blob %s", name, reference, blob.Digest)
+				err = oper.store.DeleteBlob(blob.Digest)
+				if err != nil {
+					return res, http.StatusInternalServerError, err
+				}
+			}
+		}
+	}

 	res.Location = fmt.Sprintf(`/v2/%s/manifests/%s`, params.Name, params.Reference)
 	return res, http.StatusCreated, err
@@ -63,3 +63,68 @@ func descrsFromManifest(name, reference string, manifest *ocispec.Manifest, rawM
 	}
 	return manifestDescr, blobDescrs, err
 }
+
+func layersDiff(name, reference string, existingManifest, incomingManifest *ocispec.Manifest, rawManifest []byte) ([]descr.Blob, []descr.Blob, error) {
+	var err error
+	newBlobDescrs := make([]descr.Blob, 0)
+	delBlobDescrs := make([]descr.Blob, 0)
+
+	// Calculating old layers
+	delLayers := make([]ocispec.Descriptor, 0)
+	for _, oldLayer := range existingManifest.Layers {
+		uniq := true
+		for _, newLayer := range incomingManifest.Layers {
+			if oldLayer.Digest == newLayer.Digest {
+				uniq = false
+			}
+		}
+		if uniq {
+			delLayers = append(delLayers, oldLayer)
+		}
+	}
+	// Calculating new layers
+	newLayers := make([]ocispec.Descriptor, 0)
+	for _, newLayer := range incomingManifest.Layers {
+		uniq := true
+		for _, oldLayer := range existingManifest.Layers {
+			if oldLayer.Digest == newLayer.Digest {
+				uniq = false
+			}
+		}
+		if uniq {
+			newLayers = append(newLayers, newLayer)
+		}
+	}
+	if incomingManifest.Config.Digest != existingManifest.Config.Digest {
+		delLayers = append(delLayers, existingManifest.Config)
+		newLayers = append(newLayers, incomingManifest.Config)
+	}
+	// Converting to new blob
+	timestamp := auxtool.TimeNow()
+	for _, layer := range newLayers {
+		blobDescr := descr.Blob{
+			ID:        auxuuid.NewUUID(),
+			Name:      name,
+			Reference: reference,
+			MediaType: layer.MediaType,
+			Digest:    string(layer.Digest),
+			Size:      layer.Size,
+			CreatedAt: timestamp,
+			UpdatedAt: timestamp,
+		}
+		newBlobDescrs = append(newBlobDescrs, blobDescr)
+	}
+	// Converting to old blobs
+	for _, layer := range delLayers {
+		blobDescr := descr.Blob{
+			ID:        auxuuid.NewUUID(),
+			Name:      name,
+			Reference: reference,
+			MediaType: layer.MediaType,
+			Digest:    string(layer.Digest),
+			Size:      layer.Size,
+		}
+		delBlobDescrs = append(delBlobDescrs, blobDescr)
+	}
+	return newBlobDescrs, delBlobDescrs, err
+}