proxycore

package

Go to main page

Versions in this module

v0

v0.1.6

Jul 30, 2024

v0.1.5

Jan 27, 2024

v0.1.4

Jan 5, 2023

v0.1.3

May 6, 2022

Changes in this version

+ var ColumnIsNull = errors.New("column is null")

type ClientConn

+ func (c *ClientConn) QueryFrame(ctx context.Context, frm *frame.Frame) (*ResultSet, error)

type ClusterInfo

+ DSEVersion string

type Endpoint

+ func NewEndpointTLS(addr string, cfg *tls.Config) Endpoint

+ TLSConfig func() *tls.Config

type MockCluster

+ DseVersion string

type MockServer

+ DseVersion string

v0.1.2

Mar 30, 2022

Changes in this version

+ var IgnoreEndpoint = errors.New("ignore endpoint")

type ClusterInfo

+ LocalDC string

type Host

+ DC string

type Row

+ func (r Row) InetByName(n string) (net.IP, error)

+ func (r Row) StringByName(n string) (string, error)

+ func (r Row) UUIDByName(n string) (primitive.UUID, error)

v0.1.1

Feb 15, 2022

v0.1.0

Feb 15, 2022

Changes in this version

type Cluster

+ func (c *Cluster) OutageDuration() time.Duration

type CqlError

+ Message message.Error

+ type Event interface

+ type UpEvent struct

+ Host *Host

v0.0.4

Dec 7, 2021

Changes in this version

+ const DefaultConnectTimeout

+ const DefaultRefreshTimeout

+ const DefaultRefreshWindow

+ const MaxCoalesceSize

+ const MaxMessages

+ const MaxStreams

+ var AlreadyClosed = errors.New("connection already closed")

+ var AuthExpected = errors.New("authentication required, but no authenticator provided")

+ var Closed = errors.New("connection closed")

+ var ColumnNameNotFound = errors.New("column name not found")

+ var DefaultMockRequestHandlers = MockRequestHandlers

+ var NoConnForHost = errors.New("no connection available for host")

+ var ProtocolNotSupported = errors.New("required protocol version is not supported")

+ var StreamsExhausted = errors.New("streams exhausted")

+ func DecodeType(dt datatype.DataType, version primitive.ProtocolVersion, bytes []byte) (interface{}, error)

+ func EncodeType(dt datatype.DataType, version primitive.ProtocolVersion, val interface{}) ([]byte, error)

+ func GetOrCreateNopLogger(logger *zap.Logger) *zap.Logger

+ func LookupEndpoint(endpoint Endpoint) (string, error)

+ func MockDefaultOptionsHandler(_ *MockClient, _ *frame.Frame) message.Message

+ func MockDefaultQueryHandler(cl *MockClient, frm *frame.Frame) message.Message

+ func MockDefaultRegisterHandler(cl *MockClient, frm *frame.Frame) message.Message

+ func MockDefaultStartupHandler(_ *MockClient, _ *frame.Frame) message.Message

+ type AddEvent struct

+ Host *Host

+ type Authenticator interface

+ EvaluateChallenge func(token []byte) ([]byte, error)

+ InitialResponse func(authenticator string) ([]byte, error)

+ Success func(token []byte) error

+ func NewPasswordAuth(username string, password string) Authenticator

+ type BootstrapEvent struct

+ Hosts []*Host

+ type ClientConn struct

+ func ConnectClient(ctx context.Context, endpoint Endpoint, config ClientConnConfig) (*ClientConn, error)

+ func (c *ClientConn) Close() error

+ func (c *ClientConn) Closing(err error)

+ func (c *ClientConn) Err() error

+ func (c *ClientConn) Handshake(ctx context.Context, version primitive.ProtocolVersion, auth Authenticator) (primitive.ProtocolVersion, error)

+ func (c *ClientConn) Heartbeats(connectTimeout time.Duration, version primitive.ProtocolVersion, ...)

+ func (c *ClientConn) Inflight() int32

+ func (c *ClientConn) IsClosed() chan struct{}

+ func (c *ClientConn) Query(ctx context.Context, version primitive.ProtocolVersion, query *message.Query) (*ResultSet, error)

+ func (c *ClientConn) Receive(reader io.Reader) error

+ func (c *ClientConn) Send(request Request) error

+ func (c *ClientConn) SendAndReceive(ctx context.Context, f *frame.Frame) (*frame.Frame, error)

+ func (c *ClientConn) SetKeyspace(ctx context.Context, version primitive.ProtocolVersion, keyspace string) error

+ type ClientConnConfig struct

+ Handler EventHandler

+ Logger *zap.Logger

+ PreparedCache PreparedCache

+ type Cluster struct

+ Info ClusterInfo

+ NegotiatedVersion primitive.ProtocolVersion

+ func ConnectCluster(ctx context.Context, config ClusterConfig) (*Cluster, error)

+ func (c *Cluster) Listen(listener ClusterListener) error

+ func (c *Cluster) OnEvent(frame *frame.Frame)

+ type ClusterConfig struct

+ Auth Authenticator

+ ConnectTimeout time.Duration

+ HeartBeatInterval time.Duration

+ IdleTimeout time.Duration

+ Logger *zap.Logger

+ ReconnectPolicy ReconnectPolicy

+ RefreshTimeout time.Duration

+ RefreshWindow time.Duration

+ Resolver EndpointResolver

+ Version primitive.ProtocolVersion

+ type ClusterInfo struct

+ CQLVersion string

+ Partitioner string

+ ReleaseVersion string

+ type ClusterListener interface

+ OnEvent func(event interface{})

+ type ClusterListenerFunc func(event interface{})

+ func (f ClusterListenerFunc) OnEvent(event interface{})

+ type Conn struct

+ func Connect(ctx context.Context, endpoint Endpoint, recv Receiver) (c *Conn, err error)

+ func NewConn(conn net.Conn, recv Receiver) *Conn

+ func (c *Conn) Close() error

+ func (c *Conn) Err() error

+ func (c *Conn) IsClosed() chan struct{}

+ func (c *Conn) LocalAddr() net.Addr

+ func (c *Conn) RemoteAddr() net.Addr

+ func (c *Conn) Start()

+ func (c *Conn) Write(sender Sender) error

+ func (c *Conn) WriteBytes(b []byte) error

+ type CqlError struct

+ func (e CqlError) Error() string

+ type Endpoint interface

+ Addr func() string

+ IsResolved func() bool

+ Key func() string

+ TlsConfig func() *tls.Config

+ func NewEndpoint(addr string) Endpoint

+ type EndpointResolver interface

+ NewEndpoint func(row Row) (Endpoint, error)

+ Resolve func() ([]Endpoint, error)

+ func NewResolver(contactPoints ...string) EndpointResolver

+ func NewResolverWithDefaultPort(contactPoints []string, defaultPort int) EndpointResolver

+ type EventHandler interface

+ OnEvent func(frm *frame.Frame)

+ type EventHandlerFunc func(frm *frame.Frame)

+ func (f EventHandlerFunc) OnEvent(frm *frame.Frame)

+ type Host struct

+ func NewHostFromRow(endpoint Endpoint, _ Row) (*Host, error)

+ func (h *Host) Endpoint() Endpoint

+ func (h *Host) Key() string

+ func (h *Host) String() string

+ type LoadBalancer interface

+ NewQueryPlan func() QueryPlan

+ func NewRoundRobinLoadBalancer() LoadBalancer

+ type MockClient struct

+ func (c *MockClient) InterceptQuery(hdr *frame.Header, msg *message.Query) message.Message

+ func (c *MockClient) Receive(reader io.Reader) error

+ func (c *MockClient) Register(version primitive.ProtocolVersion)

+ func (c MockClient) Closing(_ error)

+ func (c MockClient) Keyspace() string

+ func (c MockClient) Local() MockHost

+ type MockCluster struct

+ Handlers map[primitive.OpCode]MockRequestHandler

+ func NewMockCluster(startIP net.IP, port int) *MockCluster

+ func (c *MockCluster) Add(ctx context.Context, n int) error

+ func (c *MockCluster) Remove(n int)

+ func (c *MockCluster) Shutdown()

+ func (c *MockCluster) Start(ctx context.Context, n int) error

+ func (c *MockCluster) Stop(n int)

+ type MockHost struct

+ HostID *primitive.UUID

+ IP string

+ Port int

+ func (h MockHost) String() string

+ type MockRequestHandler func(client *MockClient, frm *frame.Frame) message.Message

+ type MockRequestHandlers map[primitive.OpCode]MockRequestHandler

+ func NewMockRequestHandlers(overrides MockRequestHandlers) MockRequestHandlers

+ type MockServer struct

+ Handlers map[primitive.OpCode]MockRequestHandler

+ func (s *MockServer) Add(host MockHost)

+ func (s *MockServer) Event(evt message.Event)

+ func (s *MockServer) Remove(host MockHost)

+ func (s *MockServer) Serve(ctx context.Context, maxVersion primitive.ProtocolVersion, local MockHost, ...) error

+ func (s *MockServer) Shutdown()

+ type PreparedCache interface

+ Load func(id string) (entry *PreparedEntry, ok bool)

+ Store func(id string, entry *PreparedEntry)

+ type PreparedEntry struct

+ PreparedFrame *frame.RawFrame

+ type QueryPlan interface

+ Next func() *Host

+ type Receiver interface

+ Closing func(err error)

+ Receive func(reader io.Reader) error

+ type ReconnectEvent struct

+ type ReconnectPolicy interface

+ Clone func() ReconnectPolicy

+ NextDelay func() time.Duration

+ Reset func()

+ func NewReconnectPolicy() ReconnectPolicy

+ func NewReconnectPolicyWithDelays(baseDelay, maxDelay time.Duration) ReconnectPolicy

+ type RemoveEvent struct

+ Host *Host

+ type Request interface

+ Execute func(next bool)

+ Frame func() interface{}

+ OnClose func(err error)

+ OnResult func(raw *frame.RawFrame)

+ type ResultSet struct

+ func NewResultSet(rows *message.RowsResult, version primitive.ProtocolVersion) *ResultSet

+ func (rs *ResultSet) Row(i int) Row

+ func (rs ResultSet) RowCount() int

+ type Row struct

+ func (r Row) ByName(n string) (interface{}, error)

+ func (r Row) ByPos(i int) (interface{}, error)

+ type SchemaChangeEvent struct

+ Message *message.SchemaChangeEvent

+ type Sender interface

+ Send func(writer io.Writer) error

+ type SenderFunc func(writer io.Writer) error

+ func (s SenderFunc) Send(writer io.Writer) error

+ type Session struct

+ func ConnectSession(ctx context.Context, cluster *Cluster, config SessionConfig) (*Session, error)

+ func (s *Session) OnEvent(event interface{})

+ func (s *Session) Send(host *Host, request Request) error

+ type SessionConfig struct

+ Auth Authenticator

+ ConnectTimeout time.Duration

+ HeartBeatInterval time.Duration

+ IdleTimeout time.Duration

+ Keyspace string

+ Logger *zap.Logger

+ NumConns int

+ PreparedCache PreparedCache

+ ReconnectPolicy ReconnectPolicy

+ Version primitive.ProtocolVersion

+ type UnexpectedResponse struct

+ Expected []string

+ Received string

+ func (e *UnexpectedResponse) Error() string

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL