channelling

type Broadcaster interface {
	Broadcast(sessionID, roomID string, outgoing *DataOutgoing)
}

type BusManager interface {
	ChannellingAPIConsumer
	Start()
	Publish(subject string, v interface{}) error
	Request(subject string, v interface{}, vPtr interface{}, timeout time.Duration) error
	Trigger(name, from, payload string, data interface{}, pipeline *Pipeline) error
	Subscribe(subject string, cb nats.Handler) (*nats.Subscription, error)
	BindRecvChan(subject string, channel interface{}) (*nats.Subscription, error)
	BindSendChan(subject string, channel interface{}) error
	PrefixSubject(string) string
	CreateSink(string) Sink
}

type BusTrigger struct {
	Id       string
	Name     string
	From     string
	Payload  string      `json:",omitempty"`
	Data     interface{} `json:",omitempty"`
	Pipeline string      `json:",omitempty"`
}

type ByPrioAndStamp []*DataSession

type ChannellingAPI interface {
	OnConnect(*Client, *Session) (interface{}, error)
	OnDisconnect(*Client, *Session)
	OnIncoming(Sender, *Session, *DataIncoming) (interface{}, error)
	OnIncomingProcessed(Sender, *Session, *DataIncoming, interface{}, error)
}

type ChannellingAPIConsumer interface {
	SetChannellingAPI(ChannellingAPI)
	GetChannellingAPI() ChannellingAPI
}

type Client struct {
	Connection
	Codec
	ChannellingAPI ChannellingAPI
	// contains filtered or unexported fields
}

type ClientStats interface {
	ClientInfo(details bool) (int, map[string]*DataSession, map[string]string)
}

type Codec interface {
	NewBuffer() buffercache.Buffer
	IncomingDecoder
	OutgoingEncoder
}

type Config struct {
	Title                           string                    // Title
	Ver                             string                    `json:"-"` // Version (not exported to Javascript)
	S                               string                    // Static URL prefix with version
	B                               string                    // Base URL
	Token                           string                    // Server token
	Renegotiation                   bool                      // Renegotiation flag
	StunURIs                        []string                  // STUN server URIs
	TurnURIs                        []string                  // TURN server URIs
	Tokens                          bool                      // True when we got a tokens file
	Version                         string                    // Server version number
	UsersEnabled                    bool                      // Flag if users are enabled
	UsersAllowRegistration          bool                      // Flag if users can register
	UsersMode                       string                    // Users mode string
	DefaultRoomEnabled              bool                      // Flag if default room ("") is enabled
	Plugin                          string                    // Plugin to load
	AuthorizeRoomCreation           bool                      // Whether a user account is required to create rooms
	AuthorizeRoomJoin               bool                      // Whether a user account is required to join rooms
	Modules                         []string                  // List of enabled modules
	ModulesTable                    map[string]bool           `json:"-"` // Map of enabled modules
	GlobalRoomID                    string                    `json:"-"` // Id of the global room (not exported to Javascript)
	ContentSecurityPolicy           string                    `json:"-"` // HTML content security policy
	ContentSecurityPolicyReportOnly string                    `json:"-"` // HTML content security policy in report only mode
	RoomTypeDefault                 string                    `json:"-"` // New rooms default to this type
	RoomTypes                       map[*regexp.Regexp]string `json:"-"` // Map of regular expression -> room type
}

type Connection interface {
	Index() uint64
	Send(buffercache.Buffer)
	Close()
	ReadPump()
	WritePump()
}

type ConnectionCounter interface {
	CountConnection() uint64
}

type ConnectionHandler interface {
	NewBuffer() buffercache.Buffer
	OnConnect(Connection)
	OnDisconnect()
	OnText(buffercache.Buffer)
}

type Contact struct {
	A string
	B string
}

type ContactManager interface {
	ContactrequestHandler(*Session, string, *DataContactRequest) error
	GetContactID(*Session, string) (string, error)
}

type Context struct {
	App        string // Main client script
	Cfg        *Config
	Host       string
	Ssl        bool
	Csp        bool
	Languages  []string
	Room       string        `json:"-"`
	Scheme     string        `json:"-"`
	Origin     string        `json:",omitempty"`
	S          string        `json:",omitempty"`
	ExtraDHead template.HTML `json:"-"`
	ExtraDBody template.HTML `json:"-"`
}

type DataAlive struct {
	Type  string
	Alive uint64
}

type DataAnswer struct {
	Type   string
	To     string
	Answer map[string]interface{}
}

type DataAuthentication struct {
	Type           string
	Authentication *SessionToken
}

type DataAutoCall struct {
	Id   string
	Type string
}

type DataBye struct {
	Type string
	To   string
	Bye  interface{}
}

type DataCandidate struct {
	Type      string
	To        string
	Candidate interface{}
}

type DataChat struct {
	To   string
	Type string
	Chat *DataChatMessage
}

type DataChatMessage struct {
	Message string
	Time    string
	NoEcho  bool   `json:",omitempty"`
	Mid     string `json:",omitempty"`
	Status  *DataChatStatus
}

type DataChatStatus struct {
	Typing         string              `json:",omitempty"`
	State          string              `json:",omitempty"`
	Mid            string              `json:",omitempty"`
	SeenMids       []string            `json:",omitempty"`
	FileInfo       *DataFileInfo       `json:",omitempty"`
	Geolocation    *DataGeolocation    `json:",omitempty"`
	ContactRequest *DataContactRequest `json:",omitempty"`
	AutoCall       *DataAutoCall       `json:",omitempty"`
}

type DataConference struct {
	Id         string
	Type       string
	Conference []string
}

type DataContactRequest struct {
	Id      string
	Success bool
	Userid  string `json:",omitempty"`
	Token   string `json:",omitempty"`
}

type DataError struct {
	Type    string
	Code    string
	Message string
}

type DataFileInfo struct {
	Id     string `json:"id"`
	Chunks uint64 `json:"chunks"`
	Name   string `json:"name"`
	Size   uint64 `json:"size"`
	Type   string `json:"type"`
}

type DataGeolocation struct {
	Accuracy         float64 `json:"accuracy,omitempty"`
	Latitude         float64 `json:"latitude,omitempty"`
	Longitude        float64 `json:"longitude,omitempty"`
	Altitude         float64 `json:"altitude,omitempty"`
	AltitudeAccuracy float64 `json:"altitudeAccuracy,omitempty"`
}

type DataHello struct {
	Version     string
	Ua          string
	Id          string // Compatibility with old clients.
	Name        string // Room name.
	Type        string // Room type.
	Credentials *DataRoomCredentials
}

type DataIncoming struct {
	Type           string
	Hello          *DataHello          `json:",omitempty"`
	Offer          *DataOffer          `json:",omitempty"`
	Candidate      *DataCandidate      `json:",omitempty"`
	Answer         *DataAnswer         `json:",omitempty"`
	Bye            *DataBye            `json:",omitempty"`
	Status         *DataStatus         `json:",omitempty"`
	Chat           *DataChat           `json:",omitempty"`
	Conference     *DataConference     `json:",omitempty"`
	Alive          *DataAlive          `json:",omitempty"`
	Authentication *DataAuthentication `json:",omitempty"`
	Sessions       *DataSessions       `json:",omitempty"`
	Room           *DataRoom           `json:",omitempty"`
	Iid            string              `json:",omitempty"`
}

type DataOffer struct {
	Type  string
	To    string
	Offer map[string]interface{}
}

type DataOutgoing struct {
	Data interface{} `json:",omitempty"`
	From string      `json:",omitempty"`
	To   string      `json:",omitempty"`
	Iid  string      `json:",omitempty"`
	A    string      `json:",omitempty"`
}

type DataRoom struct {
	Type        string // Room type.
	Name        string // Room name.
	Credentials *DataRoomCredentials
}

type DataRoomCredentials struct {
	PIN string
}

type DataSelf struct {
	Type       string
	Id         string
	Sid        string
	Userid     string
	Suserid    string
	Token      string
	Version    string  // Server version.
	ApiVersion float64 // Server channelling API version.
	Turn       *DataTurn
	Stun       []string
}

type DataSession struct {
	Type    string
	Id      string
	Userid  string      `json:",omitempty"`
	Ua      string      `json:",omitempty"`
	Token   string      `json:",omitempty"`
	Version string      `json:",omitempty"`
	Rev     uint64      `json:",omitempty"`
	Prio    int         `json:",omitempty"`
	Status  interface{} `json:",omitempty"`
	// contains filtered or unexported fields
}

type DataSessions struct {
	Type     string
	Sessions *DataSessionsRequest `json:",omitempty"`
	Users    []*DataSession
}

type DataSessionsRequest struct {
	Token string
	Type  string
}

type DataSink struct {
	SubjectOut string `json:subject_out"`
	SubjectIn  string `json:subject_in"`
}

type DataSinkOutgoing struct {
	Outgoing   *DataOutgoing
	ToUserid   string
	FromUserid string
	Pipe       string `json:",omitempty"`
}

type DataStatus struct {
	Type   string
	Status interface{}
}

type DataTurn struct {
	Username string   `json:"username"`
	Password string   `json:"password"`
	Ttl      int      `json:"ttl"`
	Urls     []string `json:"urls"`
}

type DataUser struct {
	Id       string
	Sessions int
}

type DataWelcome struct {
	Type  string
	Room  *DataRoom
	Users []*DataSession
}

type Hub interface {
	ClientStats
	Unicaster
	TurnDataCreator
	ContactManager
}

type HubStat struct {
	Rooms                 int                     `json:"rooms"`
	Connections           int                     `json:"connections"`
	Sessions              int                     `json:"sessions"`
	Users                 int                     `json:"users"`
	Count                 uint64                  `json:"count"`
	BroadcastChatMessages uint64                  `json:"broadcastchatmessages"`
	UnicastChatMessages   uint64                  `json:"unicastchatmessages"`
	IdsInRoom             map[string][]string     `json:"idsinroom,omitempty"`
	SessionsById          map[string]*DataSession `json:"sessionsbyid,omitempty"`
	UsersById             map[string]*DataUser    `json:"usersbyid,omitempty"`
	ConnectionsByIdx      map[string]string       `json:"connectionsbyidx,omitempty"`
}

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

type ImageCache interface {
	Update(sessionId string, image string) string
	Get(imageId string) *Image
	Delete(sessionId string)
}

type IncomingDecoder interface {
	DecodeIncoming(buffercache.Buffer) (*DataIncoming, error)
}

type OutgoingEncoder interface {
	EncodeOutgoing(*DataOutgoing) (buffercache.Buffer, error)
}

type Pipeline struct {
	PipelineManager PipelineManager
	// contains filtered or unexported fields
}

type PipelineFeedLine struct {
	Seq int
	Msg *DataOutgoing
}

type PipelineManager interface {
	BusManager
	SessionStore
	UserStore
	SessionCreator
	GetPipelineByID(id string) (pipeline *Pipeline, ok bool)
	GetPipeline(namespace string, sender Sender, session *Session, to string) *Pipeline
	FindSinkAndSession(to string) (Sink, *Session)
}

type RoomManager interface {
	RoomStatusManager
	Broadcaster
	RoomStats
	SetBusManager(bus BusManager) error
}

type RoomStats interface {
	RoomInfo(includeSessions bool) (count int, sessionInfo map[string][]string)
}

type RoomStatusManager interface {
	RoomUsers(*Session) []*DataSession
	JoinRoom(roomID, roomName, roomType string, credentials *DataRoomCredentials, session *Session, sessionAuthenticated bool, sender Sender) (*DataRoom, error)
	LeaveRoom(roomID, sessionID string)
	UpdateRoom(*Session, *DataRoom) (*DataRoom, error)
	MakeRoomID(roomName, roomType string) string
	Get(roomID string) (room RoomWorker, ok bool)
}

type RoomWorker interface {
	Start()
	SessionIDs() []string
	Users() []*roomUser
	Update(*DataRoom) error
	GetUsers() []*DataSession
	Broadcast(sessionID string, buf buffercache.Buffer)
	Join(*DataRoomCredentials, *Session, Sender) (*DataRoom, error)
	Leave(sessionID string)
	GetType() string
}

type Sender interface {
	Index() uint64
	Send(buffercache.Buffer)
}

type Session struct {
	SessionManager    SessionManager
	Unicaster         Unicaster
	Broadcaster       Broadcaster
	RoomStatusManager RoomStatusManager

	Id        string
	Sid       string
	Ua        string
	UpdateRev uint64
	Status    interface{}
	Nonce     string
	Prio      int
	Hello     bool
	Roomid    string
	// contains filtered or unexported fields
}

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

type SessionCreateRequest struct {
	Id           string
	Session      *DataSession
	Room         *DataRoom
	SetAsDefault bool
}

type SessionCreator interface {
	CreateSession(st *SessionToken, userid string) *Session
}

type SessionEncoder interface {
	EncodeSessionToken(*Session) (string, error)
	EncodeSessionUserID(*Session) string
}

type SessionManager interface {
	UserStats
	SessionStore
	UserStore
	SessionCreator
	DestroySession(sessionID, userID string)
	Authenticate(*Session, *SessionToken, string) error
	GetUserSessions(session *Session, id string) []*DataSession
	DecodeSessionToken(token string) (st *SessionToken)
}

type SessionStore interface {
	GetSession(id string) (session *Session, ok bool)
}

type SessionToken struct {
	Id     string // Public session id.
	Sid    string // Secret session id.
	Userid string // Public user id.
	Nonce  string `json:"Nonce,omitempty"` // User autentication nonce.
}

type SessionUpdate struct {
	Types  []string
	Ua     string
	Prio   int
	Status interface{}
}

type SessionValidator interface {
	Realm() string
	ValidateSession(string, string) bool
}

type Sink interface {
	// Write sends outgoing data on the sink
	Write(*DataSinkOutgoing) error
	Enabled() bool
	Close()
	Export() *DataSink
	BindRecvChan(channel interface{}) (*nats.Subscription, error)
}

type StatsCounter interface {
	CountBroadcastChat()
	CountUnicastChat()
}

type StatsGenerator interface {
	Stat(details bool) *HubStat
}

type StatsManager interface {
	ConnectionCounter
	StatsCounter
	StatsGenerator
}

type Tickets interface {
	SessionValidator
	SessionEncoder
	DecodeSessionToken(token string) (st *SessionToken)
	FakeSessionToken(userid string) *SessionToken
}

type TokenFile struct {
	Path   string
	Info   os.FileInfo
	Reload func()
	Tokens map[string]bool
}

type TokenProvider func(token string) string

type TurnDataCreator interface {
	CreateTurnData(*Session) *DataTurn
}

type Unicaster interface {
	SessionStore
	OnConnect(*Client, *Session)
	OnDisconnect(*Client, *Session)
	Unicast(to string, outgoing *DataOutgoing, pipeline *Pipeline)
}

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

type UserStats interface {
	UserInfo(bool) (int, map[string]*DataUser)
}

type UserStore interface {
	GetUser(id string) (user *User, ok bool)
}