archive

type Archiver struct {

	// Now is the clock (tests set it).
	Now func() time.Time
	// MaxObjectBytes caps one object (0: defaultMaxObjectBytes).
	MaxObjectBytes int64
	// Report, when set, is told about every object and every run.
	Report func(Report)
	// contains filtered or unexported fields
}

type Config struct {
	// Env prefixes every key ("prod", "preview"); each environment's MinIO
	// user can only reach its own prefix.
	Env       string
	Endpoint  string
	Bucket    string
	Region    string
	AccessKey string
	SecretKey string
	// HTTP overrides the S3 client's HTTP client (tests); nil is the default.
	HTTP *http.Client
}

type DeleteReport struct {
	Requests int // requests finished this run
	Objects  int // objects deleted
	Failed   int // requests that failed (retried next run)
	Overdue  int // pending requests older than DeleteWithin
}

type Deleter struct {

	// ClockMargin is added to a request's time when picking the objects
	// written before it: MinIO's clock and Postgres's can differ a little,
	// and the margin errs toward deleting. Nothing new can be archived for
	// the user that soon (the reset removed their samples, and the archive
	// takes months 90 days old). Tests set 0.
	ClockMargin time.Duration
	// Report, when set, is told the run's totals.
	Report func(DeleteReport)
	// contains filtered or unexported fields
}

type Execer interface {
	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
}

type Manifest struct {
	Schema  string   `json:"schema"`
	Columns []string `json:"columns"`
	Rows    int64    `json:"rows"`
	// FirstAt and LastAt are checked at verify and recorded in archive_months,
	// but not written to the plaintext manifest: after a crypto-shred the
	// manifest lingers until the deletion job runs, and should say nothing
	// about when the user drove (DA).
	FirstAt      string    `json:"-"`
	LastAt       string    `json:"-"`
	SHA256Plain  string    `json:"sha256_plain"`
	SHA256Object string    `json:"sha256_object"`
	Bytes        int64     `json:"bytes"`
	CreatedAt    time.Time `json:"created_at"`
}

type ObjectRef struct {
	VehicleID uuid.UUID
	Month     time.Time
	Rows      int64
}

type Querier interface {
	QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row
}

type Reader struct {

	// OnCorrupt, when set, is told about an object that exists but fails to
	// read back: corrupt, truncated, or not this user's. For a thinned month
	// that is the full-resolution data lost, so the caller counts and alerts.
	OnCorrupt func(uid, vehicleID uuid.UUID, month time.Time, err error)
	// contains filtered or unexported fields
}

type Report struct {
	Month     string
	UserID    uuid.UUID
	VehicleID uuid.UUID
	Rows      int64
	Bytes     int64
	Err       error
	// Done marks the run's summary: Objects archived, Failed objects.
	Done    bool
	Objects int
	Failed  int
}

type RestoreResult struct {
	InObject int64 `json:"in_object"`
	Present  int64 `json:"already_present"`
	Inserted int64 `json:"inserted"`
	// DBOnly is rows the database has that the object lacks; they stay, and
	// the month stays flagged for re-archiving.
	DBOnly      int64      `json:"db_only"`
	RethinAfter *time.Time `json:"rethin_after,omitempty"`
	DryRun      bool       `json:"dry_run"`
}

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

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

type Stats struct {
	Rows        int64
	FirstAt     string
	LastAt      string
	SHA256Plain string
}