Method Commit

core/metadata/content.go:582–641

(ctx context.Context, size int64, expected digest.Digest, opts ...content.Opt)

}

func (nw *namespacedWriter) Commit(ctx context.Context, size int64, expected digest.Digest, opts ...content.Opt) error {
	ctx = namespaces.WithNamespace(ctx, nw.namespace)

	nw.l.RLock()
	defer nw.l.RUnlock()

	var innerErr error
	var actualDgst digest.Digest
	var actualSize int64

	// We pre-sync the in-flight writes to the disk. This avoids the
	// subsequent fp.Sync() call[1]	from taking too long (10s+) while
	// holding the metadata database lock as in the following `update`
	// transaction.
	//
	// REF:
	// [1]: https://github.com/containerd/containerd/blob/c4c3c6ea568ce0cfbcf754863abadeea37d77c8f/plugins/content/local/writer.go#L95
	if err := nw.Sync(); err != nil {
		nw.Close()
		return fmt.Errorf("failed to perform sync: %w", err)
	}

	if err := update(ctx, nw.db, func(tx *bolt.Tx) error {
		dgst, size, err := nw.commit(ctx, tx, size, expected, opts...)
		if err != nil {
			if !errdefs.IsAlreadyExists(err) {
				return err
			}
			innerErr = err
		}
		actualDgst = dgst
		actualSize = size
		bkt := getIngestsBucket(tx, nw.namespace)
		if bkt != nil {
			if err := bkt.DeleteBucket([]byte(nw.ref)); err != nil && err != errbolt.ErrBucketNotFound {
				return err
			}
		}
		if err := removeIngestLease(ctx, tx, nw.ref); err != nil {
			return err
		}
		return addContentLease(ctx, tx, dgst)
	}); err != nil {
		return err
	}
	if innerErr != nil {
		return innerErr
	}

	if publisher := nw.db.Publisher(ctx); publisher != nil {
		if err := publisher.Publish(ctx, "/content/create", &eventstypes.ContentCreate{
			Digest: actualDgst.String(),
			Size:   actualSize,
		}); err != nil {
			return err
		}
	}