transfer

type Config ¶

type Config struct {
	Concurrency  int
	OnExists     string // skip | overwrite | fail
	Dedup        DedupConfig
	Mode         string // copy | move
	PathTemplate string

	// RetryBufferMaxMemoryBytes controls how large an object we buffer in memory to
	// make the PUT request body seekable for SDK retries.
	// Larger objects are spooled to a temp file.
	RetryBufferMaxMemoryBytes int64

	Sharding ShardingConfig
}

func DefaultConfig() Config

type CopyGate ¶

type CopyGate interface {
	// Do runs fn under the gate for the named stage. Implementations must call
	// fn exactly once on the success path and propagate its error.
	Do(ctx context.Context, stage string, fn func(context.Context) error) error
}

CopyGate wraps sequential copy phases so callers can acquire and release concurrency permits per phase. A nil gate runs each phase directly (callers that hold an outer token, or ungated library use).

Library-first (ADR-0006): both the pkg/reflow engine and the CLI pool pass the same gate type so stage boundaries stay identical.

type CopyReceipt ¶

type CopyReceipt struct {
	UploadResult
	SourceLastModified time.Time
}

CopyReceipt describes an acknowledged streamed write, not independent destination read-back verification. Unknown provider handles remain empty.

func CopyObjectWithReceipt(ctx context.Context, src, dst provider.Provider, srcKey, dstKey string, expectedSize int64, opts CopyReceiptOptions) (CopyReceipt, error)

type CopyReceiptOptions ¶

type CopyReceiptOptions struct {
	Upload   UploadOptions
	Revision *provider.SourceRevision
	Gate     CopyGate
}

CopyReceiptOptions preserves revision admission, write preconditions and phase budgets while requesting the write's payload receipt.

type DedupConfig ¶

type DedupConfig struct {
	Enabled  bool
	Strategy string // etag | key | none
}

type PathTemplate ¶

type PathTemplate struct {
	// contains filtered or unexported fields
}

PathTemplate is a minimal key mapping template.

Supported placeholders: - `{filename}`: final path segment - `{dir[n]}`: nth directory component (0-based) - `{key}`: full source key

This intentionally stays simple for v0.1.x.

func CompilePathTemplate(template string) (*PathTemplate, error)

func (t *PathTemplate) Apply(sourceKey string) (string, error)

type ReflowCapture ¶

type ReflowCapture struct {
	// contains filtered or unexported fields
}

ReflowCapture applies a rewrite-from template to a source key and returns the captured variables without rendering a destination template.

func CompileReflowCapture(fromTemplate string) (*ReflowCapture, error)

func (r *ReflowCapture) Apply(sourceKey string) (map[string]string, error)

func (r *ReflowCapture) CaptureNames() []string

type ReflowRewrite ¶

type ReflowRewrite struct {
	// contains filtered or unexported fields
}

ReflowRewrite maps a source key to a destination relative key.

The rewrite is a simple segment matcher/renderer: - Templates are split on '/'. - In the from template, literal segments must match exactly. - Placeholders in the from template capture one segment or one segment substring: {var}, prefix-{var}-suffix - The special placeholder {_} captures and ignores a segment. - In the to template, {var} renders the captured value, optionally with a literal prefix/suffix in the same segment.

Each segment may contain at most one placeholder.

func CompileReflowRewrite(fromTemplate, toTemplate string) (*ReflowRewrite, error)

func (r *ReflowRewrite) Apply(sourceKey string) (destRelKey string, vars map[string]string, err error)

func (r *ReflowRewrite) ApplyWithVars(sourceKey string, extraVars map[string]string) (destRelKey string, vars map[string]string, err error)

type ShardingConfig ¶

type ShardingConfig struct {
	Enabled         bool
	Depth           int
	MaxShards       int
	ListConcurrency int
	Delimiter       string
}

type SizeMismatchError ¶

type SizeMismatchError struct {
	Key      string
	Expected int64
	Got      int64
}

SizeMismatchError indicates the object size changed between enumeration (list/index) and content retrieval.

This is best-effort validation (validate=size) intended to fail early before deeper pipeline work (buffering/spooling/retries).

It does not eliminate TOCTOU races.

func (e *SizeMismatchError) Error() string

type Summary ¶

type Summary struct {
	ObjectsListed      int64
	ObjectsMatched     int64
	ObjectsTransferred int64
	BytesTransferred   int64
	Errors             int64
	Duration           time.Duration
}

type Transfer ¶

type Transfer struct {
	// contains filtered or unexported fields
}

func New(src provider.Provider, dst provider.Provider, matcher *match.Matcher, writer output.Writer, jobID string, cfg Config) *Transfer

func (t *Transfer) Run(ctx context.Context) (*Summary, error)

type UploadOptions ¶

type UploadOptions struct {
	PartSizeBytes         int64
	MultipartThreshold    int64
	MultipartThresholdSet bool
	RetryBufferBytes      int64
	TempDir               string
	Precondition          provider.PutPrecondition
	PutOptions            provider.PutOptions
	Progress              func(context.Context, UploadProgress) error
}

type UploadProgress ¶

type UploadProgress struct {
	Key        string
	UploadID   string
	PartNumber int32
	PartBytes  int64
	Bytes      int64
	Status     string
}

type UploadResult ¶

type UploadResult struct {
	Bytes   int64
	SHA256  string
	ETag    string
	Version string
	Mode    string
}

func UploadFile(ctx context.Context, putter provider.ObjectPutter, key string, path string, opts UploadOptions) (UploadResult, error)

func UploadReader(ctx context.Context, putter provider.ObjectPutter, key string, r io.Reader, opts UploadOptions) (UploadResult, error)

func UploadReaderWithSize(ctx context.Context, putter provider.ObjectPutter, key string, r io.Reader, size int64, opts UploadOptions) (UploadResult, error)

type UploadSession ¶

type UploadSession struct {
	// contains filtered or unexported fields
}

func NewUploadSession(ctx context.Context, putter provider.ObjectPutter, key string, opts UploadOptions) (*UploadSession, error)

func (s *UploadSession) Abort(ctx context.Context) error

func (s *UploadSession) Close(ctx context.Context) (UploadResult, error)

func (s *UploadSession) Write(p []byte) (int, error)