hub

type ACLStorage interface {
	// Insert inserts the given worker credentials to the storage.
	Insert(credentials string)
	// Remove removes the given worker credentials from the storage.
	// Returns true if it was actually removed.
	Remove(credentials string) bool
	// Has checks whether the given worker credentials contains in the
	// storage.
	Has(credentials string) bool
	// Each applies the specified function to each credentials in the storage.
	// Traversal will continue until all items in the Set have been visited,
	// or if the closure returns false.
	Each(fn func(string) bool)
}

type AllocationStatus int

type Cluster interface {
	// Starts synchronization process. Can be called multiple times after error is received in EventChannel
	Run() error

	Close()

	// IsLeader returns true if this cluster is a leader, i.e. we rule the
	// synchronization process.
	IsLeader() bool

	LeaderClient() (pb.HubClient, error)

	RegisterAndLoadEntity(name string, prototype interface{}) error

	Synchronize(entity interface{}) error

	// Fetch current cluster members
	Members() ([]NewMemberEvent, error)
}

type ClusterConfig struct {
	Store                        StoreConfig `yaml:"store"`
	Failover                     bool        `yaml:"failover"`
	Endpoint                     string      `yaml:"endpoint"`
	AnnounceEndpoint             string      `yaml:"announce_endpoint"`
	LeaderKey                    string      `yaml:"leader_key" default:"sonm/hub/leader"`
	MemberListKey                string      `yaml:"member_list_key" default:"sonm/hub/list"`
	SynchronizableEntitiesPrefix string      `yaml:"sync_prefix" default:"sonm/hub/sync"`
	LeaderTTL                    uint64      `yaml:"leader_ttl" default:"20"`
	AnnouncePeriod               uint64      `yaml:"announce_period" default:"10"`
	AnnounceTTL                  uint64      `yaml:"announce_ttl" default:"20"`
	MemberGCPeriod               uint64      `yaml:"member_gc_period" default:"60"`
}

type ClusterEvent interface{}

type Config struct {
	Endpoint      string             `required:"true" yaml:"endpoint"`
	GatewayConfig *GatewayConfig     `yaml:"gateway"`
	Logging       LoggingConfig      `yaml:"logging"`
	Eth           accounts.EthConfig `yaml:"ethereum"`
	Locator       LocatorConfig      `yaml:"locator"`
	Market        MarketConfig       `yaml:"market"`
	Cluster       ClusterConfig      `yaml:"cluster"`
	Whitelist     WhitelistConfig    `yaml:"whitelist"`
}

type DealID string

type DealMeta struct {
	ID      DealID
	BidID   string
	MinerID string
	Order   structs.Order
	Usage   *resource.Resources
	Tasks   []*TaskInfo
	// contains filtered or unexported fields
}

type DealMetaData interface {
	// Deal extracts deal ID from the request.
	Deal(ctx context.Context, request interface{}) (DealID, error)
	// Wallet extracts self-signed wallet from the request.
	Wallet(ctx context.Context, request interface{}) (string, error)
}

type DeviceProperties map[string]float64

type ETH interface {
	// VerifyBuyerBalance verifies that the buyer specified under the given
	// order has enough balance to have a deal.
	VerifyBuyerBalance(bidOrder *structs.Order) error
	// VerifyBuyerAllowance verifies that the buyer specified under the given
	// order has enough allowance to have a deal.
	VerifyBuyerAllowance(bidOrder *structs.Order) error
	// GetAcceptedDeals returns all currently accepted deals.
	GetAcceptedDeals(ctx context.Context) ([]*pb.Deal, error)
	// GetClosedDeals returns all currently closed deals.
	// Warning: use with caution: this may return significantly large amount
	// of data.
	GetClosedDeals(ctx context.Context) ([]*pb.Deal, error)
	// WaitForDealCreated waits for deal created on Buyer-side
	WaitForDealCreated(request *structs.DealRequest, buyerID string) (*pb.Deal, error)
	// WaitForDealClosed blocks the current execution context until the
	// specified deal is closed.
	WaitForDealClosed(ctx context.Context, dealID DealID, buyerID string) error
	// AcceptDeal approves deal on Hub-side.
	AcceptDeal(id string) error
	// CloseDeal closes the specified deal on Hub-side.
	CloseDeal(id DealID) error
	// GetDeal checks whether a given deal exists.
	GetDeal(id string) (*pb.Deal, error)
}

type EventAuthorization interface {
	Authorize(ctx context.Context, request interface{}) error
}

type GatewayConfig struct {
	Ports []uint16 `required:"true" yaml:"ports"`
}

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

type LeadershipEvent struct {
	Held            bool
	LeaderId        string
	LeaderEndpoints []string
}

type LocatorConfig struct {
	Endpoint string `required:"true" yaml:"endpoint"`
	Period   int    `required:"true" default:"300" yaml:"period"`
}

type LoggingConfig struct {
	Level int `required:"true" default:"1"`
}

type Market interface {
	// OrderExists checks whether an order with the specified ID exists in the
	// marketplace.
	OrderExists(ID string) (bool, error)
	// CreateOrder creates order on marketplace
	CreateOrder(ord *pb.Order) (*pb.Order, error)
	// CancelOrder removes order from marketplace
	CancelOrder(ID string) error
}

type MarketConfig struct {
	Endpoint string `required:"true" yaml:"endpoint"`
}

type MinerCtx struct {

	// gRPC Client
	Client pb.MinerClient
	// contains filtered or unexported fields
}

type NewMemberEvent struct {
	Id string
	// contains filtered or unexported fields
}

type Option func(options *options)

type OrderID string

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

type StoreConfig struct {
	Type     string `required:"true" default:"boltdb" yaml:"type"`
	Endpoint string `required:"true" default:"/tmp/sonm/boltdb" yaml:"endpoint"`
	Bucket   string `required:"true" default:"sonm" yaml:"bucket"`
	KeyFile  string `yaml:"key_file"`
	CertFile string `yaml:"cert_file"`
}

type TaskInfo struct {
	structs.StartTaskRequest
	pb.MinerStartReply
	ID      string
	DealId  DealID
	MinerId string
	EndTime *time.Time
}

type Whitelist interface {
	Allowed(ctx context.Context, registry string, image string, auth string) (bool, reference.Named, error)
}

type WhitelistConfig struct {
	Url                 string   `yaml:"url"`
	Enabled             *bool    `yaml:"enabled" default:"true" required:"true"`
	PrivilegedAddresses []string `yaml:"privileged_addresses"`
	RefreshPeriod       uint     `yaml:"refresh_period" default:"60"`
}

type WhitelistRecord struct {
	AllowedHashes []string `json:"allowed_hashes"`
}