conductor

type Client struct {
	Read <-chan *Message
	// contains filtered or unexported fields
}

type Connection interface {
	Write(message *Message) error  // Write is to send a message to the client this connection represents.
	ReadLoop(hub HubConnection)    // ReadLoop is the loop that keeps this connection alive. Don't call this.
	Disconnect()                   // Disconnect is use to disconnect the connection.
	Channels() []string            // Channels is to hold the channels this connection is bound to. Very useful for auth and cleanup.
	SetChannels(channels []string) // Update the channel list of this connection.
	Store(key, value string)       // Store is a map of local storage for the connection. This way you can identify the connection in other interfaces.
	Get(key string) string         // Get is a map of local storage for the connection.
}

type ConnectionAuth interface {
	IsValid(r *http.Request) bool                    // IsValid is called on every HTTP upgrade request and should be used to validate auth tokens.
	ConnToRequest(r *http.Request, conn Connection)  // ConnToRequest is called so you can map your HTTP request (like the auth token) to a current connection.
	CanBind(conn Connection, message *Message) bool  // CanBind is called on every bind request, so optimizing it is highly recommended.
	CanWrite(conn Connection, message *Message) bool // CanWrite is called on every write request, so optimizing it is highly recommended.
	IsSister(r *http.Request) bool                   // IsSister is called on every HTTP upgrade request and should be used to check if an incoming connection is from a sister node or not.
}

type DeDuplication interface {
	Start()
	Add(message *Message)
	Remove(message *Message)
	IsDuplicate(message *Message) bool
}

type Hub interface {
	RunLoop()                                                // This is the master run loop that processes all the messages that come into the channel.
	Write(conn Connection, message *Message)                 // Not sure if I like the duplicate method trick yet...
	Auth() ConnectionAuth                                    // This returns the current auther (if one is used)
	SisterManager() SisterManager                            // This returns the current sister manager (if one is used)
	ReceivedSisterMessage(conn Connection, message *Message) // Handle a sister message into this hub
}

type HubConnection interface {
	Write(conn Connection, message *Message)
	ReceivedSisterMessage(conn Connection, message *Message)
}

type Message struct {
	Opcode uint16 `json:"opcode"`

	Uuid string `json:"uuid"`

	ChannelName string `json:"channel_name"`

	Body []byte `json:"body"`
	// contains filtered or unexported fields
}

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

type Server struct {
	Port     int
	CertName string
	KeyName  string
	Router   http.Handler
	// contains filtered or unexported fields
}

type ServerClient interface {
	Start(useHTTPServer bool) error
	AddSister(sister SisterClient) error
}

type ServerHubHandler interface {
	Process(conn Connection, message *Message)
}

type SimpleAuth struct {
}

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

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

type SisterClient interface {
	Connect(h HubConnection) error // do the network connection to the sister server
	Write(message *Message)        // write a message to the sister server
	ReadLoop(h HubConnection)      // start the read loop to process messages from the sister server

}

type SisterManager interface {
	Start()                          // start by fetching/searching for your sister servers.
	Write(message *Message)          // write a message to all the sister servers under this management
	SisterConnected(c Connection)    // notification when a sister connects to this server
	SisterDisconnected(c Connection) // notification when a sister disconnects from this server
	MetaQueryResponse() []byte       // respond to a meta query with some content
	HandleMetaQueryResponse([]byte)  // this manager got a response to a query it sent
	// contains filtered or unexported methods
}

type SisterManagerClient interface {
	// contains filtered or unexported methods
}

type SisterServer struct {
	ServerURL string
	// contains filtered or unexported fields
}

type SisterServerClient interface {
}

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

type Storage interface {
	Store(conn Connection, message *Message)          //user on this connection wrote a message to a channel.
	SentTo(sender, conn Connection, message *Message) //a connection sent a message to the other connection.
}