proxycore

package

Go to main page

Versions in this module

v0

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