origin_serve

type AuthError struct {
	Code    int
	Message string
	Path    string
	User    string
	Issuer  string
	// contains filtered or unexported fields
}

type BackendETager interface {
	ETag(ctx context.Context) (string, error)
}

type BackendMode int

type BatchedStmt struct {
	SQL  string
	Args []any
}

type BatcherHooks struct {
	// IncFlush is called once per successful or failed COMMIT. The
	// `size` is the number of ops in the batch.
	IncFlush func(size int)
	// IncError is called once per failed COMMIT. (Each failed op
	// also reports its own error via its `done` channel.)
	IncError func()
	// ObserveBatchAge records how long the oldest op waited from
	// enqueue to flush.
	ObserveBatchAge func(d time.Duration)
	// ObserveEnqueueWait is called only when an Enqueue had to
	// block on the channel send (i.e., the in-memory buffer was
	// full). The `durability` label is "durable" or "best_effort".
	// A non-zero count here means callers are paying real
	// back-pressure latency; operators should bump
	// Origin.Metadata.BatchBufferSize.
	ObserveEnqueueWait func(durability string, d time.Duration)
}

type BlobBackendOptions struct {
	// Generic gocloud.dev/blob URL — takes precedence over the S3-specific fields.
	BlobURL string

	// S3-specific fields (used only when BlobURL is empty).
	ServiceURL string // e.g. "https://s3.us-east-1.amazonaws.com"
	Region     string
	Bucket     string
	AccessKey  string
	SecretKey  string
	URLStyle   string // "path" or "virtual" (default: "path")

	// Common fields.
	StoragePrefix string // optional key prefix within the bucket/container
}

type BlobFileSysInfo struct {
	ETag string
}

type ChecksumType string

type Checksummer interface {
	GetChecksum(root *os.Root, filename string, checksumType ChecksumType) (string, error)
}

type ConditionalWriteFs interface {
	OpenFileConditional(name string, flag int, perm os.FileMode, size int64,
		requireAbsent bool, requireETag string) (afero.File, error)
}

type CustomFields map[string]any

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

type EtagSource string

type GlobusBackendActivator interface {
	// Activate marks the collection as activated with the given tokens and OAuth2 config.
	Activate(collectionToken, transferToken *oauth2.Token, httpsServer string, oauth2Cfg *oauth2.Config)
	// RefreshTokens refreshes both the collection and transfer tokens.
	RefreshTokens() error
	// IsActivated returns whether the Globus collection has been activated.
	IsActivated() bool
}

type GlobusBackendConfig struct {
	// CollectionID is the Globus collection UUID
	CollectionID string
	// HTTPSServer is the HTTPS URL for the collection (e.g. https://g-12345.data.globus.org)
	HTTPSServer string
	// StoragePrefix is the path prefix within the collection
	StoragePrefix string
	// OAuth2Config for refreshing tokens
	OAuth2Config *oauth2.Config
	// CollectionToken is the initial collection access token
	CollectionToken *oauth2.Token
	// TransferToken is the initial transfer access token
	TransferToken *oauth2.Token
}

type HTTPSBackendOptions struct {
	ServiceURL    string
	StoragePrefix string
	TokenMode     HTTPSTokenMode
	// For static tokens:
	StaticTokenFile string
	// For OAuth2 tokens:
	OAuth2Config *oauth2.Config
	OAuth2Token  *oauth2.Token // initial token (with refresh_token)
	// EnableAutoMkdir, when true, causes PUT operations to automatically
	// create missing parent directories via WebDAV MKCOL before retrying.
	EnableAutoMkdir bool
}

type HTTPSFileSysInfo struct {
	ETag string
}

type HTTPSTokenMode int

type Mapfile struct {
	Rules []MapfileRule `json:"-"`
	// contains filtered or unexported fields
}

type MapfileRule struct {
	Sub      *string `json:"sub"`
	Username *string `json:"username"`
	Path     *string `json:"path"`
	Group    *string `json:"group"`
	Result   string  `json:"result"`
	Ignore   *bool   `json:"ignore"`
	Comment  *string `json:"comment"`
}

type MetadataPublishRow struct {
	ID                  int64     `gorm:"primaryKey;autoIncrement"`
	EventID             string    `gorm:"column:event_id;uniqueIndex;not null"`
	Namespace           string    `gorm:"column:namespace;not null;index"`
	ObjectPath          string    `gorm:"column:object_path;not null"`
	ObjectSize          int64     `gorm:"column:object_size;not null"`
	ETag                string    `gorm:"column:etag;not null"`
	ObjectCreated       time.Time `gorm:"column:object_created;not null"`
	CustomFields        string    `gorm:"column:custom_fields;not null;default:'{}'"`
	MetadataContentType string    `gorm:"column:metadata_content_type;not null;default:''"`
	MetadataBody        []byte    `gorm:"column:metadata_body;not null;default:''"`
	CreatedAt           time.Time `gorm:"column:created_at;not null;index"`
	NextAttemptAt       time.Time `gorm:"column:next_attempt_at;not null;index"`
	Attempts            int       `gorm:"column:attempts;not null;default:0"`
	LastError           string    `gorm:"column:last_error;not null;default:''"`

	// State is "pending" (the worker keeps retrying) or "rejected" (terminal:
	// the catalog answered 422 / permanently-bad, so the worker stops touching
	// it; the row lingers for status queries and admin/operator deletion).
	State string `gorm:"column:state;not null;default:'pending'"`

	// QueryToken / ManageToken are per-row random capability tokens embedded in
	// the status / manage URLs handed back to the uploading client in eventual
	// mode. Possession of the (unguessable) URL is the authority — no separate
	// bearer token is required. Empty for transactional-mode rows (which never
	// outlive the request).
	QueryToken  string `gorm:"column:query_token;not null;default:''"`
	ManageToken string `gorm:"column:manage_token;not null;default:''"`

	// EventType is the wire `type` (object.committed / object.updated /
	// object.deleted). Persisted so a retry rebuilds the event with its
	// original type, and so the worker knows to skip the "object still exists?"
	// check for deletes.
	EventType string `gorm:"column:event_type;not null;default:'object.committed'"`
}

type NotFoundError struct {
	ResourceType string
	ResourcePath string
}

type ObjectChecksumRow struct {
	ID            int64     `gorm:"primaryKey;autoIncrement"`
	ObjectID      int64     `gorm:"column:object_id;not null"`
	Algorithm     string    `gorm:"column:algorithm;not null"`
	Value         string    `gorm:"column:value;not null"`
	ComputedAt    time.Time `gorm:"column:computed_at;not null"`
	EtagAtCompute string    `gorm:"column:etag_at_compute;not null"`
}

type ObjectCommitEvent struct {
	// ID is a server-side UUIDv4. Stable across retries; used for
	// receiver-side dedup.
	ID string

	// Type is the event-type discriminator. Today: ObjectCommitEventType.
	Type string

	// Timestamp is when this event was first generated.
	Timestamp time.Time

	// Namespace is the federation prefix of the export this object
	// belongs to.
	Namespace string

	// Federation is the federation discovery URL the origin belongs to.
	// It makes the event self-describing: a receiver uses it to locate
	// the registry (federation discovery -> registry endpoint) and fetch
	// this namespace's registered public keys to verify the webhook JWT,
	// without needing to reach the origin directly. Stamped by the
	// publisher at send time.
	Federation string

	// ObjectPath is the federation-relative path of the object.
	ObjectPath string

	// ObjectSize is the size in bytes as reported by the storage
	// backend after commit.
	ObjectSize int64

	// ETag is the entity tag computed by the storage backend (eg the
	// WebDAV-generated ETag). The origin does not introduce its own
	// hashing scheme.
	ETag string

	// ObjectCreated is the storage-reported commit / mtime.
	ObjectCreated time.Time

	// CustomFields are uploader-supplied fields (parsed from the
	// X-Pelican-Object-Metadata header). Reserved keys are stripped
	// at parse time.
	CustomFields CustomFields

	// MetadataContentType + MetadataBody carry the opaque-blob
	// metadata supplied via the multipart/form-data upload path
	// (see metadata_multipart.go). Empty content type AND empty body
	// means "no blob, post plain JSON outbound." A non-empty body
	// switches the outbound webhook to multipart/related so the
	// receiver gets the bytes byte-for-byte. They are independent
	// of CustomFields: an upload may carry both.
	MetadataContentType string
	MetadataBody        []byte
}

type ObjectMetadataEvent string

type ObjectMetadataEventInput struct {
	Namespace    string
	ObjectPath   string // federation-rooted, eg "/exp/data/run99.dat"
	Size         int64
	ETag         string
	EtagSource   EtagSource
	BackendMtime time.Time
	Actor        string         // token sub at request time; "" if unknown
	Extra        map[string]any // X-Pelican-Object-Metadata; ignored if TrackExtra=false for the ns
	TrackExtra   bool           // resolved at call time from per-export overrides
	// SourceEtag is the ETag returned by a remote source during a
	// third-party copy that produced this commit. Empty for direct
	// PUTs; RecordCommit persists NULL in that case, which clears
	// any stale source_etag from a prior TPC.
	SourceEtag string
}

type ObjectMetadataHistoryRow struct {
	ID            int64      `gorm:"primaryKey;autoIncrement"`
	EventID       string     `gorm:"column:event_id;uniqueIndex;not null"`
	Namespace     string     `gorm:"column:namespace;not null"`
	ObjectPath    string     `gorm:"column:object_path;not null"`
	EventType     string     `gorm:"column:event_type;not null"`
	EventTS       time.Time  `gorm:"column:event_ts;not null"`
	Size          *int64     `gorm:"column:size"`
	ETag          *string    `gorm:"column:etag"`
	EtagSource    *string    `gorm:"column:etag_source"`
	BackendMtime  *time.Time `gorm:"column:backend_mtime"`
	ChecksumsJSON string     `gorm:"column:checksums_json;not null;default:'{}'"`
	Actor         string     `gorm:"column:actor;not null;default:''"`
	Extra         string     `gorm:"column:extra;not null;default:'{}'"`
	// SourceEtag is a snapshot of the live row's source_etag at the
	// moment of the event. Populated on the 'source_etag' event only;
	// other event types leave it NULL.
	SourceEtag *string `gorm:"column:source_etag"`
}

type ObjectMetadataRow struct {
	ID           int64      `gorm:"primaryKey;autoIncrement"`
	Namespace    string     `gorm:"column:namespace;not null;index"`
	ObjectPath   string     `gorm:"column:object_path;not null"`
	Size         int64      `gorm:"column:size;not null"`
	ETag         string     `gorm:"column:etag;not null"`
	EtagSource   string     `gorm:"column:etag_source;not null;default:'backend'"`
	BackendMtime time.Time  `gorm:"column:backend_mtime;not null"`
	CreatedAt    time.Time  `gorm:"column:created_at;not null"`
	LastModified time.Time  `gorm:"column:last_modified;not null"`
	LastAccessed *time.Time `gorm:"column:last_accessed"`
	Actor        string     `gorm:"column:actor;not null;default:''"`
	DeletedAt    *time.Time `gorm:"column:deleted_at"`
	// SourceEtag is the ETag returned by the remote source during a
	// third-party copy (TPC) that produced this row. NULL for objects
	// uploaded directly. Cleared by any subsequent write that
	// invalidates the object (RecordCommit, RecordExternalChange)
	// because the stored ETag would no longer describe the source.
	SourceEtag *string `gorm:"column:source_etag"`

	// PublishedAt / PublishedEtag record whether this origin has
	// successfully published a commit webhook for the live object, and at
	// what content version. NULL PublishedAt (or PublishedEtag != ETag after
	// an overwrite) marks the row as owing a publish; the reconcile sweep
	// uses this to recover objects whose publish was lost to a crash between
	// the storage rename and the durable queue write.
	PublishedAt   *time.Time `gorm:"column:published_at"`
	PublishedEtag *string    `gorm:"column:published_etag"`
}

type OperationError struct {
	Operation   string
	Path        string
	HTTPStatus  int
	Message     string
	Recoverable bool
	// contains filtered or unexported fields
}

type PermissionDeniedError struct {
	Resource string
	Action   string
	Reason   string
}

type PoscMetricsHooks struct {
	IncActive func()
	DecActive func()
	IncExpire func()
	// IncRollbackFailed is called when the close hook fails AND the
	// best-effort RemoveAll of the just-renamed final path also
	// fails. Invoked at most once per close. Receives no namespace
	// label here — the metrics package translates it through the
	// closure that built the POSC layer.
	IncRollbackFailed func()
}

type PrunerHooks struct {
	// IncDeleted is called once per loop iteration that deleted at
	// least one row. `namespace` is the export's federation prefix;
	// `count` is the number of rows deleted in that iteration.
	IncDeleted func(namespace string, count int64)
	// ObservePassDuration is called once per full pass (all
	// namespaces), with the total wall-clock spent.
	ObservePassDuration func(d time.Duration)
}

type PublishMode string

type ResourceExhaustedError struct {
	ResourceType string
	Message      string
}

type SizeHintFs interface {
	OpenFileSized(name string, flag int, perm os.FileMode, size int64) (afero.File, error)
}

type TokenValidationError struct {
	Reason   string
	Issuer   string
	Subject  string
	Code     int
	Details  string
	Verified bool // Whether the token signature was verified before extracting metadata
}

type UserInfo struct {
	User        string
	Groups      []string
	MappedUser  string
	RequestPath string
}

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

type XattrChecksummer struct{}