Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

proxy

package

Go to main page

Versions in this module

v4

v4.1.5

Jun 24, 2023

v4.1.4

Jun 14, 2023

v4.1.3

Apr 19, 2023

v4.1.2

Jan 11, 2023

v4.1.1

Jan 10, 2023

Changes in this version

+ type GRPCSubRefreshProxy struct

+ func NewGRPCSubRefreshProxy(p Proxy) (*GRPCSubRefreshProxy, error)

+ func (p *GRPCSubRefreshProxy) IncludeMeta() bool

+ func (p *GRPCSubRefreshProxy) Protocol() string

+ func (p *GRPCSubRefreshProxy) ProxySubRefresh(ctx context.Context, req *proxyproto.SubRefreshRequest) (*proxyproto.SubRefreshResponse, error)

+ func (p *GRPCSubRefreshProxy) UseBase64() bool

+ type HTTPSubRefreshProxy struct

+ func NewHTTPSubRefreshProxy(p Proxy) (*HTTPSubRefreshProxy, error)

+ func (p *HTTPSubRefreshProxy) IncludeMeta() bool

+ func (p *HTTPSubRefreshProxy) Protocol() string

+ func (p *HTTPSubRefreshProxy) ProxySubRefresh(ctx context.Context, req *proxyproto.SubRefreshRequest) (*proxyproto.SubRefreshResponse, error)

+ func (p *HTTPSubRefreshProxy) UseBase64() bool

+ type SubRefreshExtra struct

+ type SubRefreshHandler struct

+ func NewSubRefreshHandler(c SubRefreshHandlerConfig) *SubRefreshHandler

+ func (h *SubRefreshHandler) Handle(node *centrifuge.Node) SubRefreshHandlerFunc

+ type SubRefreshHandlerConfig struct

+ GranularProxyMode bool

+ Proxies map[string]SubRefreshProxy

+ type SubRefreshHandlerFunc func(Client, centrifuge.SubRefreshEvent, rule.ChannelOptions, PerCallData) (centrifuge.SubRefreshReply, SubRefreshExtra, error)

+ type SubRefreshProxy interface

+ IncludeMeta func() bool

+ Protocol func() string

+ ProxySubRefresh func(context.Context, *proxyproto.SubRefreshRequest) (*proxyproto.SubRefreshResponse, error)

+ UseBase64 func() bool

+ func GetSubRefreshProxy(p Proxy) (SubRefreshProxy, error)

+ type SubRefreshRequestHTTP struct

+ Channel string

+ UserID string

v4.1.0

Dec 19, 2022

v4.0.5

Dec 14, 2022

v4.0.4

Nov 10, 2022

v4.0.3

Oct 24, 2022

v4.0.2

Oct 17, 2022

v4.0.1

Aug 25, 2022

Changes in this version

+ type Client interface

+ Context func() context.Context

+ ID func() string

+ Transport func() centrifuge.TransportInfo

+ UserID func() string

v4.0.0

Jul 20, 2022

Changes in this version

+ const DefaultMaxIdleConnsPerHost

+ type BoolValue struct

+ Value bool

+ type ConnectCredentials struct

+ Base64Data string

+ Base64Info string

+ Channels []string

+ Data json.RawMessage

+ ExpireAt int64

+ Info json.RawMessage

+ Subs map[string]SubscribeOptions

+ UserID string

+ type ConnectExtra struct

+ type ConnectHandler struct

+ func NewConnectHandler(c ConnectHandlerConfig, ruleContainer *rule.Container) *ConnectHandler

+ func (h *ConnectHandler) Handle(node *centrifuge.Node) ConnectingHandlerFunc

+ type ConnectHandlerConfig struct

+ Proxy ConnectProxy

+ type ConnectProxy interface

+ Protocol func() string

+ ProxyConnect func(context.Context, *proxyproto.ConnectRequest) (*proxyproto.ConnectResponse, error)

+ UseBase64 func() bool

+ func GetConnectProxy(p Proxy) (ConnectProxy, error)

+ type ConnectReply struct

+ Disconnect *centrifuge.Disconnect

+ Error *centrifuge.Error

+ Result *ConnectCredentials

+ type ConnectRequest struct

+ ClientID string

+ Data []byte

+ Name string

+ Transport centrifuge.TransportInfo

+ Version string

+ type ConnectingHandlerFunc func(context.Context, centrifuge.ConnectEvent) (centrifuge.ConnectReply, ConnectExtra, error)

+ type GRPCConnectProxy struct

+ func NewGRPCConnectProxy(p Proxy) (*GRPCConnectProxy, error)

+ func (p *GRPCConnectProxy) Protocol() string

+ func (p *GRPCConnectProxy) ProxyConnect(ctx context.Context, req *proxyproto.ConnectRequest) (*proxyproto.ConnectResponse, error)

+ func (p *GRPCConnectProxy) UseBase64() bool

+ type GRPCPublishProxy struct

+ func NewGRPCPublishProxy(p Proxy) (*GRPCPublishProxy, error)

+ func (p *GRPCPublishProxy) IncludeMeta() bool

+ func (p *GRPCPublishProxy) Protocol() string

+ func (p *GRPCPublishProxy) ProxyPublish(ctx context.Context, req *proxyproto.PublishRequest) (*proxyproto.PublishResponse, error)

+ func (p *GRPCPublishProxy) UseBase64() bool

+ type GRPCRPCProxy struct

+ func NewGRPCRPCProxy(p Proxy) (*GRPCRPCProxy, error)

+ func (p *GRPCRPCProxy) IncludeMeta() bool

+ func (p *GRPCRPCProxy) Protocol() string

+ func (p *GRPCRPCProxy) ProxyRPC(ctx context.Context, req *proxyproto.RPCRequest) (*proxyproto.RPCResponse, error)

+ func (p *GRPCRPCProxy) UseBase64() bool

+ type GRPCRefreshProxy struct

+ func NewGRPCRefreshProxy(p Proxy) (*GRPCRefreshProxy, error)

+ func (p *GRPCRefreshProxy) IncludeMeta() bool

+ func (p *GRPCRefreshProxy) Protocol() string

+ func (p *GRPCRefreshProxy) ProxyRefresh(ctx context.Context, req *proxyproto.RefreshRequest) (*proxyproto.RefreshResponse, error)

+ func (p *GRPCRefreshProxy) UseBase64() bool

+ type GRPCSubscribeProxy struct

+ func NewGRPCSubscribeProxy(p Proxy) (*GRPCSubscribeProxy, error)

+ func (p *GRPCSubscribeProxy) IncludeMeta() bool

+ func (p *GRPCSubscribeProxy) Protocol() string

+ func (p *GRPCSubscribeProxy) ProxySubscribe(ctx context.Context, req *proxyproto.SubscribeRequest) (*proxyproto.SubscribeResponse, error)

+ func (p *GRPCSubscribeProxy) UseBase64() bool

+ type HTTPCaller interface

+ CallHTTP func(context.Context, string, http.Header, []byte) ([]byte, error)

+ func NewHTTPCaller(httpClient *http.Client) HTTPCaller

+ type HTTPConnectProxy struct

+ func NewHTTPConnectProxy(p Proxy) (*HTTPConnectProxy, error)

+ func (p *HTTPConnectProxy) Protocol() string

+ func (p *HTTPConnectProxy) ProxyConnect(ctx context.Context, req *proxyproto.ConnectRequest) (*proxyproto.ConnectResponse, error)

+ func (p *HTTPConnectProxy) UseBase64() bool

+ type HTTPPublishProxy struct

+ func NewHTTPPublishProxy(p Proxy) (*HTTPPublishProxy, error)

+ func (p *HTTPPublishProxy) IncludeMeta() bool

+ func (p *HTTPPublishProxy) Protocol() string

+ func (p *HTTPPublishProxy) ProxyPublish(ctx context.Context, req *proxyproto.PublishRequest) (*proxyproto.PublishResponse, error)

+ func (p *HTTPPublishProxy) UseBase64() bool

+ type HTTPRPCProxy struct

+ func NewHTTPRPCProxy(p Proxy) (*HTTPRPCProxy, error)

+ func (p *HTTPRPCProxy) IncludeMeta() bool

+ func (p *HTTPRPCProxy) Protocol() string

+ func (p *HTTPRPCProxy) ProxyRPC(ctx context.Context, req *proxyproto.RPCRequest) (*proxyproto.RPCResponse, error)

+ func (p *HTTPRPCProxy) UseBase64() bool

+ type HTTPRefreshProxy struct

+ func NewHTTPRefreshProxy(p Proxy) (*HTTPRefreshProxy, error)

+ func (p *HTTPRefreshProxy) IncludeMeta() bool

+ func (p *HTTPRefreshProxy) Protocol() string

+ func (p *HTTPRefreshProxy) ProxyRefresh(ctx context.Context, req *proxyproto.RefreshRequest) (*proxyproto.RefreshResponse, error)

+ func (p *HTTPRefreshProxy) UseBase64() bool

+ type HTTPSubscribeProxy struct

+ func NewHTTPSubscribeProxy(p Proxy) (*HTTPSubscribeProxy, error)

+ func (p *HTTPSubscribeProxy) IncludeMeta() bool

+ func (p *HTTPSubscribeProxy) Protocol() string

+ func (p *HTTPSubscribeProxy) ProxySubscribe(ctx context.Context, req *proxyproto.SubscribeRequest) (*proxyproto.SubscribeResponse, error)

+ func (p *HTTPSubscribeProxy) UseBase64() bool

+ type PerCallData struct

+ Meta json.RawMessage

+ type Proxy struct

+ BinaryEncoding bool

+ Endpoint string

+ GrpcCertFile string

+ GrpcCredentialsKey string

+ GrpcCredentialsValue string

+ GrpcMetadata []string

+ HttpHeaders []string

+ IncludeConnectionMeta bool

+ Name string

+ Timeout tools.Duration

+ type PublishHandler struct

+ func NewPublishHandler(c PublishHandlerConfig) *PublishHandler

+ func (h *PublishHandler) Handle(node *centrifuge.Node) PublishHandlerFunc

+ type PublishHandlerConfig struct

+ GranularProxyMode bool

+ Proxies map[string]PublishProxy

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

+ type PublishProxy interface

+ IncludeMeta func() bool

+ Protocol func() string

+ ProxyPublish func(context.Context, *proxyproto.PublishRequest) (*proxyproto.PublishResponse, error)

+ UseBase64 func() bool

+ func GetPublishProxy(p Proxy) (PublishProxy, error)

+ type PublishReply struct

+ Disconnect *centrifuge.Disconnect

+ Error *centrifuge.Error

+ Result *PublishResult

+ type PublishRequest struct

+ Channel string

+ ClientID string

+ Data []byte

+ Transport centrifuge.TransportInfo

+ UserID string

+ type PublishRequestHTTP struct

+ Base64Data string

+ Channel string

+ Data json.RawMessage

+ UserID string

+ type PublishResult struct

+ Base64Data string

+ Data json.RawMessage

+ type RPCData struct

+ Base64Data string

+ Data json.RawMessage

+ type RPCHandler struct

+ func NewRPCHandler(c RPCHandlerConfig) *RPCHandler

+ func (h *RPCHandler) Handle(node *centrifuge.Node) RPCHandlerFunc

+ type RPCHandlerConfig struct

+ GranularProxyMode bool

+ Proxies map[string]RPCProxy

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

+ type RPCProxy interface

+ IncludeMeta func() bool

+ Protocol func() string

+ ProxyRPC func(context.Context, *proxyproto.RPCRequest) (*proxyproto.RPCResponse, error)

+ UseBase64 func() bool

+ func GetRpcProxy(p Proxy) (RPCProxy, error)

+ type RPCReply struct

+ Disconnect *centrifuge.Disconnect

+ Error *centrifuge.Error

+ Result *RPCData

+ type RPCRequest struct

+ ClientID string

+ Data []byte

+ Method string

+ Transport centrifuge.TransportInfo

+ UserID string

+ type RefreshCredentials struct

+ Base64Info string

+ ExpireAt int64

+ Expired bool

+ Info json.RawMessage

+ type RefreshExtra struct

+ Meta json.RawMessage

+ type RefreshHandler struct

+ func NewRefreshHandler(c RefreshHandlerConfig) *RefreshHandler

+ func (h *RefreshHandler) Handle(node *centrifuge.Node) RefreshHandlerFunc

+ type RefreshHandlerConfig struct

+ Proxy RefreshProxy

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

+ type RefreshProxy interface

+ IncludeMeta func() bool

+ Protocol func() string

+ ProxyRefresh func(context.Context, *proxyproto.RefreshRequest) (*proxyproto.RefreshResponse, error)

+ UseBase64 func() bool

+ func GetRefreshProxy(p Proxy) (RefreshProxy, error)

+ type RefreshReply struct

+ Disconnect *centrifuge.Disconnect

+ Error *centrifuge.Error

+ Result *RefreshCredentials

+ type RefreshRequest struct

+ ClientID string

+ Transport centrifuge.TransportInfo

+ UserID string

+ type RefreshRequestHTTP struct

+ UserID string

+ type SubscribeExtra struct

+ type SubscribeHandler struct

+ func NewSubscribeHandler(c SubscribeHandlerConfig) *SubscribeHandler

+ func (h *SubscribeHandler) Handle(node *centrifuge.Node) SubscribeHandlerFunc

+ type SubscribeHandlerConfig struct

+ GranularProxyMode bool

+ Proxies map[string]SubscribeProxy

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

+ type SubscribeOptionOverride struct

+ JoinLeave *BoolValue

+ Position *BoolValue

+ Presence *BoolValue

+ Recover *BoolValue

+ type SubscribeOptions struct

+ Base64Data string

+ Base64Info string

+ Data json.RawMessage

+ ExpireAt int64

+ Info json.RawMessage

+ Override *SubscribeOptionOverride

+ type SubscribeProxy interface

+ IncludeMeta func() bool

+ Protocol func() string

+ ProxySubscribe func(context.Context, *proxyproto.SubscribeRequest) (*proxyproto.SubscribeResponse, error)

+ UseBase64 func() bool

+ func GetSubscribeProxy(p Proxy) (SubscribeProxy, error)

+ type SubscribeReply struct

+ Disconnect *centrifuge.Disconnect

+ Error *centrifuge.Error

+ Result *SubscribeResult

+ type SubscribeRequest struct

+ Channel string

+ ClientID string

+ Token string

+ Transport centrifuge.TransportInfo

+ UserID string

+ type SubscribeResult struct

v4.0.0-beta.1

Jul 9, 2022

Other modules containing this package

github.com/centrifugal/centrifugo

github.com/centrifugal/centrifugo/v3

github.com/centrifugal/centrifugo/v5