replication

type Address = refs.Address

type AddressStore interface {
	SelfAddr() (multiaddr.Multiaddr, error)
}

type CID = refs.CID

type ContainerActualityChecker interface {
	Actual(ctx context.Context, cid CID) bool
}

type EpochReceiver interface {
	Epoch() uint64
}

type LocationDetectorParams struct {
	WeightComparator
	ObjectLocator
	ReservationRatioReceiver
	PresenceChecker
	*zap.Logger

	TaskChanCap   int
	ResultTimeout time.Duration
}

type Manager interface {
	Process(ctx context.Context)
	HandleEpoch(ctx context.Context, epoch uint64)
}

type ManagerParams struct {
	Interval                time.Duration
	PushTaskTimeout         time.Duration
	PlacementHonorerEnabled bool
	ReplicateTaskChanCap    int
	RestoreTaskChanCap      int
	GarbageChanCap          int
	InitPoolSize            int
	ExpansionRate           float64

	ObjectPool
	ObjectVerifier

	PlacementHonorer
	ObjectLocationDetector
	StorageValidator
	ObjectReplicator
	ObjectRestorer

	*zap.Logger

	Scheduler
}

type MultiSolver interface {
	AddressStore
	RemoteStorageSelector
	ReservationRatioReceiver
	ContainerActualityChecker
	EpochReceiver
	WeightComparator
}

type MultiSolverParams struct {
	AddressStore
	Placement placement.Component
}

type Object = object.Object

type ObjectCleaner interface {
	Del(Address) error
}

type ObjectLocation struct {
	Node          multiaddr.Multiaddr
	WeightGreater bool // true if Node field value has less index in placement vector than localhost
}

type ObjectLocationDetector interface {
	Process(ctx context.Context) chan<- Address
	Subscribe(ch chan<- *ObjectLocationRecord)
}

type ObjectLocationRecord struct {
	Address
	ReservationRatio int
	Locations        []ObjectLocation
}

type ObjectLocator interface {
	LocateObject(ctx context.Context, objAddr Address) ([]multiaddr.Multiaddr, error)
}

type ObjectPool interface {
	Update([]Address)
	Pop() (Address, error)
	Undone() int
}

type ObjectReceptacle interface {
	Put(ctx context.Context, params ObjectStoreParams) error
}

type ObjectReplicator interface {
	Process(ctx context.Context) chan<- *ReplicateTask
	Subscribe(ch chan<- *ReplicateResult)
}

type ObjectReplicatorParams struct {
	RemoteStorageSelector
	ObjectSource
	ObjectReceptacle
	PresenceChecker
	*zap.Logger

	TaskChanCap   int
	ResultTimeout time.Duration
}

type ObjectRestorer interface {
	Process(ctx context.Context) chan<- Address
	Subscribe(ch chan<- Address)
}

type ObjectRestorerParams struct {
	ObjectVerifier
	ObjectReceptacle
	EpochReceiver
	RemoteStorageSelector
	PresenceChecker
	*zap.Logger

	TaskChanCap   int
	ResultTimeout time.Duration
}

type ObjectSource interface {
	Get(ctx context.Context, addr Address) (*Object, error)
}

type ObjectStoreParams struct {
	*Object
	Nodes   []ObjectLocation
	Handler func(ObjectLocation, bool)
}

type ObjectVerificationParams struct {
	Address
	Node         multiaddr.Multiaddr
	Handler      func(valid bool, obj *Object)
	LocalInvalid bool
}

type ObjectVerifier interface {
	Verify(ctx context.Context, params *ObjectVerificationParams) bool
}

type OwnerID = object.OwnerID

type PlacementHonorer interface {
	Process(ctx context.Context) chan<- *ObjectLocationRecord
	Subscribe(ch chan<- *ObjectLocationRecord)
}

type PlacementHonorerParams struct {
	ObjectSource
	ObjectReceptacle
	RemoteStorageSelector
	PresenceChecker
	*zap.Logger

	TaskChanCap   int
	ResultTimeout time.Duration
}

type PresenceChecker interface {
	Has(address Address) (bool, error)
}

type RemoteStorageSelector interface {
	SelectRemoteStorages(ctx context.Context, addr Address, excl ...multiaddr.Multiaddr) ([]ObjectLocation, error)
}

type ReplicateResult struct {
	*ReplicateTask
	NewStorages []multiaddr.Multiaddr
}

type ReplicateTask struct {
	Address
	Shortage     int
	ExcludeNodes []multiaddr.Multiaddr
}

type ReservationRatioReceiver interface {
	ReservationRatio(ctx context.Context, objAddr Address) (int, error)
}

type Scheduler interface {
	SelectForReplication(limit int) ([]Address, error)
}

type SchedulerParams struct {
	ContainerActualityChecker
	localstore.Iterator
}

type StorageValidator interface {
	Process(ctx context.Context) chan<- *ObjectLocationRecord
	SubscribeReplication(ch chan<- *ReplicateTask)
	SubscribeGarbage(ch chan<- Address)
}

type StorageValidatorParams struct {
	ObjectVerifier
	PresenceChecker
	*zap.Logger

	TaskChanCap   int
	ResultTimeout time.Duration
	AddrStore     AddressStore
}

type WeightComparator interface {
	CompareWeight(ctx context.Context, addr Address, node multiaddr.Multiaddr) int
}