package v071 import ( "bytes" "context" "errors" "io" "strings" ) type ObjectStore interface { Put(ctx context.Context, provider, path string, reader io.Reader, size int64) error Stat(ctx context.Context, provider, path string) (size int64, sha256 string, err error) Copy(ctx context.Context, provider, sourcePath, targetPath string) error } type TargetObjectConfig struct { StorageBackendID string Provider string } type StagedObject struct { Handle string StagingPath string FinalPath string Size int64 SHA256 string } type ObjectStage struct { ReleaseRevision string Provider string Objects []StagedObject } type ObjectImporter struct { store ObjectStore config TargetObjectConfig } func NewObjectImporter(store ObjectStore, config TargetObjectConfig) (*ObjectImporter, error) { config.StorageBackendID = strings.TrimSpace(config.StorageBackendID) config.Provider = strings.TrimSpace(config.Provider) if store == nil || !validSearchIdentifier(config.StorageBackendID) || !validObjectProvider(config.Provider) { return nil, errors.New("invalid target object importer configuration") } return &ObjectImporter{store: store, config: config}, nil } func (importer *ObjectImporter) Stage(ctx context.Context, releaseRevision string, snapshot ObjectSnapshot) (ObjectStage, error) { if !validSearchIdentifier(releaseRevision) || !validLowerSHA256(snapshot.SHA256) || snapshot.SHA256 != objectSnapshotDigest(snapshot.Objects) { return ObjectStage{}, errors.New("invalid object import snapshot") } var total int64 stage := ObjectStage{ReleaseRevision: releaseRevision, Provider: importer.config.Provider, Objects: make([]StagedObject, 0, len(snapshot.Objects))} for _, object := range snapshot.Objects { if !validSearchIdentifier(object.ResourceID) || len(object.Handle) != 22 || object.Size != int64(len(object.Data)) || object.SHA256 != shaBytes(object.Data) || !validObjectKey(object.PhysicalPath) { return ObjectStage{}, errors.New("invalid object import entry") } providerPath, ok := providerPathFromLocator(object.PhysicalPath) if !ok { return ObjectStage{}, errors.New("invalid object import locator") } total += object.Size stagingPath := ".governance-release-stage/" + releaseRevision + "/" + providerPath if !validObjectLocator(stagingPath) { return ObjectStage{}, errors.New("invalid object staging locator") } if err := importer.store.Put(ctx, importer.config.Provider, stagingPath, bytes.NewReader(object.Data), object.Size); err != nil { return ObjectStage{}, errors.New("write staged release object") } size, digest, err := importer.store.Stat(ctx, importer.config.Provider, stagingPath) if err != nil || size != object.Size || digest != object.SHA256 { return ObjectStage{}, errors.New("verify staged release object") } stage.Objects = append(stage.Objects, StagedObject{Handle: object.Handle, StagingPath: stagingPath, FinalPath: providerPath, Size: object.Size, SHA256: object.SHA256}) } if total != snapshot.TotalBytes { return ObjectStage{}, errors.New("object import total mismatch") } return stage, nil } func (importer *ObjectImporter) Promote(ctx context.Context, stage ObjectStage) error { if stage.Provider != importer.config.Provider || !validSearchIdentifier(stage.ReleaseRevision) { return errors.New("invalid object promotion stage") } for _, object := range stage.Objects { if !validObjectLocator(object.StagingPath) || !validObjectLocator(object.FinalPath) || !validLowerSHA256(object.SHA256) || object.Size < 0 { return errors.New("invalid object promotion entry") } if err := importer.store.Copy(ctx, importer.config.Provider, object.StagingPath, object.FinalPath); err != nil { return errors.New("promote release object") } size, digest, err := importer.store.Stat(ctx, importer.config.Provider, object.FinalPath) if err != nil || size != object.Size || digest != object.SHA256 { return errors.New("verify promoted release object") } } return nil } func providerPathFromLocator(locator string) (string, bool) { rest := locator if strings.HasPrefix(locator, "storage://") { rest = strings.TrimPrefix(locator, "storage://") parts := strings.SplitN(rest, "/", 2) if len(parts) != 2 || !validSearchIdentifier(parts[0]) || !validObjectLocator(parts[1]) { return "", false } rest = parts[1] } else if !validObjectLocator(locator) { return "", false } // WeKnora nests the provider locator inside the storage locator: // "storage:///oss:///". S3 keys address the // bucket configured for the store, so strip the inner scheme and bucket. if separator := strings.Index(rest, "://"); separator >= 0 { if !validSearchIdentifier(rest[:separator]) { return "", false } schemeless := rest[separator+3:] boundary := strings.Index(schemeless, "/") if boundary < 0 || boundary == len(schemeless)-1 { return "", false } rest = schemeless[boundary+1:] } return rest, validObjectLocator(rest) }