server

package
v0.14.7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 21, 2023 License: Apache-2.0 Imports: 31 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	// QueryCounter describes a metric that accumulates number of queries monotonically.
	QueryCounter = discard.NewCounter()

	// QueryErrorCounter describes a metric that accumulates number of failed queries monotonically.
	QueryErrorCounter = discard.NewCounter()

	// QueryHistogram describes a queries latency.
	QueryHistogram = discard.NewHistogram()
)
View Source 
var ErrConnectionWasClosed = errors.NewKind("connection was closed")

ErrConnectionWasClosed will be returned if we try to use a previously closed connection

View Source 
var ErrRowTimeout = errors.NewKind("row read wait bigger than connection timeout")

ErrRowTimeout will be returned if the wait for the row is longer than the connection timeout

View Source 
var ErrUnsupportedOperation = errors.NewKind("unsupported operation")
View Source 
var UnixSocketInUseError = errors.New("bind address at given unix socket path is already in use")

Functions

func DefaultSessionBuilder 

func DefaultSessionBuilder(ctx context.Context, c *mysql.Conn, addr string) (sql.Session, error)

DefaultSessionBuilder is a SessionBuilder that returns a base session.

Types

type Config 

type Config struct {
	// Protocol for the connection.
	Protocol string
	// Address of the server.
	Address string
	// Tracer to use in the server. By default, a noop tracer will be used if
	// no tracer is provided.
	Tracer trace.Tracer
	// Version string to advertise in running server
	Version string
	// ConnReadTimeout is the server's read timeout
	ConnReadTimeout time.Duration
	// ConnWriteTimeout is the server's write timeout
	ConnWriteTimeout time.Duration
	// MaxConnections is the maximum number of simultaneous connections that the server will allow.
	MaxConnections uint64
	// TLSConfig is the configuration for TLS on this server. If |nil|, TLS is not supported.
	TLSConfig *tls.Config
	// RequestSecureTransport will require incoming connections to be TLS. Requires non-|nil| TLSConfig.
	RequireSecureTransport bool
	// DisableClientMultiStatements will prevent processing of incoming
	// queries as if they contain more than one query. This processing
	// currently works in some simple cases, but breaks in the presence of
	// statements (such as in CREATE TRIGGER queries). Configuring the
	// server to disable processing these is one option for users to get
	// support back for single queries that contain statements, at the cost
	// of not supporting the CLIENT_MULTI_STATEMENTS option on the server.
	DisableClientMultiStatements bool
	// NoDefaults prevents using persisted configuration for new server sessions
	NoDefaults bool
	// Socket is a path to unix socket file
	Socket                   string
	AllowClearTextWithoutTLS bool
	// MaxLoggedQueryLen sets the length at which queries written to the logs are truncated.  A value of 0 will
	// result in no truncation. A value less than 0 will result in the queries being omitted from the logs completely
	MaxLoggedQueryLen int
}

Config for the mysql server.

func (Config) NewConfig 

func (c Config) NewConfig() (Config, error)

type DoneFunc 

type DoneFunc func()

DoneFunc is a function that must be executed when the session is used and it can be disposed.

type Handler 

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

Handler is a connection handler for a SQLe engine, implementing the Vitess mysql.Handler interface.

func NewHandler 

func NewHandler(e *sqle.Engine, sm *SessionManager, rt time.Duration, disableMultiStmts bool, maxLoggedQueryLen int, listener ServerEventListener) *Handler

NewHandler creates a new Handler given a SQLe engine.

func (*Handler) ComInitDB 

func (h *Handler) ComInitDB(c *mysql.Conn, schemaName string) error

func (*Handler) ComMultiQuery 

func (h *Handler) ComMultiQuery(
	c *mysql.Conn,
	query string,
	callback func(*sqltypes.Result, bool) error,
) (string, error)

func (*Handler) ComPrepare 

func (h *Handler) ComPrepare(c *mysql.Conn, query string) ([]*query.Field, error)

ComPrepare parses, partially analyzes, and caches a prepared statement's plan with the given [c.ConnectionID].

func (*Handler) ComQuery 

func (h *Handler) ComQuery(
	c *mysql.Conn,
	query string,
	callback func(*sqltypes.Result, bool) error,
) error

ComQuery executes a SQL query on the SQLe engine.

func (*Handler) ComResetConnection 

func (h *Handler) ComResetConnection(c *mysql.Conn)

func (*Handler) ComStmtExecute 

func (h *Handler) ComStmtExecute(c *mysql.Conn, prepare *mysql.PrepareData, callback func(*sqltypes.Result) error) error

func (*Handler) ConnectionClosed 

func (h *Handler) ConnectionClosed(c *mysql.Conn)

ConnectionClosed reports that a connection has been closed.

func (*Handler) NewConnection 

func (h *Handler) NewConnection(c *mysql.Conn)

NewConnection reports that a new connection has been established.

func (*Handler) WarningCount 

func (h *Handler) WarningCount(c *mysql.Conn) uint16

WarningCount is called at the end of each query to obtain the value to be returned to the client in the EOF packet. Note that this will be called either in the context of the ComQuery callback if the result does not contain any fields, or after the last ComQuery call completes.

type Listener 

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

Listener implements a single listener with two net.Listener, one for TCP socket and another for unix socket connections.

func NewListener 

func NewListener(protocol, address string, unixSocketPath string) (*Listener, error)

NewListener creates a new Listener. 'protocol' takes "tcp" and 'address' takes "host:port" information for TCP socket connection. For unix socket connection, 'unixSocketPath' takes a path for the unix socket file. If 'unixSocketPath' is empty, no need to create the second listener.

func (*Listener) Accept 

func (l *Listener) Accept() (net.Conn, error)

func (*Listener) Addr 

func (l *Listener) Addr() net.Addr

func (*Listener) Close 

func (l *Listener) Close() error

type MultiStmtMode 

type MultiStmtMode int
const (
	MultiStmtModeOff MultiStmtMode = 0
	MultiStmtModeOn  MultiStmtMode = 1
)

type Server 

type Server struct {
	Listener *mysql.Listener

	Engine *gms.Engine
	// contains filtered or unexported fields
}

Server is a MySQL server for SQLe engines.

func NewDefaultServer 

func NewDefaultServer(cfg Config, e *sqle.Engine) (*Server, error)

NewDefaultServer creates a Server with the default session builder.

func NewServer 

func NewServer(cfg Config, e *sqle.Engine, sb SessionBuilder, listener ServerEventListener) (*Server, error)

NewServer creates a server with the given protocol, address, authentication details given a SQLe engine and a session builder.

func NewValidatingServer 

func NewValidatingServer(
	cfg Config,
	e *sqle.Engine,
	sb SessionBuilder,
	listener ServerEventListener,
	mySqlConn string,
) (*Server, error)

NewValidatingServer creates a Server that validates its query results using a MySQL connection as a source of golden-value query result sets.

func (*Server) Close 

func (s *Server) Close() error

Close closes the server connection.

func (*Server) SessionManager 

func (s *Server) SessionManager() *SessionManager

SessionManager returns the session manager for this server.

func (*Server) Start 

func (s *Server) Start() error

Start starts accepting connections on the server.

type ServerEventListener 

type ServerEventListener interface {
	ClientConnected()
	ClientDisconnected()
	QueryStarted()
	QueryCompleted(success bool, duration time.Duration)
}

type SessionBuilder 

type SessionBuilder func(ctx context.Context, conn *mysql.Conn, addr string) (sql.Session, error)

SessionBuilder creates sessions given a MySQL connection and a server address.

type SessionManager 

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

SessionManager is in charge of creating new sessions for the given connections and keep track of which sessions are in each connection, so they can be cancelled if the connection is closed.

func NewSessionManager 

func NewSessionManager(
	builder SessionBuilder,
	tracer trace.Tracer,
	hasDBFunc func(ctx *sql.Context, name string) bool,
	memory *sql.MemoryManager,
	processlist sql.ProcessList,
	addr string,
) *SessionManager

NewSessionManager creates a SessionManager with the given SessionBuilder.

func (*SessionManager) AddConn 

func (s *SessionManager) AddConn(conn *mysql.Conn)

Add a connection to be tracked by the SessionManager. Should be called as soon as possible after the server has accepted the connection. Results in the connection being tracked by ProcessList and being available through KillConnection. The connection will be tracked until RemoveConn is called, so clients should ensure a call to AddConn is always paired up with a call to RemoveConn.

func (*SessionManager) Iter 

func (s *SessionManager) Iter(f func(session sql.Session) (stop bool, err error)) error

Iter iterates over the active sessions and executes the specified callback function on each one.

func (*SessionManager) KillConnection 

func (s *SessionManager) KillConnection(connID uint32) error

Exposed through (*sql.Context).Services.KillConnection. Calls Close on the tracked connection with |connID|. The full teardown of the connection is asychronous, similar to how |Process.Kill| for tearing down an inflight query is asynchronous. The connection and any running query will remain in the ProcessList and in the SessionManager until it has been torn down by the server handler.

func (*SessionManager) NewContext 

func (s *SessionManager) NewContext(conn *mysql.Conn) (*sql.Context, error)

NewContext creates a new context for the session at the given conn.

func (*SessionManager) NewContextWithQuery 

func (s *SessionManager) NewContextWithQuery(conn *mysql.Conn, query string) (*sql.Context, error)

NewContextWithQuery creates a new context for the session at the given conn.

func (*SessionManager) NewSession 

func (s *SessionManager) NewSession(ctx context.Context, conn *mysql.Conn) error

NewSession creates a Session for the given connection and saves it to the session pool.

func (*SessionManager) RemoveConn 

func (s *SessionManager) RemoveConn(conn *mysql.Conn)

Remove the session assosiated with |conn| from the session manager.

func (*SessionManager) SetDB 

func (s *SessionManager) SetDB(conn *mysql.Conn, db string) error

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.