kelips

type AffinityGroup interface {
	// IsLocal returns true if this node belongs the affinity group
	IsLocal() bool
	// Contact returns this nodes group contact information
	Contact() GroupContact
	// Insert a key into the affinity group returning the homenode
	Insert(key []byte) (string, error)
	// Lookup a key returning the homenode
	Lookup(*Request) (string, error)
	// Add a peer to the group
	AddPeer(peer PeerContact) error
	// Remove a peer from the group
	RemovePeer(peer PeerContact) error
	// Starts all go-routines for the group
	Start()
}

type Config struct {
	K                 int64                 // Number of affinity groups
	HashFunc          func() hash.Hash      // Hash function
	TupleTTL          time.Duration         // TTL from last seen before removing
	TupleExpireMinInt time.Duration         // Interval min to check for expirations
	TupleExpireMaxInt time.Duration         // Interval max to check for expirations
	Transport         Transport             // Network transport
	Tuples            TupleStorage          // Tuple store
	Contacts          ContactStorageFactory // Contact store
	Logger            *log.Logger
}

type ContactStorage interface {
	// Adds a PeerContact to the affinity group
	Add(PeerContact) error
	// Remove a peer from the store
	Remove(PeerContact) error
	// List returns all known peers in the affinity group
	List() []PeerContact
	// GetClosest returns the closest node to the querying node
	GetClosest() (PeerContact, bool)
	// GetRandom returns a random peer from the storage
	GetRandom() (PeerContact, bool)
}

type ContactStorageFactory interface {
	// New should return a new ContactStorage.  This is called once per
	// affinity group. Home is true if the contact store will be used for
	// the local affinity group
	New(id int64, home bool) ContactStorage
}

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

type GroupContact struct {
	ID   int64  // Group id
	Host string // Host
}

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

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

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

type Peer struct {
	Host string
	// contains filtered or unexported fields
}

type PeerContact interface {
	// Returns the ip:port of the peer
	Address() string
}

type Request struct {
	Key        []byte       // Key to lookup or insert
	TTL        int          // number of hops
	Originator GroupContact // Group originating the request
}

type Transport interface {
	Insert(contact GroupContact, key []byte) (string, error)
	// Lookup should return the home node of the key
	Lookup(contact GroupContact, req *Request) (string, error)
	// Add a peer to the group
	AddPeer(contact GroupContact, host PeerContact) error
	// Registers the affinity group with the transport
	Register(contact GroupContact, group AffinityGroup)
	// Start the transport.  This should be non-blocking
	Start(net.Listener) error
	// Shutdown the transport
	Shutdown(ctx context.Context) error
}

type Tuple struct {
	// Tuple key
	Key []byte
	// Host on which the data associated to the key lives
	Host string
	// contains filtered or unexported fields
}

type TupleStorage interface {
	// Ping should increment the tuple counter and the last seen time
	Ping(key ...[]byte) int
	// Remove all tuples not seen in the last d time.Duration
	Expire(d time.Duration) int
	// Remove all tuples with the given host
	ExpireHost(host string) int
	// Insert the tuple
	Insert(...*Tuple) int
	// Delete all given keys returning the number of keys deleted
	Delete(keys ...[]byte) int
	// Returns nil if a tuple for the key is not found
	Lookup(key []byte) *Tuple
	// List all tuples in the store
	List() []*Tuple
}