mysqlctl

package
v0.0.0-...-8e4f697 Latest Latest
Warning

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

 Go to latest Published: Jul 19, 2013 License: BSD-3-Clause Imports: 49 Imported by: 0

Documentation

Overview

Copyright 2012, Google Inc. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.

Copyright 2012, Google Inc. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.

Copyright 2012, Google Inc. All rights reserved. Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.

Index

Constants

View Source 
const (
	MAX_TXN_BATCH = 1024
	DML           = "DML"
	DDL           = "DDL"
	BEGIN         = "BEGIN"
	COMMIT        = "COMMIT"
	USE           = "use"
	EOF           = "EOF"
)
View Source 
const (
	FATAL             = "Fatal"
	SERVICE_ERROR     = "Service Error"
	EVENT_ERROR       = "Event Error"
	CODE_ERROR        = "Code Error"
	REPLICATION_ERROR = "Replication Error"
	CONNECTION_ERROR  = "Connection Error"
)

Error types for update stream

View Source 
const (
	BINLOG_HEADER_SIZE = 4  // copied from mysqlbinlog.cc for mysql 5.0.33
	EVENT_HEADER_SIZE  = 19 // 4.0 and above, can be larger in 5.x
	BINLOG_BLOCK_SIZE  = 16 * 1024
	MYSQLBINLOG_CHUNK  = 64 * 1024
	MAX_WAIT_TIMEOUT   = 30.0
	LOG_WAIT_TIMEOUT   = 5.0
)
View Source 
const (
	SlaveStartDeadline = 30
	InvalidLagSeconds  = 0xFFFFFFFF
)
View Source 
const (
	TABLE_BASE_TABLE = "BASE TABLE"
	TABLE_VIEW       = "VIEW"
)
View Source 
const (
	SnapshotURLPath = "/snapshot"

	INSERT_INTO_RECOVERY = `` /* 291-byte string literal not displayed */

)
View Source 
const (
	DISABLED = iota
	ENABLED
)
View Source 
const (
	MysqlWaitTime = 120 * time.Second // default number of seconds to wait
)
View Source 
const (
	SnapshotManifestFile = "snapshot_manifest.json"
)

Variables

View Source 
var (
	STREAM_COMMENT_START   = []byte("/* _stream ")
	BINLOG_DELIMITER       = []byte("/*!*/;")
	BINLOG_POSITION_PREFIX = []byte("# at ")
	BINLOG_ROTATE_TO       = []byte("Rotate to ")
	BINLOG_BEGIN           = []byte("BEGIN")
	BINLOG_COMMIT          = []byte("COMMIT")
	BINLOG_ROLLBACK        = []byte("ROLLBACK")
	BINLOG_SET_TIMESTAMP   = []byte("SET TIMESTAMP=")
	BINLOG_SET_INSERT      = []byte("SET INSERT_ID=")
	BINLOG_END_LOG_POS     = []byte("end_log_pos ")
	BINLOG_XID             = []byte("Xid = ")
	BINLOG_GROUP_ID        = []byte("group_id ")
	BINLOG_START           = []byte("Start: binlog")
	BINLOG_DB_CHANGE       = []byte(USE)
	POS                    = []byte(" pos: ")
	SPACE                  = []byte(" ")
	COMMENT                = []byte("/*!")
	SET_SESSION_VAR        = []byte("SET @@session")
	DELIMITER              = []byte("DELIMITER ")
	BINLOG                 = []byte("BINLOG ")
	SEMICOLON_BYTE         = []byte(";")
)
View Source 
var (
	ErrNotSlave  = errors.New("no slave status")
	ErrNotMaster = errors.New("no master status")
)
View Source 
var DefaultDbaParams = mysql.ConnectionParams{
	Uname:   "vt_dba",
	Charset: "utf8",
}
View Source 
var DefaultReplParams = mysql.ConnectionParams{
	Uname:   "vt_repl",
	Charset: "utf8",
}
View Source 
var SqlKwMap = map[string]string{
	"create":   DDL,
	"alter":    DDL,
	"drop":     DDL,
	"truncate": DDL,
	"rename":   DDL,
	"insert":   DML,
	"update":   DML,
	"delete":   DML,
	"begin":    BEGIN,
	"commit":   COMMIT,
}

Functions

func ConcurrentMap 

func ConcurrentMap(concurrency, n int, fun MapFunc) error

ConcurrentMap applies fun in a concurrent manner on integers from 0 to n-1 (they are assumed to be indexes of some slice containing items to be processed). The first error returned by a fun application will returned (subsequent errors will only be logged). It will use concurrency goroutines.

func DiffPermissions 

func DiffPermissions(leftName string, left *Permissions, rightName string, right *Permissions, er concurrency.ErrorRecorder)

func DiffPermissionsToArray 

func DiffPermissionsToArray(leftName string, left *Permissions, rightName string, right *Permissions) (result []string)

func DiffSchema 

func DiffSchema(leftName string, left *SchemaDefinition, rightName string, right *SchemaDefinition, er concurrency.ErrorRecorder)

generates a report on what's different between two SchemaDefinition for now, we skip the VIEW entirely.

func DiffSchemaToArray 

func DiffSchemaToArray(leftName string, left *SchemaDefinition, rightName string, right *SchemaDefinition) (result []string)

func DirectoryList 

func DirectoryList(cnf *Mycnf) []string

func DisableUpdateStreamService 

func DisableUpdateStreamService()

func EnableUpdateStreamService 

func EnableUpdateStreamService(tabletType string, dbcfgs dbconfigs.DBConfigs)

func GetDmlType 

func GetDmlType(firstKw string) string

func GetSqlType 

func GetSqlType(firstKw string) string

func IgnoredStatement 

func IgnoredStatement(line []byte) bool

func Init 

func Init(mt *Mysqld, mysqlWaitTime time.Duration) error

func IsMasterPositionValid 

func IsMasterPositionValid(startCoordinates *ReplicationCoordinates) bool

func IsRelayPositionValid 

func IsRelayPositionValid(startCoordinates *ReplicationCoordinates, logsDir string) bool

This verifies the correctness of the start position. The seek for relay logs depends on the RelayFilename and correct MasterFilename and Position.

func IsStartPositionValid 

func IsStartPositionValid(startPos *BinlogPosition) bool

func IsTxnStatement 

func IsTxnStatement(line []byte, firstKw string) bool

func IsUpdateStreamEnabled 

func IsUpdateStreamEnabled() bool

func IsUpdateStreamUsingRelayLogs 

func IsUpdateStreamUsingRelayLogs() bool

func LogsDir 

func LogsDir() string

func MakeMycnf 

func MakeMycnf(mycnf *Mycnf, cnfFiles []string) (string, error)

Join cnf files cnfPaths and subsitute in the right values.

func MycnfFile 

func MycnfFile(uid uint32) string

func NewEventBuffer 

func NewEventBuffer(pos *BinlogPosition, line []byte) *eventBuffer

func RegisterUpdateStreamService 

func RegisterUpdateStreamService(mycnf *Mycnf)

func SanityCheckManifests 

func SanityCheckManifests(ssms []*SplitSnapshotManifest) error

SanityCheckManifests checks if the ssms can be restored together.

func SendError 

func SendError(sendReply SendUpdateStreamResponse, inputErr error, blpPos *BinlogPosition)

This sends the error to the client.

func ServeUpdateStream 

func ServeUpdateStream(req *UpdateStreamRequest, sendReply SendUpdateStreamResponse) error

func Shutdown 

func Shutdown(mt *Mysqld, waitForMysqld bool, mysqlWaitTime time.Duration) error
waitForMysqld: should the function block until mysqld has stopped?

This can actually take a *long* time if the buffer cache needs to be fully flushed - on the order of 20-30 minutes.

func SnapshotDir 

func SnapshotDir(uid uint32) string

func Start 

func Start(mt *Mysqld, mysqlWaitTime time.Duration) error

func StartReplicationCommands 

func StartReplicationCommands(mysqld *Mysqld, replState *ReplicationState) ([]string, error)

func StartSplitReplicationCommands 

func StartSplitReplicationCommands(mysqld *Mysqld, replState *ReplicationState, keyRange key.KeyRange) ([]string, error)

func TabletDir 

func TabletDir(uid uint32) string

func Teardown 

func Teardown(mt *Mysqld, force bool) error

func TopLevelDirs 

func TopLevelDirs() []string

Types

type BinlogData 

type BinlogData struct {
	SqlType    string
	Sql        []string
	KeyspaceId string
	IndexType  string
	IndexId    interface{}
	UserId     uint64
}

type BinlogDecoder 

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

func (*BinlogDecoder) DecodeMysqlBinlog 

func (decoder *BinlogDecoder) DecodeMysqlBinlog(binlog *os.File) (io.Reader, error)

return a Reader from which the decoded binlog can be read

func (*BinlogDecoder) Kill 

func (decoder *BinlogDecoder) Kill() error

type BinlogParseError 

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

func NewBinlogParseError 

func NewBinlogParseError(errType, msg string) *BinlogParseError

func (BinlogParseError) Error 

func (err BinlogParseError) Error() string

func (*BinlogParseError) IsEOF 

func (err *BinlogParseError) IsEOF() bool

func (*BinlogParseError) IsFatal 

func (err *BinlogParseError) IsFatal() bool

type BinlogPosition 

type BinlogPosition struct {
	Position  ReplicationCoordinates
	Timestamp int64
	Xid       uint64
	GroupId   uint64
}

func (*BinlogPosition) MarshalBson 

func (pos *BinlogPosition) MarshalBson(buf *bytes2.ChunkedWriter)

func (*BinlogPosition) String 

func (pos *BinlogPosition) String() string

func (*BinlogPosition) UnmarshalBson 

func (pos *BinlogPosition) UnmarshalBson(buf *bytes.Buffer)

func (*BinlogPosition) Valid 

func (pos *BinlogPosition) Valid() bool

type BinlogReader 

type BinlogReader struct {

	// these parameters will have reasonable default values but can be tuned
	BinlogBlockSize int64
	MaxWaitTimeout  float64
	LogWaitTimeout  float64
	// contains filtered or unexported fields
}

func NewBinlogReader 

func NewBinlogReader(binLogPrefix string) *BinlogReader

func (*BinlogReader) HandleBinlogRequest 

func (blr *BinlogReader) HandleBinlogRequest(rw http.ResponseWriter, req *http.Request)

func (*BinlogReader) ServeData 

func (blr *BinlogReader) ServeData(writer io.Writer, filename string, startPosition int64)

type BinlogResponse 

type BinlogResponse struct {
	Error string
	BlPosition
	BinlogData
}

type BinlogServerRequest 

type BinlogServerRequest struct {
	StartPosition ReplicationCoordinates
	KeyspaceStart string
	KeyspaceEnd   string
}

type BlPosition 

type BlPosition struct {
	Position  ReplicationCoordinates
	Timestamp int64
	Xid       uint64
	GroupId   uint64
}

type Blp 

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

func NewBlp 

func NewBlp(startCoordinates *ReplicationCoordinates, updateStream *UpdateStream) *Blp

func (Blp) DebugJsonString 

func (stats Blp) DebugJsonString() string

func (*Blp) StreamBinlog 

func (blp *Blp) StreamBinlog(sendReply SendUpdateStreamResponse, binlogPrefix string)

Main entry function for reading and parsing the binlog.

type ByReverseDataLength 

type ByReverseDataLength struct {
	TableDefinitions
}

sort by reverse DataLength

func (ByReverseDataLength) Less 

func (bdl ByReverseDataLength) Less(i, j int) bool

type CreateConnection 

type CreateConnection func() (*mysql.Connection, error)

type DbPermission 

type DbPermission struct {
	Host       string
	Db         string
	User       string
	Privileges map[string]string
}

DbPermission describes a single row in the mysql.db table Primary key is Host+Db+User

func (*DbPermission) PrimaryKey 

func (dp *DbPermission) PrimaryKey() string

func (*DbPermission) String 

func (dp *DbPermission) String() string

type DbPermissionList 

type DbPermissionList []*DbPermission

func (DbPermissionList) Get 

func (upl DbPermissionList) Get(i int) Permission

func (DbPermissionList) Len 

func (upl DbPermissionList) Len() int

type EventData 

type EventData struct {
	SqlType    string
	TableName  string
	Sql        string
	PkColNames []string
	PkValues   [][]interface{}
}

type HostPermission 

type HostPermission struct {
	Host       string
	Db         string
	Privileges map[string]string
}

HostPermission describes a single row in the mysql.host table Primary key is Host+Db

func (*HostPermission) PrimaryKey 

func (hp *HostPermission) PrimaryKey() string

func (*HostPermission) String 

func (hp *HostPermission) String() string

type HostPermissionList 

type HostPermissionList []*HostPermission

func (HostPermissionList) Get 

func (upl HostPermissionList) Get(i int) Permission

func (HostPermissionList) Len 

func (upl HostPermissionList) Len() int

type MapFunc 

type MapFunc func(index int) error

type Mycnf 

type Mycnf struct {
	ServerId              uint32
	MysqlPort             int
	DataDir               string
	InnodbDataHomeDir     string
	InnodbLogGroupHomeDir string
	SocketFile            string
	StartKey              string
	EndKey                string
	ErrorLogPath          string
	SlowLogPath           string
	RelayLogPath          string
	RelayLogIndexPath     string
	RelayLogInfoPath      string
	BinLogPath            string
	BinLogIndexPath       string
	MasterInfoFile        string
	PidFile               string
	TmpDir                string
	SlaveLoadTmpDir       string
	// contains filtered or unexported fields
}

func NewMycnf 

func NewMycnf(uid uint32, mysqlPort int, vtRepl VtReplParams) *Mycnf

NewMycnf fills the Mycnf structure with vt root paths and derived values. This is used to fill out the cnfTemplate values and generate my.cnf. uid is a unique id for a particular tablet - it must be unique within the tabletservers deployed within a keyspace, lest there be collisions on disk. mysqldPort needs to be unique per instance per machine.

func ReadMycnf 

func ReadMycnf(cnfFile string) (mycnf *Mycnf, err error)

type Mysqld 

type Mysqld struct {
	TabletDir   string
	SnapshotDir string
	// contains filtered or unexported fields
}

func NewMysqld 

func NewMysqld(config *Mycnf, dba, repl mysql.ConnectionParams) *Mysqld

func (*Mysqld) Addr 

func (mysqld *Mysqld) Addr() string

func (*Mysqld) ApplySchemaChange 

func (mysqld *Mysqld) ApplySchemaChange(dbName string, change *SchemaChange) (*SchemaChangeResult, error)

func (*Mysqld) BreakSlaves 

func (mysqld *Mysqld) BreakSlaves() error

Force all slaves to error and stop. This is extreme, but helpful for emergencies and tests. Insert a row, block the propagation of its subsequent delete and reinsert it. This forces a failure on slaves only.

func (*Mysqld) CheckReplication 

func (mysqld *Mysqld) CheckReplication(timeCheck int64) error

Check for the magic row inserted under controlled reparenting.

func (*Mysqld) ConfigureKeyRange 

func (mysqld *Mysqld) ConfigureKeyRange(startKey, endKey key.HexKeyspaceId) error

func (*Mysqld) CreateMultiSnapshot 

func (mysqld *Mysqld) CreateMultiSnapshot(keyRanges []key.KeyRange, dbName, keyName string, sourceAddr string, allowHierarchicalReplication bool, snapshotConcurrency int, tables []string, skipSlaveRestart bool, maximumFilesize uint64, hookExtraEnv map[string]string) (snapshotManifestFilenames []string, err error)

func (*Mysqld) CreateSnapshot 

func (mysqld *Mysqld) CreateSnapshot(dbName, sourceAddr string, allowHierarchicalReplication bool, concurrency int, serverMode bool, hookExtraEnv map[string]string) (snapshotManifestUrlPath string, slaveStartRequired, readOnly bool, err error)

This function runs on the machine acting as the source for the clone.

Check master/slave status and determine restore needs. If this instance is a slave, stop replication, otherwise place in read-only mode. Record replication position. Shutdown mysql Check paths for storing data

Depending on the serverMode flag, we do the following: serverMode = false: 

Compress /vt/vt_[0-9a-f]+/data/vt_.+
Compute hash (of compressed files, as we serve .gz files here)
Place in /vt/clone_src where they will be served by http server (not rpc)
Restart mysql

serverMode = true: 

Make symlinks for /vt/vt_[0-9a-f]+/data/vt_.+ to innodb files
Compute hash (of uncompressed files, as we serve uncompressed files)
Place symlinks in /vt/clone_src where they will be served by http server
Leave mysql stopped, return slaveStartRequired, readOnly

func (*Mysqld) CreateSplitSnapshot 

func (mysqld *Mysqld) CreateSplitSnapshot(dbName, keyName string, startKey, endKey key.HexKeyspaceId, sourceAddr string, allowHierarchicalReplication bool, snapshotConcurrency int, hookExtraEnv map[string]string) (snapshotManifestFilename string, err error)

copied from replication. create a series of raw dump files the contain rows to be reinserted

dbName - mysql db name keyName - name of the mysql column that is the leading edge of all primary keys startKey, endKey - the row range to prepare sourceAddr - the ip addr of the machine running the export allowHierarchicalReplication - allow replication from a slave

func (*Mysqld) DemoteMaster 

func (mysqld *Mysqld) DemoteMaster() (*ReplicationPosition, error)

if the master is still alive, then we need to demote it gracefully make it read-only, flush the writes and get the position

func (*Mysqld) ExecuteMysqlCommand 

func (mysqld *Mysqld) ExecuteMysqlCommand(sql string) error

executes some SQL commands using a mysql command line interface process

func (*Mysqld) FindSlaves 

func (mysqld *Mysqld) FindSlaves() ([]string, error)

Get IP addresses for all currently connected slaves. FIXME(msolomon) use command instead of user to find "rogue" slaves?

func (*Mysqld) FindVtDatabases 

func (mysqld *Mysqld) FindVtDatabases() ([]string, error)

func (*Mysqld) GetColumns 

func (mysqld *Mysqld) GetColumns(dbName, table string) ([]string, error)

GetColumns returns the columns of table.

func (*Mysqld) GetMasterAddr 

func (mysqld *Mysqld) GetMasterAddr() (string, error)

func (*Mysqld) GetPermissions 

func (mysqld *Mysqld) GetPermissions() (*Permissions, error)

func (*Mysqld) GetSchema 

func (mysqld *Mysqld) GetSchema(dbName string, tables []string, includeViews bool) (*SchemaDefinition, error)

GetSchema returns the schema for database for tables listed in tables. If tables is empty, return the schema for all tables.

func (*Mysqld) IpAddr 

func (mysqld *Mysqld) IpAddr() string

func (*Mysqld) IsReadOnly 

func (mysqld *Mysqld) IsReadOnly() (bool, error)

func (*Mysqld) MasterStatus 

func (mysqld *Mysqld) MasterStatus() (rp *ReplicationPosition, err error)

mysql> show master status\G **************************** 1. row *************************** File: vt-000001c6-bin.000003 Position: 106 Binlog_Do_DB: Binlog_Ignore_DB:

func (*Mysqld) PreflightSchemaChange 

func (mysqld *Mysqld) PreflightSchemaChange(dbName string, change string) (*SchemaChangeResult, error)

func (*Mysqld) PromoteSlave 

func (mysqld *Mysqld) PromoteSlave(setReadWrite bool) (replicationState *ReplicationState, waitPosition *ReplicationPosition, timePromoted int64, err error)

setReadWrite: set the new master in read-write mode.

replicationState: info slaves need to reparent themselves waitPosition: slaves can wait for this position when restarting replication timePromoted: this timestamp (unix nanoseconds) is inserted into _vt.replication_log to verify the replication config

func (*Mysqld) ReparentPosition 

func (mysqld *Mysqld) ReparentPosition(slavePosition *ReplicationPosition) (rs *ReplicationState, waitPosition *ReplicationPosition, reparentTime int64, err error)

Return a replication state that will reparent a slave to the correct master for a specified position.

func (*Mysqld) ResetKeyRange 

func (mysqld *Mysqld) ResetKeyRange() error

func (*Mysqld) RestartSlave 

func (mysqld *Mysqld) RestartSlave(replicationState *ReplicationState, waitPosition *ReplicationPosition, timeCheck int64) error

func (*Mysqld) RestoreFromMultiSnapshot 

func (mysqld *Mysqld) RestoreFromMultiSnapshot(destinationDbName string, keyRange key.KeyRange, sourceAddrs []*url.URL, uids []uint32, snapshotConcurrency, fetchConcurrency, insertTableConcurrency, fetchRetryCount int, strategy string) (err error)

RestoreFromMultiSnapshot is the main entry point for multi restore.

  • If the strategy contains the string 'writeBinLogs' then we will also write to the binary logs.
  • If the strategy contains the command 'populateBlpRecovery(NNN)' then we will populate the blp_checkpoint table with master positions to start from

func (*Mysqld) RestoreFromPartialSnapshot 

func (mysqld *Mysqld) RestoreFromPartialSnapshot(snapshotManifest *SplitSnapshotManifest, fetchConcurrency, fetchRetryCount int) (err error)

This piece runs on the presumably empty machine acting as the target in the create replica action.

validate target (self) shutdown_mysql() create temp data directory /vt/target/vt_<keyspace> copy compressed data files via HTTP verify hash of compressed files uncompress into /vt/vt_<target-uid>/data/vt_<keyspace> start_mysql() clean up compressed files

func (*Mysqld) RestoreFromSnapshot 

func (mysqld *Mysqld) RestoreFromSnapshot(snapshotManifest *SnapshotManifest, fetchConcurrency, fetchRetryCount int, dontWaitForSlaveStart bool, hookExtraEnv map[string]string) error

This piece runs on the presumably empty machine acting as the target in the create replica action.

validate target (self) shutdown_mysql() create temp data directory /vt/target/vt_<keyspace> copy compressed data files via HTTP verify hash of compressed files uncompress into /vt/vt_<target-uid>/data/vt_<keyspace> start_mysql() clean up compressed files

func (*Mysqld) SetReadOnly 

func (mysqld *Mysqld) SetReadOnly(on bool) error

func (*Mysqld) SlaveStatus 

func (mysqld *Mysqld) SlaveStatus() (*ReplicationPosition, error)

func (*Mysqld) SnapshotSourceEnd 

func (mysqld *Mysqld) SnapshotSourceEnd(slaveStartRequired, readOnly, deleteSnapshot bool) error

func (*Mysqld) StartSlave 

func (mysqld *Mysqld) StartSlave() error

func (*Mysqld) StopSlave 

func (mysqld *Mysqld) StopSlave() error

func (*Mysqld) ValidateCloneTarget 

func (mysqld *Mysqld) ValidateCloneTarget(hookExtraEnv map[string]string) error

func (*Mysqld) ValidateSnapshotPath 

func (mysqld *Mysqld) ValidateSnapshotPath() error

Helper function to make sure we can write to the local snapshot area, before we actually do any action (can be used for both partial and full snapshots)

func (*Mysqld) WaitForSlave 

func (mysqld *Mysqld) WaitForSlave(maxLag int) (err error)

func (*Mysqld) WaitForSlaveStart 

func (mysqld *Mysqld) WaitForSlaveStart(slaveStartDeadline int) (err error)

func (*Mysqld) WaitMasterPos 

func (mysqld *Mysqld) WaitMasterPos(rp *ReplicationPosition, waitTimeout int) error

type Permission 

type Permission interface {
	PrimaryKey() string
	String() string
}

type PermissionList 

type PermissionList interface {
	Get(int) Permission
	Len() int
}

type Permissions 

type Permissions struct {
	UserPermissions UserPermissionList
	DbPermissions   DbPermissionList
	HostPermissions HostPermissionList
}

Permissions have all the rows in mysql.{user,db,host} tables, (all rows are sorted by primary key)

func (*Permissions) String 

func (permissions *Permissions) String() string

type ReplicationCoordinates 

type ReplicationCoordinates struct {
	RelayFilename  string
	RelayPosition  uint64
	MasterFilename string
	MasterPosition uint64
}

func GetReplicationPosition 

func GetReplicationPosition() (rc *ReplicationCoordinates, err error)

func NewReplicationCoordinates 

func NewReplicationCoordinates(slaveLog string, slavePosition uint64, masterFile string, masterPos uint64) *ReplicationCoordinates

func (*ReplicationCoordinates) String 

func (repl *ReplicationCoordinates) String() string

type ReplicationPosition 

type ReplicationPosition struct {
	MasterLogFile       string
	MasterLogPosition   uint
	MasterLogFileIo     string // how much has been read, but not applied
	MasterLogPositionIo uint
	SecondsBehindMaster uint
}

func (ReplicationPosition) MapKey 

func (rp ReplicationPosition) MapKey() string

func (ReplicationPosition) MapKeyIo 

func (rp ReplicationPosition) MapKeyIo() string

type ReplicationState 

type ReplicationState struct {
	// ReplicationPosition is not anonymous because the default json encoder has begun to fail here.
	ReplicationPosition ReplicationPosition
	MasterHost          string
	MasterPort          int
	MasterConnectRetry  int
}

func NewReplicationState 

func NewReplicationState(masterAddr string) (*ReplicationState, error)

func (ReplicationState) MasterAddr 

func (rs ReplicationState) MasterAddr() string

type SchemaChange 

type SchemaChange struct {
	Sql              string
	Force            bool
	AllowReplication bool
	BeforeSchema     *SchemaDefinition
	AfterSchema      *SchemaDefinition
}

type SchemaChangeResult 

type SchemaChangeResult struct {
	BeforeSchema *SchemaDefinition
	AfterSchema  *SchemaDefinition
}

func (*SchemaChangeResult) String 

func (scr *SchemaChangeResult) String() string

type SchemaDefinition 

type SchemaDefinition struct {
	// the 'CREATE DATABASE...' statement, with db name as {{.DatabaseName}}
	DatabaseSchema string

	// ordered by TableDefinition.Name by default
	TableDefinitions TableDefinitions

	// the md5 of the concatenation of TableDefinition.Schema
	Version string
}

func (*SchemaDefinition) GetTable 

func (sd *SchemaDefinition) GetTable(table string) (td *TableDefinition, ok bool)

func (*SchemaDefinition) SortByReverseDataLength 

func (sd *SchemaDefinition) SortByReverseDataLength()

func (*SchemaDefinition) String 

func (sd *SchemaDefinition) String() string

type SendUpdateStreamResponse 

type SendUpdateStreamResponse func(response interface{}) error

type SlaveMetadata 

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

func NewSlaveMetadata 

func NewSlaveMetadata(logsDir string, relayInfo string) *SlaveMetadata

func (*SlaveMetadata) GetCurrentReplicationPosition 

func (metadata *SlaveMetadata) GetCurrentReplicationPosition() (repl *ReplicationCoordinates, err error)

This gets the current replication position.

type SnapshotFile 

type SnapshotFile struct {
	Path      string
	Size      int64
	Hash      string
	TableName string
}

SnapshotFile describes a file to serve. 'Path' is the path component of the URL. SnapshotManifest.Addr is the host+port component of the URL. If path ends in '.gz', it is compressed. Size and Hash are computed on the Path itself if TableName is set, this file belongs to that table

type SnapshotFiles 

type SnapshotFiles []SnapshotFile

func (SnapshotFiles) Len 

func (s SnapshotFiles) Len() int

sort.Interface we sort by descending file size

func (SnapshotFiles) Less 

func (s SnapshotFiles) Less(i, j int) bool

func (SnapshotFiles) Swap 

func (s SnapshotFiles) Swap(i, j int)

type SnapshotManifest 

type SnapshotManifest struct {
	Addr string // this is the address of the tabletserver, not mysql

	DbName string
	Files  SnapshotFiles

	ReplicationState *ReplicationState
	MasterState      *ReplicationState
}

a SnapshotManifest describes multiple SnapshotFiles and where to get them from.

func ReadSnapshotManifest 

func ReadSnapshotManifest(filename string) (*SnapshotManifest, error)

type SplitSnapshotManifest 

type SplitSnapshotManifest struct {
	Source           *SnapshotManifest
	KeyRange         key.KeyRange
	SchemaDefinition *SchemaDefinition
}

func NewSplitSnapshotManifest 

func NewSplitSnapshotManifest(myAddr, myMysqlAddr, masterAddr, dbName string, files []SnapshotFile, pos, myMasterPos *ReplicationPosition, startKey, endKey key.HexKeyspaceId, sd *SchemaDefinition) (*SplitSnapshotManifest, error)

NewSplitSnapshotManifest creates a new SplitSnapshotManifest. myAddr and myMysqlAddr are the local server addresses. masterAddr is the address of the server to use as master. pos is the replication position to use on that master. myMasterPos is the local server master position

func ReadSplitSnapshotManifest 

func ReadSplitSnapshotManifest(filename string) (*SplitSnapshotManifest, error)

type TableDefinition 

type TableDefinition struct {
	Name       string   // the table name
	Schema     string   // the SQL to run to create the table
	Columns    []string // the columns in the order that will be used to dump and load the data
	Type       string   // TABLE_BASE_TABLE or TABLE_VIEW
	DataLength uint64   // how much space the data file takes.
}

type TableDefinitions 

type TableDefinitions []TableDefinition

helper methods for sorting

func (TableDefinitions) Len 

func (tds TableDefinitions) Len() int

func (TableDefinitions) Swap 

func (tds TableDefinitions) Swap(i, j int)

type UpdateResponse 

type UpdateResponse struct {
	Error string
	BinlogPosition
	EventData
}

Api Interface

type UpdateStream 

type UpdateStream struct {
	// contains filtered or unexported fields
}
var UpdateStreamRpcService *UpdateStream

func (*UpdateStream) ServeUpdateStream 

func (updateStream *UpdateStream) ServeUpdateStream(req *UpdateStreamRequest, sendReply SendUpdateStreamResponse) error

type UpdateStreamRequest 

type UpdateStreamRequest struct {
	StartPosition BinlogPosition
}

type UserPermission 

type UserPermission struct {
	Host             string
	User             string
	PasswordChecksum uint64
	Privileges       map[string]string
}

UserPermission describes a single row in the mysql.user table Primary key is Host+User PasswordChecksum is the crc64 of the password, for security reasons

func (*UserPermission) PrimaryKey 

func (up *UserPermission) PrimaryKey() string

func (*UserPermission) String 

func (up *UserPermission) String() string

type UserPermissionList 

type UserPermissionList []*UserPermission

func (UserPermissionList) Get 

func (upl UserPermissionList) Get(i int) Permission

func (UserPermissionList) Len 

func (upl UserPermissionList) Len() int

type VtReplParams 

type VtReplParams struct {
	StartKey string
	EndKey   string
}

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.