proxy

type BoolValue struct {
	Value bool `json:"value,omitempty"`
}

type ConnectCredentials struct {
	UserID     string                      `json:"user"`
	ExpireAt   int64                       `json:"expire_at"`
	Info       json.RawMessage             `json:"info"`
	Base64Info string                      `json:"b64info"`
	Data       json.RawMessage             `json:"data"`
	Base64Data string                      `json:"b64data"`
	Channels   []string                    `json:"channels"`
	Subs       map[string]SubscribeOptions `json:"subs,omitempty"`
}

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

type ConnectHandlerConfig struct {
	Proxy ConnectProxy
}

type ConnectProxy interface {
	ProxyConnect(context.Context, *proxyproto.ConnectRequest) (*proxyproto.ConnectResponse, error)
	// Protocol for metrics and logging.
	Protocol() string
	// UseBase64 for bytes in requests from Centrifugo to application backend.
	UseBase64() bool
}

type ConnectReply struct {
	Result     *ConnectCredentials    `json:"result"`
	Error      *centrifuge.Error      `json:"error"`
	Disconnect *centrifuge.Disconnect `json:"disconnect"`
}

type ConnectRequest struct {
	ClientID  string
	Transport centrifuge.TransportInfo
	Data      []byte
	Name      string
	Version   string
}

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

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

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

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

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

type HTTPCaller interface {
	CallHTTP(context.Context, string, http.Header, []byte) ([]byte, error)
}

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

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

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

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

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

type Proxy struct {
	// Name is a unique name of proxy to reference.
	Name string `mapstructure:"name" json:"name"`
	// Endpoint - HTTP address or GRPC service endpoint.
	Endpoint string `mapstructure:"endpoint" json:"endpoint"`
	// Timeout for proxy request.
	Timeout tools.Duration `mapstructure:"timeout" json:"timeout,omitempty"`

	// HTTPHeaders is a list of HTTP headers to proxy.  No headers used by proxy by default.
	// If GRPC proxy is used then request HTTP headers set to outgoing request metadata.
	HttpHeaders []string `mapstructure:"http_headers" json:"http_headers,omitempty"`
	// GRPCMetadata is a list of GRPC metadata keys to proxy. No meta keys used by proxy by
	// default. If HTTP proxy is used then these keys become outgoing request HTTP headers.
	GrpcMetadata []string `mapstructure:"grpc_metadata" json:"grpc_metadata,omitempty"`

	// BinaryEncoding makes proxy send data as base64 string (assuming it contains custom
	// non-JSON payload).
	BinaryEncoding bool `mapstructure:"binary_encoding" json:"binary_encoding,omitempty"`
	// IncludeConnectionMeta to each proxy request (except connect where it's obtained).
	IncludeConnectionMeta bool `mapstructure:"include_connection_meta" json:"include_connection_meta,omitempty"`

	// GrpcCertFile is a path to GRPC cert file on disk.
	GrpcCertFile string `mapstructure:"grpc_cert_file" json:"grpc_cert_file,omitempty"`
	// GrpcCredentialsKey is a custom key to add into per-RPC credentials.
	GrpcCredentialsKey string `mapstructure:"grpc_credentials_key" json:"grpc_credentials_key,omitempty"`
	// GrpcCredentialsValue is a custom value for GrpcCredentialsKey.
	GrpcCredentialsValue string `mapstructure:"grpc_credentials_value" json:"grpc_credentials_value,omitempty"`
	// contains filtered or unexported fields
}

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

type PublishHandlerConfig struct {
	Proxies           map[string]PublishProxy
	GranularProxyMode bool
}

type PublishHandlerFunc func(*centrifuge.Client, centrifuge.PublishEvent, rule.ChannelOptions) (centrifuge.PublishReply, error)

type PublishProxy interface {
	ProxyPublish(context.Context, *proxyproto.PublishRequest) (*proxyproto.PublishResponse, error)
	// Protocol for metrics and logging.
	Protocol() string
	// UseBase64 for bytes in requests from Centrifugo to application backend.
	UseBase64() bool
	// IncludeMeta ...
	IncludeMeta() bool
}

type PublishReply struct {
	Result     *PublishResult         `json:"result"`
	Error      *centrifuge.Error      `json:"error"`
	Disconnect *centrifuge.Disconnect `json:"disconnect"`
}

type PublishRequest struct {
	ClientID  string
	UserID    string
	Channel   string
	Data      []byte
	Transport centrifuge.TransportInfo
}

type PublishRequestHTTP struct {
	UserID  string `json:"user"`
	Channel string `json:"channel"`

	Data json.RawMessage `json:"data,omitempty"`
	// Base64Data to proxy binary data.
	Base64Data string `json:"b64data,omitempty"`
	// contains filtered or unexported fields
}

type PublishResult struct {
	Data       json.RawMessage `json:"data"`
	Base64Data string          `json:"b64data"`
}

type RPCData struct {
	Data       json.RawMessage `json:"data"`
	Base64Data string          `json:"b64data"`
}

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

type RPCHandlerConfig struct {
	Proxies           map[string]RPCProxy
	GranularProxyMode bool
}

type RPCHandlerFunc func(*centrifuge.Client, centrifuge.RPCEvent, *rule.Container) (centrifuge.RPCReply, error)

type RPCProxy interface {
	ProxyRPC(context.Context, *proxyproto.RPCRequest) (*proxyproto.RPCResponse, error)
	// Protocol for metrics and logging.
	Protocol() string
	// UseBase64 for bytes in requests from Centrifugo to application backend.
	UseBase64() bool
	// IncludeMeta ...
	IncludeMeta() bool
}

type RPCReply struct {
	Result     *RPCData               `json:"result"`
	Error      *centrifuge.Error      `json:"error"`
	Disconnect *centrifuge.Disconnect `json:"disconnect"`
}

type RPCRequest struct {
	Method    string
	Data      []byte
	ClientID  string
	UserID    string
	Transport centrifuge.TransportInfo
}

type RefreshCredentials struct {
	Expired    bool            `json:"expired"`
	ExpireAt   int64           `json:"expire_at"`
	Info       json.RawMessage `json:"info"`
	Base64Info string          `json:"b64info"`
}

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

type RefreshHandlerConfig struct {
	Proxy RefreshProxy
}

type RefreshHandlerFunc func(*centrifuge.Client, centrifuge.RefreshEvent) (centrifuge.RefreshReply, error)

type RefreshProxy interface {
	ProxyRefresh(context.Context, *proxyproto.RefreshRequest) (*proxyproto.RefreshResponse, error)
	// Protocol for metrics and logging.
	Protocol() string
	// UseBase64 for bytes in requests from Centrifugo to application backend.
	UseBase64() bool
	// IncludeMeta ...
	IncludeMeta() bool
}

type RefreshReply struct {
	Result     *RefreshCredentials    `json:"result"`
	Error      *centrifuge.Error      `json:"error"`
	Disconnect *centrifuge.Disconnect `json:"disconnect"`
}

type RefreshRequest struct {
	ClientID  string
	UserID    string
	Transport centrifuge.TransportInfo
}

type RefreshRequestHTTP struct {
	UserID string `json:"user"`
	// contains filtered or unexported fields
}

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

type SubscribeHandlerConfig struct {
	Proxies           map[string]SubscribeProxy
	GranularProxyMode bool
}

type SubscribeHandlerFunc func(*centrifuge.Client, centrifuge.SubscribeEvent, rule.ChannelOptions) (centrifuge.SubscribeReply, error)

type SubscribeOptionOverride struct {
	// Presence turns on participating in channel presence.
	Presence *BoolValue `json:"presence,omitempty"`
	// JoinLeave enables sending Join and Leave messages for this client in channel.
	JoinLeave *BoolValue `json:"join_leave,omitempty"`
	// Position on says that client will additionally sync its position inside
	// a stream to prevent message loss. Make sure you are enabling Position in channels
	// that maintain Publication history stream. When Position is on  Centrifuge will
	// include StreamPosition information to subscribe response - for a client to be able
	// to manually track its position inside a stream.
	Position *BoolValue `json:"position,omitempty"`
	// Recover turns on recovery option for a channel. In this case client will try to
	// recover missed messages automatically upon resubscribe to a channel after reconnect
	// to a server. This option also enables client position tracking inside a stream
	// (like Position option) to prevent occasional message loss. Make sure you are using
	// Recover in channels that maintain Publication history stream.
	Recover *BoolValue `json:"recover,omitempty"`
}

type SubscribeOptions struct {
	// ExpireAt defines time in future when subscription should expire,
	// zero value means no expiration.
	ExpireAt int64 `json:"expire_at,omitempty"`
	// Info defines custom channel information, zero value means no channel information.
	Info json.RawMessage `json:"info,omitempty"`
	// Base64Info is like Info but for binary.
	Base64Info string `json:"b64info,omitempty"`
	// Data to send to a client with Subscribe Push.
	Data json.RawMessage `json:"data,omitempty"`
	// Base64Data is like Data but for binary data.
	Base64Data string `json:"b64data,omitempty"`
	// Override channel options can contain channel options overrides.
	Override *SubscribeOptionOverride `json:"override,omitempty"`
}

type SubscribeProxy interface {
	ProxySubscribe(context.Context, *proxyproto.SubscribeRequest) (*proxyproto.SubscribeResponse, error)
	// Protocol for metrics and logging.
	Protocol() string
	// UseBase64 for bytes in requests from Centrifugo to application backend.
	UseBase64() bool
	// IncludeMeta ...
	IncludeMeta() bool
}

type SubscribeReply struct {
	Result     *SubscribeResult       `json:"result"`
	Error      *centrifuge.Error      `json:"error"`
	Disconnect *centrifuge.Disconnect `json:"disconnect"`
}

type SubscribeRequest struct {
	ClientID  string
	UserID    string
	Channel   string
	Transport centrifuge.TransportInfo
	Token     string
}

type SubscribeResult struct {
	SubscribeOptions
}