goutube

type Agent struct {
	AgentConfig
	// contains filtered or unexported fields
}

type AgentConfig struct {
	DataDir          string
	BindAddr         string
	RPCPort          int
	ReplicationPort  int
	NodeName         string
	SeedAddresses    []string
	VirtualNodeCount int

	ACLModelFile    string
	ACLPolicyFile   string
	ServerTLSConfig *tls.Config // Served to clients.
	PeerTLSConfig   *tls.Config // Servers so they can connect with and replicate each other.

	LeaderAddresses []string          // Addresses of the servers which will set this server as one of its loadbalancers (for replication).
	Rule            ParticipationRule // True, if this server takes part in the ring (peer-to-peer architecture) and/or replication.

	MaxChunkSize       uint64 // MaxChunkSize defines the size of the chunk that can be processed by this server.
	MultiStreamPercent int    // MultiStreamPercent tells Percents of the number of followers to return upon GetMetadata request?
}

type Arc struct {
	ArcConfig

	Dir string
	// contains filtered or unexported fields
}

type ArcConfig struct {

	// Dialer
	StreamLayer StreamLayer
	Logger      hclog.Logger
	// Timeout is used to apply I/O deadlines. For InstallSnapshot, we multiply
	// the timeout by (SnapshotSize / TimeoutScale).
	Timeout time.Duration

	MaxChunkSize uint64

	Bundler Bundler
	// contains filtered or unexported fields
}

type Bundler interface {
	Build(header interface{}, key interface{}, value interface{}) ([]byte, error)
}

type Config struct {
	Distributed struct {
		LocalID      string
		StreamLayer  *LocusStreamLayer
		StoreAddress string
		Logger       hclog.Logger
		Rule         ParticipationRule
		RPCAddress   string
		Ring         *ring.Ring
		MaxChunkSize uint64
	}
	Point struct {
		TickTime     time.Duration
		CloseTimeout time.Duration
		// contains filtered or unexported fields
	}
}

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

type FSM interface {
	Apply(command *RecordRequest) *FSMRecordResponse
	Read(key string, offset uint64) (uint64, []byte, error)
}

type FSMRecordResponse struct {
	StoreKey   interface{}
	StoreValue interface{}
	Response   interface{}
}

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

type FollowerResolverHelper struct {
	streaming_api.UnimplementedFollowerResolverHelperServer
	*ResolverHelperConfig
}

type GetFollowerer interface {
	GetFollowers(*streaming_api.GetFollowersRequest) ([]*streaming_api.Server, error)
}

type GetServerer interface {
	GetServers(*streaming_api.GetServersRequest) ([]*streaming_api.Server, error)
}

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

type GetServersRequest struct {
}

type GetServersResponse struct {
	Response interface{}
}

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

type LBResolverHelper struct {
	streaming_api.UnimplementedLBResolverHelperServer
	*ResolverHelperConfig
}

type Locus struct {
	Config Config
	// contains filtered or unexported fields
}

type LocusHelper interface {
	Append(*streaming_api.ProduceRequest) (uint64, error)
	GetMetadata(string) (PointMetadata, error)
	ReadWithLimit(string, uint64, uint64, uint64) (uint64, []byte, error)
	ClosePoint(string) error
}

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

type ParticipationRule uint8

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

type Point struct {
	File *os.File
	// contains filtered or unexported fields
}

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

type Promise interface {
	Error() error
	Response() interface{}
}

type RPC struct {
	Command  interface{}
	RespChan chan<- RPCResponse
}

type RPCResponse struct {
	Response interface{}
	Error    error
}

type RecordEntriesPipeline interface {
	// SendRecordEntriesRequest is used to add another request to the pipeline.
	// To send may block which is an effective form of back-pressure.
	SendRecordEntriesRequest(req *RecordEntriesRequest, resp *RecordEntriesResponse) (Promise, error)

	// Consumer returns a channel that can be used to consume
	// response futures when they are ready.
	Consumer() <-chan Promise

	// Close closes the pipeline and cancels all inflight RPCs
	Close() error
}

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

type RecordEntriesRequest struct {
	Entries []*RecordRequest
}

type RecordEntriesResponse struct {
	LastOff  uint64
	Response interface{}
}

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

type RecordRequest struct {
	Data []byte
}

type RecordResponse struct {
	LastOff  uint64
	Response interface{}
}

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

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

type ReplicationClusterConfig struct {
	NodeName      string
	BindAddr      string
	Tags          map[string]string
	SeedAddresses []string
}

type ReplicationClusterHandler interface {
	Join(rpcAddr string, rule ParticipationRule) error
	Leave(rpcAddr string) error
}

type RequestBundler struct {
}

type RequestType uint8

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

type ResolverHelperConfig struct {
	GetServerer   GetServerer
	GetFollowerer GetFollowerer
}

type Server struct {
	// Address is its network address that a transport can contact.
	Address ServerAddress
}

type ServerAddress string

type ServerConfig struct {
	StreamingConfig      *StreamingConfig
	ResolverHelperConfig *ResolverHelperConfig
	Rule                 ParticipationRule
}

type ServerID string

type Store interface {
	AddPointEvent(pointId string, offset uint64) error
	GetPointEvent(pointId string) (uint64, error)
}

type StreamLayer interface {
	net.Listener

	// Dial is used to create a new outgoing connection
	Dial(address ServerAddress, timeout time.Duration) (net.Conn, error)
}

type StreamingConfig struct {
	Locus      LocusHelper
	Authorizer *authorizer
}

type StreamingManager struct {
	streaming_api.UnimplementedStreamingServer
	*StreamingConfig
}

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

type TLSConfig struct {
	CertFile      string
	KeyFile       string
	CAFile        string
	ServerAddress string
	Server        bool
}

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

type TransportConfig struct {
	Logger hclog.Logger

	// Dialer
	Stream StreamLayer

	// Timeout is used to apply I/O deadlines. For InstallSnapshot, we multiply
	// the timeout by (SnapshotSize / TimeoutScale).
	Timeout time.Duration

	MaxPool int
}