Method putCommit

private/bufpkg/bufmodule/bufmodulestore/commit_store.go:231–288

(
	ctx context.Context,
	commit bufmodule.Commit,
)

}

func (p *commitStore) putCommit(
	ctx context.Context,
	commit bufmodule.Commit,
) (retErr error) {
	createTime, err := commit.CreateTime()
	if err != nil {
		return err
	}
	moduleKey := commit.ModuleKey()
	digest, err := moduleKey.Digest()
	if err != nil {
		return err
	}
	commitKey, err := bufmodule.ModuleKeyToCommitKey(moduleKey)
	if err != nil {
		return err
	}
	bucket := p.getReadWriteBucketForDir(ctx, commitKey)
	path := getCommitStoreFilePath(commitKey)
	registryLockPath := getCommitStoreLockPath(commitKey)
	// Check if the commit already exists under a shared lock before acquiring
	// an exclusive lock.
	exists, err := p.commitExistsUnderRLock(ctx, bucket, path, registryLockPath)
	if err != nil {
		return err
	}
	if exists {
		return nil
	}
	unlocker, err := p.locker.Lock(ctx, registryLockPath)
	if err != nil {
		return err
	}
	defer func() {
		retErr = errors.Join(retErr, unlocker.Unlock())
	}()
	// Re-check after acquiring the exclusive lock, as another process may have
	// written the commit between releasing the shared lock and acquiring the
	// exclusive lock.
	if _, err := bucket.Stat(ctx, path); err == nil {
		return nil
	}
	externalCommit := externalCommit{
		Version:    externalCommitVersion,
		Owner:      moduleKey.FullName().Owner(),
		Module:     moduleKey.FullName().Name(),
		CreateTime: createTime,
		Digest:     digest.String(),
	}
	if !externalCommit.isValid() {
		return syserror.Newf("external commit is invalid: %+v", externalCommit)
	}
	data, err := json.Marshal(externalCommit)
	if err != nil {
		return err
	}
	return storage.PutPath(ctx, bucket, path, data, storage.PutWithAtomic())
}