Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "SetSuperReadOnly", "(", "on", "bool", ")", "error", "{", "fmd", ".", "SuperReadOnly", "=", "on", "\n", "fmd", ".", "ReadOnly", "=", "on", "\n", "return", "nil", "\n", "}" ]

[ "SetSuperReadOnly", "is", "part", "of", "the", "MysqlDaemon", "interface" ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "StartSlave", "(", "hookExtraEnv", "map", "[", "string", "]", "string", ")", "error", "{", "return", "fmd", ".", "ExecuteSuperQueryList", "(", "context", ".", "Background", "(", ")", ",", "[", "]", "string", "{", "\"", "\"", ",", "}", ")", "\n", "}" ]

[ "StartSlave", "is", "part", "of", "the", "MysqlDaemon", "interface", "." ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "StartSlaveUntilAfter", "(", "ctx", "context", ".", "Context", ",", "pos", "mysql", ".", "Position", ")", "error", "{", "if", "!", "reflect", ".", "DeepEqual", "(", "fmd", ".", "StartSlaveUntilAfterPos", ",", "pos", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fmd", ".", "SetSlavePositionPos", ",", "pos", ")", "\n", "}", "\n\n", "return", "fmd", ".", "ExecuteSuperQueryList", "(", "context", ".", "Background", "(", ")", ",", "[", "]", "string", "{", "\"", "\"", ",", "}", ")", "\n", "}" ]

[ "StartSlaveUntilAfter", "is", "part", "of", "the", "MysqlDaemon", "interface", "." ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "SetMaster", "(", "ctx", "context", ".", "Context", ",", "masterHost", "string", ",", "masterPort", "int", ",", "slaveStopBefore", "bool", ",", "slaveStartAfter", "bool", ")", "error", "{", "input", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "masterHost", ",", "masterPort", ")", "\n", "if", "fmd", ".", "SetMasterInput", "!=", "input", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fmd", ".", "SetMasterInput", ",", "input", ")", "\n", "}", "\n", "cmds", ":=", "[", "]", "string", "{", "}", "\n", "if", "slaveStopBefore", "{", "cmds", "=", "append", "(", "cmds", ",", "\"", "\"", ")", "\n", "}", "\n", "cmds", "=", "append", "(", "cmds", ",", "\"", "\"", ")", "\n", "if", "slaveStartAfter", "{", "cmds", "=", "append", "(", "cmds", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "fmd", ".", "ExecuteSuperQueryList", "(", "ctx", ",", "cmds", ")", "\n", "}" ]

[ "SetMaster", "is", "part", "of", "the", "MysqlDaemon", "interface", "." ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "WaitForReparentJournal", "(", "ctx", "context", ".", "Context", ",", "timeCreatedNS", "int64", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "WaitForReparentJournal", "is", "part", "of", "the", "MysqlDaemon", "interface" ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "WaitMasterPos", "(", "_", "context", ".", "Context", ",", "pos", "mysql", ".", "Position", ")", "error", "{", "if", "fmd", ".", "TimeoutHook", "!=", "nil", "{", "return", "fmd", ".", "TimeoutHook", "(", ")", "\n", "}", "\n", "if", "reflect", ".", "DeepEqual", "(", "fmd", ".", "WaitMasterPosition", ",", "pos", ")", "{", "return", "nil", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fmd", ".", "WaitMasterPosition", ",", "pos", ")", "\n", "}" ]

[ "WaitMasterPos", "is", "part", "of", "the", "MysqlDaemon", "interface" ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "PromoteSlave", "(", "hookExtraEnv", "map", "[", "string", "]", "string", ")", "(", "mysql", ".", "Position", ",", "error", ")", "{", "return", "fmd", ".", "PromoteSlaveResult", ",", "nil", "\n", "}" ]

[ "PromoteSlave", "is", "part", "of", "the", "MysqlDaemon", "interface" ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "ExecuteSuperQueryList", "(", "ctx", "context", ".", "Context", ",", "queryList", "[", "]", "string", ")", "error", "{", "for", "_", ",", "query", ":=", "range", "queryList", "{", "// test we still have a query to compare", "if", "fmd", ".", "ExpectedExecuteSuperQueryCurrent", ">=", "len", "(", "fmd", ".", "ExpectedExecuteSuperQueryList", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "query", ")", "\n", "}", "\n\n", "// compare the query", "expected", ":=", "fmd", ".", "ExpectedExecuteSuperQueryList", "[", "fmd", ".", "ExpectedExecuteSuperQueryCurrent", "]", "\n", "fmd", ".", "ExpectedExecuteSuperQueryCurrent", "++", "\n", "if", "strings", ".", "HasPrefix", "(", "expected", ",", "\"", "\"", ")", "{", "// remove the SUB from the expected,", "// and truncate the query to length(expected)", "expected", "=", "expected", "[", "3", ":", "]", "\n", "if", "len", "(", "query", ")", ">", "len", "(", "expected", ")", "{", "query", "=", "query", "[", ":", "len", "(", "expected", ")", "]", "\n", "}", "\n", "}", "\n", "if", "expected", "!=", "query", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "expected", ",", "query", ")", "\n", "}", "\n\n", "// intercept some queries to update our status", "switch", "query", "{", "case", "\"", "\"", ":", "fmd", ".", "Replicating", "=", "true", "\n", "case", "\"", "\"", ":", "fmd", ".", "Replicating", "=", "false", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ExecuteSuperQueryList", "is", "part", "of", "the", "MysqlDaemon", "interface" ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "FetchSuperQuery", "(", "ctx", "context", ".", "Context", ",", "query", "string", ")", "(", "*", "sqltypes", ".", "Result", ",", "error", ")", "{", "if", "fmd", ".", "FetchSuperQueryMap", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "query", ")", "\n", "}", "\n\n", "qr", ",", "ok", ":=", "fmd", ".", "FetchSuperQueryMap", "[", "query", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "query", ")", "\n", "}", "\n", "return", "qr", ",", "nil", "\n", "}" ]

[ "FetchSuperQuery", "returns", "the", "results", "from", "the", "map", "if", "any" ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "CheckSuperQueryList", "(", ")", "error", "{", "if", "fmd", ".", "ExpectedExecuteSuperQueryCurrent", "!=", "len", "(", "fmd", ".", "ExpectedExecuteSuperQueryList", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fmd", ".", "ExpectedExecuteSuperQueryCurrent", ",", "len", "(", "fmd", ".", "ExpectedExecuteSuperQueryList", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckSuperQueryList", "returns", "an", "error", "if", "all", "the", "queries", "we", "expected", "haven", "t", "been", "seen", "." ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "GetSchema", "(", "dbName", "string", ",", "tables", ",", "excludeTables", "[", "]", "string", ",", "includeViews", "bool", ")", "(", "*", "tabletmanagerdatapb", ".", "SchemaDefinition", ",", "error", ")", "{", "if", "fmd", ".", "SchemaFunc", "!=", "nil", "{", "return", "fmd", ".", "SchemaFunc", "(", ")", "\n", "}", "\n", "if", "fmd", ".", "Schema", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "tmutils", ".", "FilterTables", "(", "fmd", ".", "Schema", ",", "tables", ",", "excludeTables", ",", "includeViews", ")", "\n", "}" ]

[ "GetSchema", "is", "part", "of", "the", "MysqlDaemon", "interface" ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "GetColumns", "(", "dbName", ",", "table", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "[", "]", "string", "{", "}", ",", "nil", "\n", "}" ]

[ "GetColumns", "is", "part", "of", "the", "MysqlDaemon", "interface" ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "GetPrimaryKeyColumns", "(", "dbName", ",", "table", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "[", "]", "string", "{", "}", ",", "nil", "\n", "}" ]

[ "GetPrimaryKeyColumns", "is", "part", "of", "the", "MysqlDaemon", "interface" ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "PreflightSchemaChange", "(", "dbName", "string", ",", "changes", "[", "]", "string", ")", "(", "[", "]", "*", "tabletmanagerdatapb", ".", "SchemaChangeResult", ",", "error", ")", "{", "if", "fmd", ".", "PreflightSchemaChangeResult", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "fmd", ".", "PreflightSchemaChangeResult", ",", "nil", "\n", "}" ]

[ "PreflightSchemaChange", "is", "part", "of", "the", "MysqlDaemon", "interface" ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "ApplySchemaChange", "(", "dbName", "string", ",", "change", "*", "tmutils", ".", "SchemaChange", ")", "(", "*", "tabletmanagerdatapb", ".", "SchemaChangeResult", ",", "error", ")", "{", "if", "fmd", ".", "ApplySchemaChangeResult", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "fmd", ".", "ApplySchemaChangeResult", ",", "nil", "\n", "}" ]

[ "ApplySchemaChange", "is", "part", "of", "the", "MysqlDaemon", "interface" ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "GetAppConnection", "(", "ctx", "context", ".", "Context", ")", "(", "*", "dbconnpool", ".", "PooledDBConnection", ",", "error", ")", "{", "return", "fmd", ".", "appPool", ".", "Get", "(", "ctx", ")", "\n", "}" ]

[ "GetAppConnection", "is", "part", "of", "the", "MysqlDaemon", "interface", "." ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "GetAllPrivsConnection", "(", ")", "(", "*", "dbconnpool", ".", "DBConnection", ",", "error", ")", "{", "return", "dbconnpool", ".", "NewDBConnection", "(", "fmd", ".", "db", ".", "ConnParams", "(", ")", ",", "stats", ".", "NewTimings", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "GetAllPrivsConnection", "is", "part", "of", "the", "MysqlDaemon", "interface", "." ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "SetSemiSyncEnabled", "(", "master", ",", "slave", "bool", ")", "error", "{", "fmd", ".", "SemiSyncMasterEnabled", "=", "master", "\n", "fmd", ".", "SemiSyncSlaveEnabled", "=", "slave", "\n", "return", "nil", "\n", "}" ]

[ "SetSemiSyncEnabled", "is", "part", "of", "the", "MysqlDaemon", "interface", "." ]

[ "func", "(", "fmd", "*", "FakeMysqlDaemon", ")", "SemiSyncEnabled", "(", ")", "(", "master", ",", "slave", "bool", ")", "{", "return", "fmd", ".", "SemiSyncMasterEnabled", ",", "fmd", ".", "SemiSyncSlaveEnabled", "\n", "}" ]

[ "SemiSyncEnabled", "is", "part", "of", "the", "MysqlDaemon", "interface", "." ]

[ "func", "NewPlainController", "(", "sqlStr", "string", ",", "keyspace", "string", ")", "*", "PlainController", "{", "controller", ":=", "&", "PlainController", "{", "sqls", ":", "make", "(", "[", "]", "string", ",", "0", ",", "32", ")", ",", "keyspace", ":", "keyspace", ",", "}", "\n\n", "sqls", ",", "err", ":=", "sqlparser", ".", "SplitStatementToPieces", "(", "sqlStr", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "for", "_", ",", "sql", ":=", "range", "sqls", "{", "s", ":=", "strings", ".", "TrimSpace", "(", "sql", ")", "\n", "if", "s", "!=", "\"", "\"", "{", "controller", ".", "sqls", "=", "append", "(", "controller", ".", "sqls", ",", "s", ")", "\n", "}", "\n", "}", "\n", "return", "controller", "\n", "}" ]

[ "NewPlainController", "creates", "a", "new", "PlainController", "instance", "." ]

[ "func", "(", "controller", "*", "PlainController", ")", "Read", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "controller", ".", "sqls", ",", "nil", "\n", "}" ]

[ "Read", "reads", "schema", "changes" ]

[ "func", "(", "controller", "*", "PlainController", ")", "OnReadSuccess", "(", "ctx", "context", ".", "Context", ")", "error", "{", "log", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "OnReadSuccess", "is", "called", "when", "schemamanager", "successfully", "reads", "all", "sql", "statements", "." ]

[ "func", "(", "controller", "*", "PlainController", ")", "OnReadFail", "(", "ctx", "context", ".", "Context", ",", "err", "error", ")", "error", "{", "log", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}" ]

[ "OnReadFail", "is", "called", "when", "schemamanager", "fails", "to", "read", "all", "sql", "statements", "." ]

[ "func", "(", "controller", "*", "PlainController", ")", "OnExecutorComplete", "(", "ctx", "context", ".", "Context", ",", "result", "*", "ExecuteResult", ")", "error", "{", "out", ",", "_", ":=", "json", ".", "MarshalIndent", "(", "result", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "log", ".", "Infof", "(", "\"", "\\n", "\"", ",", "string", "(", "out", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "OnExecutorComplete", "is", "called", "when", "schemamanager", "finishes", "applying", "schema", "changes", "." ]

[ "func", "(", "fhc", "*", "FakeHealthCheck", ")", "SetListener", "(", "listener", "HealthCheckStatsListener", ",", "sendDownEvents", "bool", ")", "{", "fhc", ".", "listener", "=", "listener", "\n", "}" ]

[ "SetListener", "is", "not", "implemented", "." ]

[ "func", "(", "fhc", "*", "FakeHealthCheck", ")", "AddTablet", "(", "tablet", "*", "topodatapb", ".", "Tablet", ",", "name", "string", ")", "{", "key", ":=", "TabletToMapKey", "(", "tablet", ")", "\n", "item", ":=", "&", "fhcItem", "{", "ts", ":", "&", "TabletStats", "{", "Key", ":", "key", ",", "Tablet", ":", "tablet", ",", "Target", ":", "&", "querypb", ".", "Target", "{", "Keyspace", ":", "tablet", ".", "Keyspace", ",", "Shard", ":", "tablet", ".", "Shard", ",", "TabletType", ":", "tablet", ".", "Type", ",", "}", ",", "Serving", ":", "true", ",", "Up", ":", "true", ",", "Name", ":", "name", ",", "Stats", ":", "&", "querypb", ".", "RealtimeStats", "{", "}", ",", "}", ",", "}", "\n\n", "fhc", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "fhc", ".", "mu", ".", "Unlock", "(", ")", "\n", "fhc", ".", "items", "[", "key", "]", "=", "item", "\n\n", "if", "fhc", ".", "listener", "!=", "nil", "{", "fhc", ".", "listener", ".", "StatsUpdate", "(", "item", ".", "ts", ")", "\n", "}", "\n", "}" ]

[ "AddTablet", "adds", "the", "tablet", "and", "calls", "the", "listener", "." ]

[ "func", "(", "fhc", "*", "FakeHealthCheck", ")", "RemoveTablet", "(", "tablet", "*", "topodatapb", ".", "Tablet", ")", "{", "fhc", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "fhc", ".", "mu", ".", "Unlock", "(", ")", "\n", "key", ":=", "TabletToMapKey", "(", "tablet", ")", "\n", "delete", "(", "fhc", ".", "items", ",", "key", ")", "\n", "}" ]

[ "RemoveTablet", "removes", "the", "tablet", "." ]

[ "func", "(", "fhc", "*", "FakeHealthCheck", ")", "ReplaceTablet", "(", "old", ",", "new", "*", "topodatapb", ".", "Tablet", ",", "name", "string", ")", "{", "fhc", ".", "RemoveTablet", "(", "old", ")", "\n", "fhc", ".", "AddTablet", "(", "new", ",", "name", ")", "\n", "}" ]

[ "ReplaceTablet", "removes", "the", "old", "tablet", "and", "adds", "the", "new", "." ]

[ "func", "(", "fhc", "*", "FakeHealthCheck", ")", "CacheStatus", "(", ")", "TabletsCacheStatusList", "{", "fhc", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "fhc", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "stats", ":=", "make", "(", "TabletsCacheStatusList", ",", "0", ",", "len", "(", "fhc", ".", "items", ")", ")", "\n", "for", "_", ",", "item", ":=", "range", "fhc", ".", "items", "{", "stats", "=", "append", "(", "stats", ",", "&", "TabletsCacheStatus", "{", "Cell", ":", "\"", "\"", ",", "Target", ":", "item", ".", "ts", ".", "Target", ",", "TabletsStats", ":", "TabletStatsList", "{", "item", ".", "ts", "}", ",", "}", ")", "\n", "}", "\n", "sort", ".", "Sort", "(", "stats", ")", "\n", "return", "stats", "\n", "}" ]

[ "CacheStatus", "returns", "the", "status", "for", "each", "tablet" ]

[ "func", "(", "fhc", "*", "FakeHealthCheck", ")", "Reset", "(", ")", "{", "fhc", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "fhc", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "fhc", ".", "items", "=", "make", "(", "map", "[", "string", "]", "*", "fhcItem", ")", "\n", "}" ]

[ "Management", "methods", "Reset", "cleans", "up", "the", "internal", "state", "." ]

[ "func", "(", "fhc", "*", "FakeHealthCheck", ")", "AddFakeTablet", "(", "cell", ",", "host", "string", ",", "port", "int32", ",", "keyspace", ",", "shard", "string", ",", "tabletType", "topodatapb", ".", "TabletType", ",", "serving", "bool", ",", "reparentTS", "int64", ",", "err", "error", ",", "connFactory", "func", "(", "*", "topodatapb", ".", "Tablet", ")", "queryservice", ".", "QueryService", ")", "queryservice", ".", "QueryService", "{", "t", ":=", "topo", ".", "NewTablet", "(", "0", ",", "cell", ",", "host", ")", "\n", "t", ".", "Keyspace", "=", "keyspace", "\n", "t", ".", "Shard", "=", "shard", "\n", "t", ".", "Type", "=", "tabletType", "\n", "t", ".", "PortMap", "[", "\"", "\"", "]", "=", "port", "\n", "key", ":=", "TabletToMapKey", "(", "t", ")", "\n\n", "fhc", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "fhc", ".", "mu", ".", "Unlock", "(", ")", "\n", "item", ":=", "fhc", ".", "items", "[", "key", "]", "\n", "if", "item", "==", "nil", "{", "item", "=", "&", "fhcItem", "{", "ts", ":", "&", "TabletStats", "{", "Key", ":", "key", ",", "Tablet", ":", "t", ",", "Up", ":", "true", ",", "}", ",", "}", "\n", "fhc", ".", "items", "[", "key", "]", "=", "item", "\n", "}", "\n", "item", ".", "ts", ".", "Target", "=", "&", "querypb", ".", "Target", "{", "Keyspace", ":", "keyspace", ",", "Shard", ":", "shard", ",", "TabletType", ":", "tabletType", ",", "}", "\n", "item", ".", "ts", ".", "Serving", "=", "serving", "\n", "item", ".", "ts", ".", "TabletExternallyReparentedTimestamp", "=", "reparentTS", "\n", "item", ".", "ts", ".", "Stats", "=", "&", "querypb", ".", "RealtimeStats", "{", "}", "\n", "item", ".", "ts", ".", "LastError", "=", "err", "\n", "conn", ":=", "connFactory", "(", "t", ")", "\n", "item", ".", "conn", "=", "conn", "\n\n", "if", "fhc", ".", "listener", "!=", "nil", "{", "fhc", ".", "listener", ".", "StatsUpdate", "(", "item", ".", "ts", ")", "\n", "}", "\n", "return", "conn", "\n", "}" ]

[ "AddFakeTablet", "inserts", "a", "fake", "entry", "into", "FakeHealthCheck", ".", "The", "Tablet", "can", "be", "talked", "to", "using", "the", "provided", "connection", ".", "The", "Listener", "is", "called", "as", "if", "AddTablet", "had", "been", "called", ".", "For", "flexibility", "the", "connection", "is", "created", "via", "a", "connFactory", "callback" ]

[ "func", "(", "fhc", "*", "FakeHealthCheck", ")", "GetAllTablets", "(", ")", "map", "[", "string", "]", "*", "topodatapb", ".", "Tablet", "{", "res", ":=", "make", "(", "map", "[", "string", "]", "*", "topodatapb", ".", "Tablet", ")", "\n", "fhc", ".", "mu", ".", "RLock", "(", ")", "\n", "defer", "fhc", ".", "mu", ".", "RUnlock", "(", ")", "\n", "for", "key", ",", "t", ":=", "range", "fhc", ".", "items", "{", "res", "[", "key", "]", "=", "t", ".", "ts", ".", "Tablet", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "GetAllTablets", "returns", "all", "the", "tablets", "we", "have", "." ]

[ "func", "splitAndExpression", "(", "filters", "[", "]", "sqlparser", ".", "Expr", ",", "node", "sqlparser", ".", "Expr", ")", "[", "]", "sqlparser", ".", "Expr", "{", "if", "node", "==", "nil", "{", "return", "filters", "\n", "}", "\n", "switch", "node", ":=", "node", ".", "(", "type", ")", "{", "case", "*", "sqlparser", ".", "AndExpr", ":", "filters", "=", "splitAndExpression", "(", "filters", ",", "node", ".", "Left", ")", "\n", "return", "splitAndExpression", "(", "filters", ",", "node", ".", "Right", ")", "\n", "case", "*", "sqlparser", ".", "ParenExpr", ":", "// If the inner expression is AndExpr, then we can remove", "// the parenthesis because they are unnecessary.", "if", "node", ",", "ok", ":=", "node", ".", "Expr", ".", "(", "*", "sqlparser", ".", "AndExpr", ")", ";", "ok", "{", "return", "splitAndExpression", "(", "filters", ",", "node", ")", "\n", "}", "\n", "}", "\n", "return", "append", "(", "filters", ",", "node", ")", "\n", "}" ]

[ "splitAndExpression", "breaks", "up", "the", "Expr", "into", "AND", "-", "separated", "conditions", "and", "appends", "them", "to", "filters", "which", "can", "be", "shuffled", "and", "recombined", "as", "needed", "." ]

[ "func", "Listen", "(", "port", "string", ")", "(", "l", "net", ".", "Listener", ",", "err", "error", ")", "{", "if", "port", "!=", "\"", "\"", "{", "killPredecessor", "(", "port", ")", "\n", "}", "\n", "return", "listen", "(", "port", ")", "\n", "}" ]

[ "Listen", "tries", "to", "create", "a", "listener", "on", "the", "specified", "tcp", "port", ".", "Before", "creating", "the", "listener", "it", "checks", "to", "see", "if", "there", "is", "another", "server", "already", "using", "the", "port", ".", "If", "there", "is", "one", "it", "sends", "a", "USR1", "signal", "requesting", "the", "server", "to", "shutdown", "and", "then", "attempts", "to", "to", "create", "the", "listener", "." ]

[ "func", "Wait", "(", ")", "os", ".", "Signal", "{", "c", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "signal", ".", "Notify", "(", "c", ",", "syscall", ".", "SIGTERM", ",", "syscall", ".", "SIGUSR1", ",", "syscall", ".", "SIGINT", ")", "\n\n", "http", ".", "HandleFunc", "(", "pidURL", ",", "func", "(", "r", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "r", ".", "Write", "(", "strconv", ".", "AppendInt", "(", "nil", ",", "int64", "(", "os", ".", "Getpid", "(", ")", ")", ",", "10", ")", ")", "\n", "}", ")", "\n\n", "return", "<-", "c", "\n", "}" ]

[ "Wait", "creates", "an", "HTTP", "handler", "on", "pidURL", "and", "serves", "the", "current", "process", "pid", "on", "it", ".", "It", "then", "creates", "a", "signal", "handler", "and", "waits", "for", "SIGTERM", "or", "SIGUSR1", "and", "returns", "when", "the", "signal", "is", "received", ".", "A", "new", "server", "that", "comes", "up", "will", "query", "this", "URL", ".", "If", "it", "receives", "a", "valid", "response", "it", "will", "send", "a", "SIGUSR1", "signal", "and", "attempt", "to", "bind", "to", "the", "port", "the", "current", "server", "is", "using", "." ]

[ "func", "ListenAndServe", "(", "port", "string", ")", "os", ".", "Signal", "{", "l", ",", "err", ":=", "Listen", "(", "port", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "go", "http", ".", "Serve", "(", "l", ",", "nil", ")", "\n", "s", ":=", "Wait", "(", ")", "\n", "l", ".", "Close", "(", ")", "\n", "return", "s", "\n", "}" ]

[ "ListenAndServe", "combines", "Listen", "and", "Wait", "to", "also", "run", "an", "http", "server", "on", "the", "specified", "port", ".", "If", "it", "fails", "to", "obtain", "a", "listener", "the", "program", "is", "fatally", "terminated", ".", "The", "return", "value", "is", "the", "signal", "received", "for", "termination" ]

[ "func", "NewEffectiveCallerID", "(", "principal", "string", ",", "component", "string", ",", "subComponent", "string", ")", "*", "vtrpcpb", ".", "CallerID", "{", "return", "&", "vtrpcpb", ".", "CallerID", "{", "Principal", ":", "principal", ",", "Component", ":", "component", ",", "Subcomponent", ":", "subComponent", "}", "\n", "}" ]

[ "NewEffectiveCallerID", "creates", "a", "new", "vtrpcpb", ".", "CallerID", "with", "principal", "component", "and", "subComponent" ]

[ "func", "printJSONData", "(", "data", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// It's possible for data to be empty. If so, we have to", "// treat it as 'null'.", "// The mysql code also says why, but this wasn't reproduceable:", "// https://github.com/mysql/mysql-server/blob/8.0/sql/json_binary.cc#L1070", "if", "len", "(", "data", ")", "==", "0", "{", "return", "[", "]", "byte", "(", "\"", "\"", ")", ",", "nil", "\n", "}", "\n", "result", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "typ", ":=", "data", "[", "0", "]", "\n", "if", "err", ":=", "printJSONValue", "(", "typ", ",", "data", "[", "1", ":", "]", ",", "true", "/* toplevel */", ",", "result", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "result", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "printJSONData", "parses", "the", "MySQL", "binary", "format", "for", "JSON", "data", "and", "prints", "the", "result", "as", "a", "string", "." ]

[ "func", "(", "tsv", "*", "TabletServer", ")", "AddStatusPart", "(", ")", "{", "servenv", ".", "AddStatusPart", "(", "\"", "\"", ",", "queryserviceStatusTemplate", ",", "func", "(", ")", "interface", "{", "}", "{", "status", ":=", "queryserviceStatus", "{", "State", ":", "tsv", ".", "GetState", "(", ")", ",", "History", ":", "tsv", ".", "history", ".", "Records", "(", ")", ",", "}", "\n", "rates", ":=", "tabletenv", ".", "QPSRates", ".", "Get", "(", ")", "\n", "if", "qps", ",", "ok", ":=", "rates", "[", "\"", "\"", "]", ";", "ok", "&&", "len", "(", "qps", ")", ">", "0", "{", "status", ".", "CurrentQPS", "=", "qps", "[", "0", "]", "\n", "}", "\n", "return", "status", "\n", "}", ")", "\n", "}" ]

[ "AddStatusPart", "registers", "the", "status", "part", "for", "the", "status", "page", "." ]

[ "func", "LogErrorsWhenClosing", "(", "in", "io", ".", "Closer", ")", "func", "(", ")", "{", "return", "func", "(", ")", "{", "err", ":=", "in", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Error", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "LogErrorsWhenClosing", "will", "close", "the", "provided", "Closer", "and", "log", "any", "errors", "it", "generates" ]

[ "func", "RegisterFlags", "(", ")", "{", "flagServerID", "=", "flag", ".", "Int", "(", "\"", "\"", ",", "0", ",", "\"", "\"", ")", "\n", "flagMysqlPort", "=", "flag", ".", "Int", "(", "\"", "\"", ",", "0", ",", "\"", "\"", ")", "\n", "flagDataDir", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagInnodbDataHomeDir", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagInnodbLogGroupHomeDir", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagSocketFile", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagGeneralLogPath", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagErrorLogPath", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagSlowLogPath", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagRelayLogPath", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagRelayLogIndexPath", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagRelayLogInfoPath", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagBinLogPath", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagMasterInfoFile", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagPidFile", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagTmpDir", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "flagSlaveLoadTmpDir", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "flagMycnfFile", "=", "flag", ".", "String", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}" ]

[ "RegisterFlags", "registers", "the", "command", "line", "flags", "for", "specifying", "the", "values", "of", "a", "mycnf", "config", "file", ".", "See", "NewMycnfFromFlags", "to", "get", "the", "supported", "modes", "." ]

[ "func", "NewTimings", "(", "name", ",", "help", ",", "label", "string", ",", "categories", "...", "string", ")", "*", "Timings", "{", "t", ":=", "&", "Timings", "{", "histograms", ":", "make", "(", "map", "[", "string", "]", "*", "Histogram", ")", ",", "help", ":", "help", ",", "label", ":", "label", ",", "}", "\n", "for", "_", ",", "cat", ":=", "range", "categories", "{", "t", ".", "histograms", "[", "cat", "]", "=", "NewGenericHistogram", "(", "\"", "\"", ",", "\"", "\"", ",", "bucketCutoffs", ",", "bucketLabels", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "t", ")", "\n", "}", "\n\n", "return", "t", "\n", "}" ]

[ "NewTimings", "creates", "a", "new", "Timings", "object", "and", "publishes", "it", "if", "name", "is", "set", ".", "categories", "is", "an", "optional", "list", "of", "categories", "to", "initialize", "to", "0", ".", "Categories", "that", "aren", "t", "initialized", "will", "be", "missing", "from", "the", "map", "until", "the", "first", "time", "they", "are", "updated", "." ]

[ "func", "safeJoinLabels", "(", "labels", "[", "]", "string", ")", "string", "{", "sanitizedLabels", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "labels", ")", ")", "\n", "for", "idx", ",", "label", ":=", "range", "labels", "{", "sanitizedLabels", "[", "idx", "]", "=", "safeLabel", "(", "label", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "sanitizedLabels", ",", "\"", "\"", ")", "\n", "}" ]

[ "safeJoinLabels", "joins", "the", "label", "values", "with", ".", "but", "first", "replaces", "any", "existing", ".", "characters", "in", "the", "labels", "with", "the", "proper", "replacement", "to", "avoid", "issues", "parsing", "them", "apart", "later", "." ]

[ "func", "(", "b", "*", "Buffer", ")", "mode", "(", "keyspace", ",", "shard", "string", ")", "bufferMode", "{", "// Actual buffering is enabled if", "// a) no keyspaces and shards were listed in particular,", "if", "*", "enabled", "&&", "len", "(", "b", ".", "keyspaces", ")", "==", "0", "&&", "len", "(", "b", ".", "shards", ")", "==", "0", "{", "// No explicit whitelist given i.e. all shards should be buffered.", "return", "bufferEnabled", "\n", "}", "\n", "// b) or this keyspace is listed,", "if", "b", ".", "keyspaces", "[", "keyspace", "]", "{", "return", "bufferEnabled", "\n", "}", "\n", "// c) or this shard is listed.", "keyspaceShard", ":=", "topoproto", ".", "KeyspaceShardString", "(", "keyspace", ",", "shard", ")", "\n", "if", "b", ".", "shards", "[", "keyspaceShard", "]", "{", "return", "bufferEnabled", "\n", "}", "\n\n", "if", "*", "enabledDryRun", "{", "return", "bufferDryRun", "\n", "}", "\n\n", "return", "bufferDisabled", "\n", "}" ]

[ "mode", "determines", "for", "the", "given", "keyspace", "and", "shard", "if", "buffering", "dry", "-", "run", "buffering", "or", "no", "buffering", "at", "all", "should", "be", "enabled", "." ]

[ "func", "(", "b", "*", "Buffer", ")", "StatsUpdate", "(", "ts", "*", "discovery", ".", "TabletStats", ")", "{", "if", "ts", ".", "Target", ".", "TabletType", "!=", "topodatapb", ".", "TabletType_MASTER", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ts", ")", ")", "\n", "}", "\n\n", "timestamp", ":=", "ts", ".", "TabletExternallyReparentedTimestamp", "\n", "if", "timestamp", "==", "0", "{", "// Masters where TabletExternallyReparented was never called will return 0.", "// Ignore them.", "return", "\n", "}", "\n\n", "sb", ":=", "b", ".", "getOrCreateBuffer", "(", "ts", ".", "Target", ".", "Keyspace", ",", "ts", ".", "Target", ".", "Shard", ")", "\n", "if", "sb", "==", "nil", "{", "// Buffer is shut down. Ignore all calls.", "return", "\n", "}", "\n", "sb", ".", "recordExternallyReparentedTimestamp", "(", "timestamp", ",", "ts", ".", "Tablet", ".", "Alias", ")", "\n", "}" ]

[ "StatsUpdate", "keeps", "track", "of", "the", "tablet_externally_reparented_timestamp", "of", "each", "master", ".", "This", "way", "we", "can", "detect", "the", "end", "of", "a", "failover", ".", "It", "is", "part", "of", "the", "discovery", ".", "HealthCheckStatsListener", "interface", "." ]

[ "func", "(", "b", "*", "Buffer", ")", "getOrCreateBuffer", "(", "keyspace", ",", "shard", "string", ")", "*", "shardBuffer", "{", "key", ":=", "topoproto", ".", "KeyspaceShardString", "(", "keyspace", ",", "shard", ")", "\n", "b", ".", "mu", ".", "RLock", "(", ")", "\n", "sb", ",", "ok", ":=", "b", ".", "buffers", "[", "key", "]", "\n", "stopped", ":=", "b", ".", "stopped", "\n", "b", ".", "mu", ".", "RUnlock", "(", ")", "\n\n", "if", "stopped", "{", "return", "nil", "\n", "}", "\n", "if", "ok", "{", "return", "sb", "\n", "}", "\n\n", "b", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "mu", ".", "Unlock", "(", ")", "\n", "// Look it up again because it could have been created in the meantime.", "sb", ",", "ok", "=", "b", ".", "buffers", "[", "key", "]", "\n", "if", "!", "ok", "{", "sb", "=", "newShardBuffer", "(", "b", ".", "mode", "(", "keyspace", ",", "shard", ")", ",", "keyspace", ",", "shard", ",", "b", ".", "now", ",", "b", ".", "bufferSizeSema", ")", "\n", "b", ".", "buffers", "[", "key", "]", "=", "sb", "\n", "}", "\n", "return", "sb", "\n", "}" ]

[ "getOrCreateBuffer", "returns", "the", "ShardBuffer", "for", "the", "given", "keyspace", "and", "shard", ".", "It", "returns", "nil", "if", "Buffer", "is", "shut", "down", "and", "all", "calls", "should", "be", "ignored", "." ]

[ "func", "addCells", "(", "left", ",", "right", "[", "]", "string", ")", "[", "]", "string", "{", "if", "len", "(", "left", ")", "==", "0", "||", "len", "(", "right", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "for", "_", ",", "cell", ":=", "range", "right", "{", "if", "!", "InCellList", "(", "cell", ",", "left", ")", "{", "left", "=", "append", "(", "left", ",", "cell", ")", "\n", "}", "\n", "}", "\n", "return", "left", "\n", "}" ]

[ "Functions", "for", "dealing", "with", "shard", "representations", "in", "topology", ".", "addCells", "will", "merge", "both", "cells", "list", "settling", "on", "nil", "if", "either", "list", "is", "empty" ]

[ "func", "removeCellsFromList", "(", "toRemove", ",", "fullList", "[", "]", "string", ")", "[", "]", "string", "{", "leftoverCells", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "for", "_", ",", "cell", ":=", "range", "fullList", "{", "if", "!", "InCellList", "(", "cell", ",", "toRemove", ")", "{", "leftoverCells", "=", "append", "(", "leftoverCells", ",", "cell", ")", "\n", "}", "\n", "}", "\n", "return", "leftoverCells", "\n", "}" ]

[ "removeCellsFromList", "will", "remove", "the", "cells", "from", "the", "provided", "list", ".", "It", "returns", "the", "new", "list", "and", "a", "boolean", "that", "indicates", "the", "returned", "list", "is", "empty", "." ]

[ "func", "removeCells", "(", "cells", ",", "toRemove", ",", "fullList", "[", "]", "string", ")", "(", "[", "]", "string", ",", "bool", ")", "{", "// The assumption here is we already migrated something,", "// and we're reverting that part. So we're gonna remove", "// records only.", "leftoverCells", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "cells", ")", ")", "\n", "if", "len", "(", "cells", ")", "==", "0", "{", "// we migrated all the cells already, take the full list", "// and remove all the ones we're not reverting", "for", "_", ",", "cell", ":=", "range", "fullList", "{", "if", "!", "InCellList", "(", "cell", ",", "toRemove", ")", "{", "leftoverCells", "=", "append", "(", "leftoverCells", ",", "cell", ")", "\n", "}", "\n", "}", "\n", "}", "else", "{", "// we migrated a subset of the cells,", "// remove the ones we're reverting", "for", "_", ",", "cell", ":=", "range", "cells", "{", "if", "!", "InCellList", "(", "cell", ",", "toRemove", ")", "{", "leftoverCells", "=", "append", "(", "leftoverCells", ",", "cell", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "leftoverCells", ")", "==", "0", "{", "// we don't have any cell left, we need to clear this record", "return", "nil", ",", "true", "\n", "}", "\n\n", "return", "leftoverCells", ",", "false", "\n", "}" ]

[ "removeCells", "will", "remove", "the", "cells", "from", "the", "provided", "list", ".", "It", "returns", "the", "new", "list", "and", "a", "boolean", "that", "indicates", "the", "returned", "list", "is", "empty", "." ]

[ "func", "ValidateShardName", "(", "shard", "string", ")", "(", "string", ",", "*", "topodatapb", ".", "KeyRange", ",", "error", ")", "{", "if", "!", "IsShardUsingRangeBasedSharding", "(", "shard", ")", "{", "return", "shard", ",", "nil", ",", "nil", "\n", "}", "\n\n", "parts", ":=", "strings", ".", "Split", "(", "shard", ",", "\"", "\"", ")", "\n", "if", "len", "(", "parts", ")", "!=", "2", "{", "return", "\"", "\"", ",", "nil", ",", "vterrors", ".", "Errorf", "(", "vtrpc", ".", "Code_INVALID_ARGUMENT", ",", "\"", "\"", ",", "shard", ")", "\n", "}", "\n\n", "keyRange", ",", "err", ":=", "key", ".", "ParseKeyRangeParts", "(", "parts", "[", "0", "]", ",", "parts", "[", "1", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "keyRange", ".", "End", ")", ">", "0", "&&", "string", "(", "keyRange", ".", "Start", ")", ">=", "string", "(", "keyRange", ".", "End", ")", "{", "return", "\"", "\"", ",", "nil", ",", "vterrors", ".", "Errorf", "(", "vtrpc", ".", "Code_INVALID_ARGUMENT", ",", "\"", "\"", ",", "hex", ".", "EncodeToString", "(", "keyRange", ".", "Start", ")", ",", "hex", ".", "EncodeToString", "(", "keyRange", ".", "End", ")", ")", "\n", "}", "\n\n", "return", "strings", ".", "ToLower", "(", "shard", ")", ",", "keyRange", ",", "nil", "\n", "}" ]

[ "ValidateShardName", "takes", "a", "shard", "name", "and", "sanitizes", "it", "and", "also", "returns", "the", "KeyRange", "." ]

[ "func", "(", "ts", "*", "Server", ")", "GetShard", "(", "ctx", "context", ".", "Context", ",", "keyspace", ",", "shard", "string", ")", "(", "*", "ShardInfo", ",", "error", ")", "{", "span", ",", "ctx", ":=", "trace", ".", "NewSpan", "(", "ctx", ",", "\"", "\"", ")", "\n", "span", ".", "Annotate", "(", "\"", "\"", ",", "keyspace", ")", "\n", "span", ".", "Annotate", "(", "\"", "\"", ",", "shard", ")", "\n", "defer", "span", ".", "Finish", "(", ")", "\n\n", "shardPath", ":=", "path", ".", "Join", "(", "KeyspacesPath", ",", "keyspace", ",", "ShardsPath", ",", "shard", ",", "ShardFile", ")", "\n", "data", ",", "version", ",", "err", ":=", "ts", ".", "globalCell", ".", "Get", "(", "ctx", ",", "shardPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "value", ":=", "&", "topodatapb", ".", "Shard", "{", "}", "\n", "if", "err", "=", "proto", ".", "Unmarshal", "(", "data", ",", "value", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "keyspace", ",", "shard", ")", "\n", "}", "\n", "return", "&", "ShardInfo", "{", "keyspace", ":", "keyspace", ",", "shardName", ":", "shard", ",", "version", ":", "version", ",", "Shard", ":", "value", ",", "}", ",", "nil", "\n", "}" ]

[ "GetShard", "is", "a", "high", "level", "function", "to", "read", "shard", "data", ".", "It", "generates", "trace", "spans", "." ]

[ "func", "(", "ts", "*", "Server", ")", "updateShard", "(", "ctx", "context", ".", "Context", ",", "si", "*", "ShardInfo", ")", "error", "{", "span", ",", "ctx", ":=", "trace", ".", "NewSpan", "(", "ctx", ",", "\"", "\"", ")", "\n", "span", ".", "Annotate", "(", "\"", "\"", ",", "si", ".", "keyspace", ")", "\n", "span", ".", "Annotate", "(", "\"", "\"", ",", "si", ".", "shardName", ")", "\n", "defer", "span", ".", "Finish", "(", ")", "\n\n", "data", ",", "err", ":=", "proto", ".", "Marshal", "(", "si", ".", "Shard", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "shardPath", ":=", "path", ".", "Join", "(", "KeyspacesPath", ",", "si", ".", "keyspace", ",", "ShardsPath", ",", "si", ".", "shardName", ",", "ShardFile", ")", "\n", "newVersion", ",", "err", ":=", "ts", ".", "globalCell", ".", "Update", "(", "ctx", ",", "shardPath", ",", "data", ",", "si", ".", "version", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "si", ".", "version", "=", "newVersion", "\n\n", "event", ".", "Dispatch", "(", "&", "events", ".", "ShardChange", "{", "KeyspaceName", ":", "si", ".", "Keyspace", "(", ")", ",", "ShardName", ":", "si", ".", "ShardName", "(", ")", ",", "Shard", ":", "si", ".", "Shard", ",", "Status", ":", "\"", "\"", ",", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "updateShard", "updates", "the", "shard", "data", "with", "the", "right", "version", ".", "It", "also", "creates", "a", "span", "and", "dispatches", "the", "event", "." ]

[ "func", "(", "ts", "*", "Server", ")", "UpdateShardFields", "(", "ctx", "context", ".", "Context", ",", "keyspace", ",", "shard", "string", ",", "update", "func", "(", "*", "ShardInfo", ")", "error", ")", "(", "*", "ShardInfo", ",", "error", ")", "{", "for", "{", "si", ",", "err", ":=", "ts", ".", "GetShard", "(", "ctx", ",", "keyspace", ",", "shard", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", "=", "update", "(", "si", ")", ";", "err", "!=", "nil", "{", "if", "IsErrType", "(", "err", ",", "NoUpdateNeeded", ")", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", "=", "ts", ".", "updateShard", "(", "ctx", ",", "si", ")", ";", "!", "IsErrType", "(", "err", ",", "BadVersion", ")", "{", "return", "si", ",", "err", "\n", "}", "\n", "}", "\n", "}" ]

[ "UpdateShardFields", "is", "a", "high", "level", "helper", "to", "read", "a", "shard", "record", "call", "an", "update", "function", "on", "it", "and", "then", "write", "it", "back", ".", "If", "the", "write", "fails", "due", "to", "a", "version", "mismatch", "it", "will", "re", "-", "read", "the", "record", "and", "retry", "the", "update", ".", "If", "the", "update", "succeeds", "it", "returns", "the", "updated", "ShardInfo", ".", "If", "the", "update", "method", "returns", "ErrNoUpdateNeeded", "nothing", "is", "written", "and", "nil", "nil", "is", "returned", ".", "Note", "the", "callback", "method", "takes", "a", "ShardInfo", "so", "it", "can", "get", "the", "keyspace", "and", "shard", "from", "it", "or", "use", "all", "the", "ShardInfo", "methods", "." ]

[ "func", "(", "ts", "*", "Server", ")", "CreateShard", "(", "ctx", "context", ".", "Context", ",", "keyspace", ",", "shard", "string", ")", "(", "err", "error", ")", "{", "// Lock the keyspace, because we'll be looking at ServedTypes.", "ctx", ",", "unlock", ",", "lockErr", ":=", "ts", ".", "LockKeyspace", "(", "ctx", ",", "keyspace", ",", "\"", "\"", ")", "\n", "if", "lockErr", "!=", "nil", "{", "return", "lockErr", "\n", "}", "\n", "defer", "unlock", "(", "&", "err", ")", "\n\n", "// validate parameters", "name", ",", "keyRange", ",", "err", ":=", "ValidateShardName", "(", "shard", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "value", ":=", "&", "topodatapb", ".", "Shard", "{", "KeyRange", ":", "keyRange", ",", "}", "\n\n", "isMasterServing", ":=", "true", "\n\n", "// start the shard IsMasterServing. If it overlaps with", "// other shards for some serving types, remove them.", "if", "IsShardUsingRangeBasedSharding", "(", "name", ")", "{", "// if we are using range-based sharding, we don't want", "// overlapping shards to all serve and confuse the clients.", "sis", ",", "err", ":=", "ts", ".", "FindAllShardsInKeyspace", "(", "ctx", ",", "keyspace", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "IsErrType", "(", "err", ",", "NoNode", ")", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "si", ":=", "range", "sis", "{", "if", "si", ".", "KeyRange", "==", "nil", "||", "key", ".", "KeyRangesIntersect", "(", "si", ".", "KeyRange", ",", "keyRange", ")", "{", "isMasterServing", "=", "false", "\n", "}", "\n", "}", "\n", "}", "\n\n", "value", ".", "IsMasterServing", "=", "isMasterServing", "\n\n", "// Marshal and save.", "data", ",", "err", ":=", "proto", ".", "Marshal", "(", "value", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "shardPath", ":=", "path", ".", "Join", "(", "KeyspacesPath", ",", "keyspace", ",", "ShardsPath", ",", "shard", ",", "ShardFile", ")", "\n", "if", "_", ",", "err", ":=", "ts", ".", "globalCell", ".", "Create", "(", "ctx", ",", "shardPath", ",", "data", ")", ";", "err", "!=", "nil", "{", "// Return error as is, we need to propagate", "// ErrNodeExists for instance.", "return", "err", "\n", "}", "\n\n", "event", ".", "Dispatch", "(", "&", "events", ".", "ShardChange", "{", "KeyspaceName", ":", "keyspace", ",", "ShardName", ":", "shard", ",", "Shard", ":", "value", ",", "Status", ":", "\"", "\"", ",", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "CreateShard", "creates", "a", "new", "shard", "and", "tries", "to", "fill", "in", "the", "right", "information", ".", "This", "will", "lock", "the", "Keyspace", "as", "we", "may", "be", "looking", "at", "other", "shard", "servedTypes", ".", "Using", "GetOrCreateShard", "is", "probably", "a", "better", "idea", "for", "most", "use", "cases", "." ]

[ "func", "(", "ts", "*", "Server", ")", "GetOrCreateShard", "(", "ctx", "context", ".", "Context", ",", "keyspace", ",", "shard", "string", ")", "(", "si", "*", "ShardInfo", ",", "err", "error", ")", "{", "si", ",", "err", "=", "ts", ".", "GetShard", "(", "ctx", ",", "keyspace", ",", "shard", ")", "\n", "if", "!", "IsErrType", "(", "err", ",", "NoNode", ")", "{", "return", "\n", "}", "\n\n", "// create the keyspace, maybe it already exists", "if", "err", "=", "ts", ".", "CreateKeyspace", "(", "ctx", ",", "keyspace", ",", "&", "topodatapb", ".", "Keyspace", "{", "}", ")", ";", "err", "!=", "nil", "&&", "!", "IsErrType", "(", "err", ",", "NodeExists", ")", "{", "return", "nil", ",", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "keyspace", ")", "\n", "}", "\n\n", "// now try to create with the lock, may already exist", "if", "err", "=", "ts", ".", "CreateShard", "(", "ctx", ",", "keyspace", ",", "shard", ")", ";", "err", "!=", "nil", "&&", "!", "IsErrType", "(", "err", ",", "NodeExists", ")", "{", "return", "nil", ",", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "keyspace", ",", "shard", ")", "\n", "}", "\n\n", "// try to read the shard again, maybe someone created it", "// in between the original GetShard and the LockKeyspace", "return", "ts", ".", "GetShard", "(", "ctx", ",", "keyspace", ",", "shard", ")", "\n", "}" ]

[ "GetOrCreateShard", "will", "return", "the", "shard", "object", "or", "create", "one", "if", "it", "doesn", "t", "already", "exist", ".", "Note", "the", "shard", "creation", "is", "protected", "by", "a", "keyspace", "Lock", "." ]

[ "func", "(", "ts", "*", "Server", ")", "DeleteShard", "(", "ctx", "context", ".", "Context", ",", "keyspace", ",", "shard", "string", ")", "error", "{", "shardPath", ":=", "path", ".", "Join", "(", "KeyspacesPath", ",", "keyspace", ",", "ShardsPath", ",", "shard", ",", "ShardFile", ")", "\n", "if", "err", ":=", "ts", ".", "globalCell", ".", "Delete", "(", "ctx", ",", "shardPath", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "event", ".", "Dispatch", "(", "&", "events", ".", "ShardChange", "{", "KeyspaceName", ":", "keyspace", ",", "ShardName", ":", "shard", ",", "Shard", ":", "nil", ",", "Status", ":", "\"", "\"", ",", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "DeleteShard", "wraps", "the", "underlying", "conn", ".", "Delete", "and", "dispatches", "the", "event", "." ]

[ "func", "(", "si", "*", "ShardInfo", ")", "GetTabletControl", "(", "tabletType", "topodatapb", ".", "TabletType", ")", "*", "topodatapb", ".", "Shard_TabletControl", "{", "for", "_", ",", "tc", ":=", "range", "si", ".", "TabletControls", "{", "if", "tc", ".", "TabletType", "==", "tabletType", "{", "return", "tc", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetTabletControl", "returns", "the", "Shard_TabletControl", "for", "the", "given", "tablet", "type", "or", "nil", "if", "it", "is", "not", "in", "the", "map", "." ]

[ "func", "(", "si", "*", "ShardInfo", ")", "GetServedType", "(", "tabletType", "topodatapb", ".", "TabletType", ")", "*", "topodatapb", ".", "Shard_ServedType", "{", "for", "_", ",", "st", ":=", "range", "si", ".", "ServedTypes", "{", "if", "st", ".", "TabletType", "==", "tabletType", "{", "return", "st", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetServedType", "returns", "the", "Shard_ServedType", "for", "a", "TabletType", "or", "nil" ]

[ "func", "InCellList", "(", "cell", "string", ",", "cells", "[", "]", "string", ")", "bool", "{", "if", "len", "(", "cells", ")", "==", "0", "{", "return", "true", "\n", "}", "\n", "for", "_", ",", "c", ":=", "range", "cells", "{", "if", "c", "==", "cell", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Utility", "functions", "for", "shards", "InCellList", "returns", "true", "if", "the", "cell", "list", "is", "empty", "or", "if", "the", "passed", "cell", "is", "in", "the", "cell", "list", "." ]

[ "func", "(", "ts", "*", "Server", ")", "FindAllTabletAliasesInShard", "(", "ctx", "context", ".", "Context", ",", "keyspace", ",", "shard", "string", ")", "(", "[", "]", "*", "topodatapb", ".", "TabletAlias", ",", "error", ")", "{", "return", "ts", ".", "FindAllTabletAliasesInShardByCell", "(", "ctx", ",", "keyspace", ",", "shard", ",", "nil", ")", "\n", "}" ]

[ "FindAllTabletAliasesInShard", "uses", "the", "replication", "graph", "to", "find", "all", "the", "tablet", "aliases", "in", "the", "given", "shard", ".", "It", "can", "return", "ErrPartialResult", "if", "some", "cells", "were", "not", "fetched", "in", "which", "case", "the", "result", "only", "contains", "the", "cells", "that", "were", "fetched", ".", "The", "tablet", "aliases", "are", "sorted", "by", "cell", "then", "by", "UID", "." ]

[ "func", "(", "ts", "*", "Server", ")", "FindAllTabletAliasesInShardByCell", "(", "ctx", "context", ".", "Context", ",", "keyspace", ",", "shard", "string", ",", "cells", "[", "]", "string", ")", "(", "[", "]", "*", "topodatapb", ".", "TabletAlias", ",", "error", ")", "{", "span", ",", "ctx", ":=", "trace", ".", "NewSpan", "(", "ctx", ",", "\"", "\"", ")", "\n", "span", ".", "Annotate", "(", "\"", "\"", ",", "keyspace", ")", "\n", "span", ".", "Annotate", "(", "\"", "\"", ",", "shard", ")", "\n", "span", ".", "Annotate", "(", "\"", "\"", ",", "len", "(", "cells", ")", ")", "\n", "defer", "span", ".", "Finish", "(", ")", "\n", "ctx", "=", "trace", ".", "NewContext", "(", "ctx", ",", "span", ")", "\n", "var", "err", "error", "\n\n", "// The caller intents to all cells", "if", "len", "(", "cells", ")", "==", "0", "{", "cells", ",", "err", "=", "ts", ".", "GetCellInfoNames", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "// read the shard information to find the cells", "si", ",", "err", ":=", "ts", ".", "GetShard", "(", "ctx", ",", "keyspace", ",", "shard", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "resultAsMap", ":=", "make", "(", "map", "[", "string", "]", "*", "topodatapb", ".", "TabletAlias", ")", "\n", "if", "si", ".", "HasMaster", "(", ")", "{", "if", "InCellList", "(", "si", ".", "MasterAlias", ".", "Cell", ",", "cells", ")", "{", "resultAsMap", "[", "topoproto", ".", "TabletAliasString", "(", "si", ".", "MasterAlias", ")", "]", "=", "si", ".", "MasterAlias", "\n", "}", "\n", "}", "\n\n", "// read the replication graph in each cell and add all found tablets", "wg", ":=", "sync", ".", "WaitGroup", "{", "}", "\n", "mutex", ":=", "sync", ".", "Mutex", "{", "}", "\n", "rec", ":=", "concurrency", ".", "AllErrorRecorder", "{", "}", "\n", "result", ":=", "make", "(", "[", "]", "*", "topodatapb", ".", "TabletAlias", ",", "0", ",", "len", "(", "resultAsMap", ")", ")", "\n", "for", "_", ",", "cell", ":=", "range", "cells", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "cell", "string", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "sri", ",", "err", ":=", "ts", ".", "GetShardReplication", "(", "ctx", ",", "cell", ",", "keyspace", ",", "shard", ")", "\n", "switch", "{", "case", "err", "==", "nil", ":", "mutex", ".", "Lock", "(", ")", "\n", "for", "_", ",", "node", ":=", "range", "sri", ".", "Nodes", "{", "resultAsMap", "[", "topoproto", ".", "TabletAliasString", "(", "node", ".", "TabletAlias", ")", "]", "=", "node", ".", "TabletAlias", "\n", "}", "\n", "mutex", ".", "Unlock", "(", ")", "\n", "case", "IsErrType", "(", "err", ",", "NoNode", ")", ":", "// There is no shard replication for this shard in this cell. NOOP", "default", ":", "rec", ".", "RecordError", "(", "vterrors", ".", "Wrap", "(", "err", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cell", ",", "keyspace", ",", "shard", ")", ")", ")", "\n", "return", "\n", "}", "\n", "}", "(", "cell", ")", "\n", "}", "\n", "wg", ".", "Wait", "(", ")", "\n", "err", "=", "nil", "\n", "if", "rec", ".", "HasErrors", "(", ")", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "keyspace", ",", "shard", ",", "rec", ".", "Error", "(", ")", ")", "\n", "err", "=", "NewError", "(", "PartialResult", ",", "shard", ")", "\n", "}", "\n\n", "for", "_", ",", "a", ":=", "range", "resultAsMap", "{", "v", ":=", "*", "a", "\n", "result", "=", "append", "(", "result", ",", "&", "v", ")", "\n", "}", "\n", "sort", ".", "Sort", "(", "topoproto", ".", "TabletAliasList", "(", "result", ")", ")", "\n", "return", "result", ",", "err", "\n", "}" ]

[ "FindAllTabletAliasesInShardByCell", "uses", "the", "replication", "graph", "to", "find", "all", "the", "tablet", "aliases", "in", "the", "given", "shard", ".", "It", "can", "return", "ErrPartialResult", "if", "some", "cells", "were", "not", "fetched", "in", "which", "case", "the", "result", "only", "contains", "the", "cells", "that", "were", "fetched", ".", "The", "tablet", "aliases", "are", "sorted", "by", "cell", "then", "by", "UID", "." ]

[ "func", "ParseGTID", "(", "flavor", ",", "value", "string", ")", "(", "GTID", ",", "error", ")", "{", "parser", ":=", "gtidParsers", "[", "flavor", "]", "\n", "if", "parser", "==", "nil", "{", "return", "nil", ",", "vterrors", ".", "Errorf", "(", "vtrpc", ".", "Code_INTERNAL", ",", "\"", "\"", ",", "flavor", ")", "\n", "}", "\n", "return", "parser", "(", "value", ")", "\n", "}" ]

[ "ParseGTID", "calls", "the", "GTID", "parser", "for", "the", "specified", "flavor", "." ]

[ "func", "MustParseGTID", "(", "flavor", ",", "value", "string", ")", "GTID", "{", "gtid", ",", "err", ":=", "ParseGTID", "(", "flavor", ",", "value", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "gtid", "\n", "}" ]

[ "MustParseGTID", "calls", "ParseGTID", "and", "panics", "on", "error", "." ]

[ "func", "EncodeGTID", "(", "gtid", "GTID", ")", "string", "{", "if", "gtid", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "gtid", ".", "Flavor", "(", ")", ",", "gtid", ".", "String", "(", ")", ")", "\n", "}" ]

[ "EncodeGTID", "returns", "a", "string", "that", "contains", "both", "the", "flavor", "and", "value", "of", "the", "GTID", "so", "that", "the", "correct", "parser", "can", "be", "selected", "when", "that", "string", "is", "passed", "to", "DecodeGTID", "." ]

[ "func", "DecodeGTID", "(", "s", "string", ")", "(", "GTID", ",", "error", ")", "{", "if", "s", "==", "\"", "\"", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "parts", ":=", "strings", ".", "SplitN", "(", "s", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "parts", ")", "!=", "2", "{", "// There is no flavor. Try looking for a default parser.", "return", "ParseGTID", "(", "\"", "\"", ",", "s", ")", "\n", "}", "\n", "return", "ParseGTID", "(", "parts", "[", "0", "]", ",", "parts", "[", "1", "]", ")", "\n", "}" ]

[ "DecodeGTID", "converts", "a", "string", "in", "the", "format", "returned", "by", "EncodeGTID", "back", "into", "a", "GTID", "interface", "value", "with", "the", "correct", "underlying", "flavor", "." ]

[ "func", "MustDecodeGTID", "(", "s", "string", ")", "GTID", "{", "gtid", ",", "err", ":=", "DecodeGTID", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "gtid", "\n", "}" ]

[ "MustDecodeGTID", "calls", "DecodeGTID", "and", "panics", "on", "error", "." ]

[ "func", "(", "bps", "*", "Stats", ")", "SetLastPosition", "(", "pos", "mysql", ".", "Position", ")", "{", "bps", ".", "lastPositionMutex", ".", "Lock", "(", ")", "\n", "defer", "bps", ".", "lastPositionMutex", ".", "Unlock", "(", ")", "\n", "bps", ".", "lastPosition", "=", "pos", "\n", "}" ]

[ "SetLastPosition", "sets", "the", "last", "replication", "position", "." ]

[ "func", "(", "bps", "*", "Stats", ")", "LastPosition", "(", ")", "mysql", ".", "Position", "{", "bps", ".", "lastPositionMutex", ".", "Lock", "(", ")", "\n", "defer", "bps", ".", "lastPositionMutex", ".", "Unlock", "(", ")", "\n", "return", "bps", ".", "lastPosition", "\n", "}" ]

[ "LastPosition", "gets", "the", "last", "replication", "position", "." ]

[ "func", "(", "bps", "*", "Stats", ")", "MessageHistory", "(", ")", "[", "]", "string", "{", "strs", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "3", ")", "\n", "for", "_", ",", "h", ":=", "range", "bps", ".", "History", ".", "Records", "(", ")", "{", "h1", ",", "_", ":=", "h", ".", "(", "*", "StatsHistoryRecord", ")", "\n", "if", "h1", "!=", "nil", "{", "strs", "=", "append", "(", "strs", ",", "h1", ".", "Message", ")", "\n", "}", "\n", "}", "\n", "return", "strs", "\n", "}" ]

[ "MessageHistory", "gets", "all", "the", "messages", "we", "store", "3", "at", "a", "time" ]

[ "func", "NewStats", "(", ")", "*", "Stats", "{", "bps", ":=", "&", "Stats", "{", "}", "\n", "bps", ".", "Timings", "=", "stats", ".", "NewTimings", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "bps", ".", "Rates", "=", "stats", ".", "NewRates", "(", "\"", "\"", ",", "bps", ".", "Timings", ",", "15", ",", "60e9", ")", "\n", "bps", ".", "History", "=", "history", ".", "New", "(", "3", ")", "\n", "bps", ".", "SecondsBehindMaster", ".", "Set", "(", "math", ".", "MaxInt64", ")", "\n", "return", "bps", "\n", "}" ]

[ "NewStats", "creates", "a", "new", "Stats", "structure", "." ]

[ "func", "(", "blp", "*", "BinlogPlayer", ")", "ApplyBinlogEvents", "(", "ctx", "context", ".", "Context", ")", "error", "{", "if", "err", ":=", "SetVReplicationState", "(", "blp", ".", "dbClient", ",", "blp", ".", "uid", ",", "BlpRunning", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "blp", ".", "applyEvents", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "msg", ":=", "err", ".", "Error", "(", ")", "\n", "blp", ".", "blplStats", ".", "History", ".", "Add", "(", "&", "StatsHistoryRecord", "{", "Time", ":", "time", ".", "Now", "(", ")", ",", "Message", ":", "msg", ",", "}", ")", "\n", "if", "err", ":=", "SetVReplicationState", "(", "blp", ".", "dbClient", ",", "blp", ".", "uid", ",", "BlpError", ",", "msg", ")", ";", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ApplyBinlogEvents", "makes", "an", "RPC", "request", "to", "BinlogServer", "and", "processes", "the", "events", ".", "It", "returns", "nil", "if", "the", "provided", "context", "was", "canceled", "or", "if", "we", "reached", "the", "stopping", "point", ".", "If", "an", "error", "is", "encountered", "it", "updates", "the", "vreplication", "state", "to", "Error", ".", "If", "a", "stop", "position", "was", "specifed", "and", "reached", "the", "state", "is", "updated", "to", "Stopped", "." ]

[ "func", "SetVReplicationState", "(", "dbClient", "DBClient", ",", "uid", "uint32", ",", "state", ",", "message", "string", ")", "error", "{", "query", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "state", ",", "encodeString", "(", "message", ")", ",", "uid", ")", "\n", "if", "_", ",", "err", ":=", "dbClient", ".", "ExecuteFetch", "(", "query", ",", "1", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "query", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SetVReplicationState", "updates", "the", "state", "in", "the", "_vt", ".", "vreplication", "table", "." ]

[ "func", "ReadVRSettings", "(", "dbClient", "DBClient", ",", "uid", "uint32", ")", "(", "VRSettings", ",", "error", ")", "{", "query", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "uid", ")", "\n", "qr", ",", "err", ":=", "dbClient", ".", "ExecuteFetch", "(", "query", ",", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "VRSettings", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "query", ")", "\n", "}", "\n\n", "if", "len", "(", "qr", ".", "Rows", ")", "!=", "1", "{", "return", "VRSettings", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uid", ")", "\n", "}", "\n", "vrRow", ":=", "qr", ".", "Rows", "[", "0", "]", "\n\n", "maxTPS", ",", "err", ":=", "sqltypes", ".", "ToInt64", "(", "vrRow", "[", "2", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "VRSettings", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "maxReplicationLag", ",", "err", ":=", "sqltypes", ".", "ToInt64", "(", "vrRow", "[", "3", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "VRSettings", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "startPos", ",", "err", ":=", "mysql", ".", "DecodePosition", "(", "vrRow", "[", "0", "]", ".", "ToString", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "VRSettings", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "stopPos", ",", "err", ":=", "mysql", ".", "DecodePosition", "(", "vrRow", "[", "1", "]", ".", "ToString", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "VRSettings", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "VRSettings", "{", "StartPos", ":", "startPos", ",", "StopPos", ":", "stopPos", ",", "MaxTPS", ":", "maxTPS", ",", "MaxReplicationLag", ":", "maxReplicationLag", ",", "State", ":", "vrRow", "[", "4", "]", ".", "ToString", "(", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "ReadVRSettings", "retrieves", "the", "throttler", "settings", "for", "vreplication", "from", "the", "checkpoint", "table", "." ]

[ "func", "CreateVReplication", "(", "workflow", "string", ",", "source", "*", "binlogdatapb", ".", "BinlogSource", ",", "position", "string", ",", "maxTPS", ",", "maxReplicationLag", ",", "timeUpdated", "int64", ",", "dbName", "string", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "encodeString", "(", "workflow", ")", ",", "encodeString", "(", "source", ".", "String", "(", ")", ")", ",", "encodeString", "(", "position", ")", ",", "maxTPS", ",", "maxReplicationLag", ",", "timeUpdated", ",", "BlpRunning", ",", "encodeString", "(", "dbName", ")", ")", "\n", "}" ]

[ "CreateVReplication", "returns", "a", "statement", "to", "populate", "the", "first", "value", "into", "the", "_vt", ".", "vreplication", "table", "." ]

[ "func", "CreateVReplicationState", "(", "workflow", "string", ",", "source", "*", "binlogdatapb", ".", "BinlogSource", ",", "position", ",", "state", "string", ",", "dbName", "string", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "encodeString", "(", "workflow", ")", ",", "encodeString", "(", "source", ".", "String", "(", ")", ")", ",", "encodeString", "(", "position", ")", ",", "throttler", ".", "MaxRateModuleDisabled", ",", "throttler", ".", "ReplicationLagModuleDisabled", ",", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ",", "state", ",", "encodeString", "(", "dbName", ")", ")", "\n", "}" ]

[ "CreateVReplicationState", "returns", "a", "statement", "to", "create", "a", "stopped", "vreplication", "." ]

[ "func", "GenerateUpdatePos", "(", "uid", "uint32", ",", "pos", "mysql", ".", "Position", ",", "timeUpdated", "int64", ",", "txTimestamp", "int64", ")", "string", "{", "if", "txTimestamp", "!=", "0", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "encodeString", "(", "mysql", ".", "EncodePosition", "(", "pos", ")", ")", ",", "timeUpdated", ",", "txTimestamp", ",", "uid", ")", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "encodeString", "(", "mysql", ".", "EncodePosition", "(", "pos", ")", ")", ",", "timeUpdated", ",", "uid", ")", "\n", "}" ]

[ "GenerateUpdatePos", "returns", "a", "statement", "to", "update", "a", "value", "in", "the", "_vt", ".", "vreplication", "table", "." ]

[ "func", "StartVReplicationUntil", "(", "uid", "uint32", ",", "pos", "string", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "BlpRunning", ",", "encodeString", "(", "pos", ")", ",", "uid", ")", "\n", "}" ]

[ "StartVReplicationUntil", "returns", "a", "statement", "to", "start", "the", "replication", "with", "a", "stop", "position", "." ]

[ "func", "StopVReplication", "(", "uid", "uint32", ",", "message", "string", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "BlpStopped", ",", "encodeString", "(", "message", ")", ",", "uid", ")", "\n", "}" ]

[ "StopVReplication", "returns", "a", "statement", "to", "stop", "the", "replication", "." ]

[ "func", "NewActionRepository", "(", "ts", "*", "topo", ".", "Server", ")", "*", "ActionRepository", "{", "return", "&", "ActionRepository", "{", "keyspaceActions", ":", "make", "(", "map", "[", "string", "]", "actionKeyspaceMethod", ")", ",", "shardActions", ":", "make", "(", "map", "[", "string", "]", "actionShardMethod", ")", ",", "tabletActions", ":", "make", "(", "map", "[", "string", "]", "actionTabletRecord", ")", ",", "ts", ":", "ts", ",", "}", "\n", "}" ]

[ "NewActionRepository", "creates", "and", "returns", "a", "new", "ActionRepository", "with", "no", "actions", "." ]

[ "func", "(", "ar", "*", "ActionRepository", ")", "RegisterKeyspaceAction", "(", "name", "string", ",", "method", "actionKeyspaceMethod", ")", "{", "ar", ".", "keyspaceActions", "[", "name", "]", "=", "method", "\n", "}" ]

[ "RegisterKeyspaceAction", "registers", "a", "new", "action", "on", "a", "keyspace", "." ]

[ "func", "(", "ar", "*", "ActionRepository", ")", "RegisterShardAction", "(", "name", "string", ",", "method", "actionShardMethod", ")", "{", "ar", ".", "shardActions", "[", "name", "]", "=", "method", "\n", "}" ]

[ "RegisterShardAction", "registers", "a", "new", "action", "on", "a", "shard", "." ]

[ "func", "(", "ar", "*", "ActionRepository", ")", "RegisterTabletAction", "(", "name", ",", "role", "string", ",", "method", "actionTabletMethod", ")", "{", "ar", ".", "tabletActions", "[", "name", "]", "=", "actionTabletRecord", "{", "role", ":", "role", ",", "method", ":", "method", ",", "}", "\n", "}" ]

[ "RegisterTabletAction", "registers", "a", "new", "action", "on", "a", "tablet", "." ]

[ "func", "(", "ar", "*", "ActionRepository", ")", "ApplyKeyspaceAction", "(", "ctx", "context", ".", "Context", ",", "actionName", ",", "keyspace", "string", ",", "r", "*", "http", ".", "Request", ")", "*", "ActionResult", "{", "result", ":=", "&", "ActionResult", "{", "Name", ":", "actionName", ",", "Parameters", ":", "keyspace", "}", "\n\n", "action", ",", "ok", ":=", "ar", ".", "keyspaceActions", "[", "actionName", "]", "\n", "if", "!", "ok", "{", "result", ".", "error", "(", "\"", "\"", ")", "\n", "return", "result", "\n", "}", "\n\n", "ctx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "ctx", ",", "*", "actionTimeout", ")", "\n", "wr", ":=", "wrangler", ".", "New", "(", "logutil", ".", "NewConsoleLogger", "(", ")", ",", "ar", ".", "ts", ",", "tmclient", ".", "NewTabletManagerClient", "(", ")", ")", "\n", "output", ",", "err", ":=", "action", "(", "ctx", ",", "wr", ",", "keyspace", ",", "r", ")", "\n", "cancel", "(", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "result", "\n", "}", "\n", "result", ".", "Output", "=", "output", "\n", "return", "result", "\n", "}" ]

[ "ApplyKeyspaceAction", "applies", "the", "provided", "action", "to", "the", "keyspace", "." ]

[ "func", "(", "ar", "*", "ActionRepository", ")", "ApplyTabletAction", "(", "ctx", "context", ".", "Context", ",", "actionName", "string", ",", "tabletAlias", "*", "topodatapb", ".", "TabletAlias", ",", "r", "*", "http", ".", "Request", ")", "*", "ActionResult", "{", "result", ":=", "&", "ActionResult", "{", "Name", ":", "actionName", ",", "Parameters", ":", "topoproto", ".", "TabletAliasString", "(", "tabletAlias", ")", ",", "}", "\n\n", "action", ",", "ok", ":=", "ar", ".", "tabletActions", "[", "actionName", "]", "\n", "if", "!", "ok", "{", "result", ".", "error", "(", "\"", "\"", ")", "\n", "return", "result", "\n", "}", "\n\n", "// check the role", "if", "action", ".", "role", "!=", "\"", "\"", "{", "if", "err", ":=", "acl", ".", "CheckAccessHTTP", "(", "r", ",", "action", ".", "role", ")", ";", "err", "!=", "nil", "{", "result", ".", "error", "(", "\"", "\"", ")", "\n", "return", "result", "\n", "}", "\n", "}", "\n\n", "// run the action", "ctx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "ctx", ",", "*", "actionTimeout", ")", "\n", "wr", ":=", "wrangler", ".", "New", "(", "logutil", ".", "NewConsoleLogger", "(", ")", ",", "ar", ".", "ts", ",", "tmclient", ".", "NewTabletManagerClient", "(", ")", ")", "\n", "output", ",", "err", ":=", "action", ".", "method", "(", "ctx", ",", "wr", ",", "tabletAlias", ",", "r", ")", "\n", "cancel", "(", ")", "\n", "if", "err", "!=", "nil", "{", "result", ".", "error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "result", "\n", "}", "\n", "result", ".", "Output", "=", "output", "\n", "return", "result", "\n", "}" ]

[ "ApplyTabletAction", "applies", "the", "provided", "action", "to", "the", "tablet", "." ]

[ "func", "resetVars", "(", ")", "{", "statsState", ".", "Set", "(", "\"", "\"", ")", "\n", "statsRetryCount", ".", "Reset", "(", ")", "\n", "statsRetryCounters", ".", "ResetAll", "(", ")", "\n\n", "statsOnlineInsertsCounters", ".", "ResetAll", "(", ")", "\n", "statsOnlineUpdatesCounters", ".", "ResetAll", "(", ")", "\n", "statsOnlineDeletesCounters", ".", "ResetAll", "(", ")", "\n", "statsOnlineEqualRowsCounters", ".", "ResetAll", "(", ")", "\n\n", "statsOfflineInsertsCounters", ".", "ResetAll", "(", ")", "\n", "statsOfflineUpdatesCounters", ".", "ResetAll", "(", ")", "\n", "statsOfflineDeletesCounters", ".", "ResetAll", "(", ")", "\n", "statsOfflineEqualRowsCounters", ".", "ResetAll", "(", ")", "\n\n", "statsStreamingQueryCounters", ".", "ResetAll", "(", ")", "\n", "statsStreamingQueryErrorsCounters", ".", "ResetAll", "(", ")", "\n", "}" ]

[ "resetVars", "resets", "the", "debug", "variables", "that", "are", "meant", "to", "provide", "information", "on", "a", "per", "-", "run", "basis", ".", "This", "should", "be", "called", "at", "the", "beginning", "of", "each", "worker", "run", "." ]

[ "func", "NewSimpleRoute", "(", "opcode", "RouteOpcode", ",", "keyspace", "*", "vindexes", ".", "Keyspace", ")", "*", "Route", "{", "return", "&", "Route", "{", "Opcode", ":", "opcode", ",", "Keyspace", ":", "keyspace", ",", "}", "\n", "}" ]

[ "NewSimpleRoute", "creates", "a", "Route", "with", "the", "bare", "minimum", "of", "parameters", "." ]

[ "func", "NewRoute", "(", "opcode", "RouteOpcode", ",", "keyspace", "*", "vindexes", ".", "Keyspace", ",", "query", ",", "fieldQuery", "string", ")", "*", "Route", "{", "return", "&", "Route", "{", "Opcode", ":", "opcode", ",", "Keyspace", ":", "keyspace", ",", "Query", ":", "query", ",", "FieldQuery", ":", "fieldQuery", ",", "}", "\n", "}" ]

[ "NewRoute", "creates", "a", "Route", "." ]

[ "func", "(", "route", "*", "Route", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "var", "vindexName", "string", "\n", "if", "route", ".", "Vindex", "!=", "nil", "{", "vindexName", "=", "route", ".", "Vindex", ".", "String", "(", ")", "\n", "}", "\n", "marshalRoute", ":=", "struct", "{", "Opcode", "RouteOpcode", "\n", "Keyspace", "*", "vindexes", ".", "Keyspace", "`json:\",omitempty\"`", "\n", "Query", "string", "`json:\",omitempty\"`", "\n", "FieldQuery", "string", "`json:\",omitempty\"`", "\n", "Vindex", "string", "`json:\",omitempty\"`", "\n", "Values", "[", "]", "sqltypes", ".", "PlanValue", "`json:\",omitempty\"`", "\n", "OrderBy", "[", "]", "OrderbyParams", "`json:\",omitempty\"`", "\n", "TruncateColumnCount", "int", "`json:\",omitempty\"`", "\n", "QueryTimeout", "int", "`json:\",omitempty\"`", "\n", "ScatterErrorsAsWarnings", "bool", "`json:\",omitempty\"`", "\n", "}", "{", "Opcode", ":", "route", ".", "Opcode", ",", "Keyspace", ":", "route", ".", "Keyspace", ",", "Query", ":", "route", ".", "Query", ",", "FieldQuery", ":", "route", ".", "FieldQuery", ",", "Vindex", ":", "vindexName", ",", "Values", ":", "route", ".", "Values", ",", "OrderBy", ":", "route", ".", "OrderBy", ",", "TruncateColumnCount", ":", "route", ".", "TruncateColumnCount", ",", "QueryTimeout", ":", "route", ".", "QueryTimeout", ",", "ScatterErrorsAsWarnings", ":", "route", ".", "ScatterErrorsAsWarnings", ",", "}", "\n", "return", "jsonutil", ".", "MarshalNoEscape", "(", "marshalRoute", ")", "\n", "}" ]

[ "MarshalJSON", "serializes", "the", "Route", "into", "a", "JSON", "representation", ".", "It", "s", "used", "for", "testing", "and", "diagnostics", "." ]

[ "func", "NewCounterDuration", "(", "name", ",", "help", "string", ")", "*", "CounterDuration", "{", "cd", ":=", "&", "CounterDuration", "{", "help", ":", "help", ",", "}", "\n", "publish", "(", "name", ",", "cd", ")", "\n", "return", "cd", "\n", "}" ]

[ "NewCounterDuration", "returns", "a", "new", "CounterDuration", "." ]

[ "func", "(", "cd", "CounterDuration", ")", "String", "(", ")", "string", "{", "return", "strconv", ".", "FormatInt", "(", "int64", "(", "cd", ".", "i", ".", "Get", "(", ")", ")", ",", "10", ")", "\n", "}" ]

[ "String", "is", "the", "implementation", "of", "expvar", ".", "var", "." ]

[ "func", "(", "cd", "*", "CounterDuration", ")", "Add", "(", "delta", "time", ".", "Duration", ")", "{", "cd", ".", "i", ".", "Add", "(", "delta", ")", "\n", "}" ]

[ "Add", "adds", "the", "provided", "value", "to", "the", "CounterDuration", "." ]

[ "func", "NewGaugeDuration", "(", "name", ",", "help", "string", ")", "*", "GaugeDuration", "{", "gd", ":=", "&", "GaugeDuration", "{", "CounterDuration", ":", "CounterDuration", "{", "help", ":", "help", ",", "}", ",", "}", "\n", "publish", "(", "name", ",", "gd", ")", "\n", "return", "gd", "\n", "}" ]

[ "NewGaugeDuration", "returns", "a", "new", "GaugeDuration", "." ]

[ "func", "(", "gd", "*", "GaugeDuration", ")", "Set", "(", "value", "time", ".", "Duration", ")", "{", "gd", ".", "i", ".", "Set", "(", "value", ")", "\n", "}" ]

[ "Set", "sets", "the", "value", "." ]

[ "func", "NewCounterDurationFunc", "(", "name", "string", ",", "help", "string", ",", "f", "func", "(", ")", "time", ".", "Duration", ")", "*", "CounterDurationFunc", "{", "cf", ":=", "&", "CounterDurationFunc", "{", "F", ":", "f", ",", "help", ":", "help", ",", "}", "\n\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "cf", ")", "\n", "}", "\n", "return", "cf", "\n", "}" ]

[ "NewCounterDurationFunc", "creates", "a", "new", "CounterDurationFunc", "instance", "and", "publishes", "it", "if", "name", "is", "set", "." ]

[ "func", "NewGaugeDurationFunc", "(", "name", "string", ",", "help", "string", ",", "f", "func", "(", ")", "time", ".", "Duration", ")", "*", "GaugeDurationFunc", "{", "gf", ":=", "&", "GaugeDurationFunc", "{", "CounterDurationFunc", ":", "CounterDurationFunc", "{", "F", ":", "f", ",", "help", ":", "help", ",", "}", ",", "}", "\n\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "gf", ")", "\n", "}", "\n", "return", "gf", "\n", "}" ]

[ "NewGaugeDurationFunc", "creates", "a", "new", "GaugeDurationFunc", "instance", "and", "publishes", "it", "if", "name", "is", "set", "." ]

[ "func", "NewReplicationWatcher", "(", "se", "*", "schema", ".", "Engine", ",", "config", "tabletenv", ".", "TabletConfig", ")", "*", "ReplicationWatcher", "{", "rpw", ":=", "&", "ReplicationWatcher", "{", "watchReplication", ":", "config", ".", "WatchReplication", ",", "se", ":", "se", ",", "}", "\n", "replOnce", ".", "Do", "(", "func", "(", ")", "{", "stats", ".", "Publish", "(", "\"", "\"", ",", "stats", ".", "StringFunc", "(", "func", "(", ")", "string", "{", "if", "e", ":=", "rpw", ".", "EventToken", "(", ")", ";", "e", "!=", "nil", "{", "return", "e", ".", "Position", "\n", "}", "\n", "return", "\"", "\"", "\n", "}", ")", ")", "\n", "stats", ".", "NewGaugeFunc", "(", "\"", "\"", ",", "\"", "\"", ",", "func", "(", ")", "int64", "{", "if", "e", ":=", "rpw", ".", "EventToken", "(", ")", ";", "e", "!=", "nil", "{", "return", "e", ".", "Timestamp", "\n", "}", "\n", "return", "0", "\n", "}", ")", "\n", "}", ")", "\n", "return", "rpw", "\n", "}" ]

[ "NewReplicationWatcher", "creates", "a", "new", "ReplicationWatcher", "." ]

[ "func", "(", "rpw", "*", "ReplicationWatcher", ")", "Open", "(", ")", "{", "if", "rpw", ".", "isOpen", "||", "!", "rpw", ".", "watchReplication", "{", "return", "\n", "}", "\n", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "tabletenv", ".", "LocalContext", "(", ")", ")", "\n", "rpw", ".", "cancel", "=", "cancel", "\n", "rpw", ".", "wg", ".", "Add", "(", "1", ")", "\n", "go", "rpw", ".", "Process", "(", "ctx", ",", "rpw", ".", "dbconfigs", ")", "\n", "rpw", ".", "isOpen", "=", "true", "\n", "}" ]

[ "Open", "starts", "the", "ReplicationWatcher", "service", "." ]

[ "func", "(", "rpw", "*", "ReplicationWatcher", ")", "Close", "(", ")", "{", "if", "!", "rpw", ".", "isOpen", "{", "return", "\n", "}", "\n", "rpw", ".", "cancel", "(", ")", "\n", "rpw", ".", "wg", ".", "Wait", "(", ")", "\n", "rpw", ".", "isOpen", "=", "false", "\n", "}" ]

[ "Close", "stops", "the", "ReplicationWatcher", "service", "." ]

[ "func", "(", "rpw", "*", "ReplicationWatcher", ")", "Process", "(", "ctx", "context", ".", "Context", ",", "dbconfigs", "*", "dbconfigs", ".", "DBConfigs", ")", "{", "defer", "func", "(", ")", "{", "tabletenv", ".", "LogError", "(", ")", "\n", "rpw", ".", "wg", ".", "Done", "(", ")", "\n", "}", "(", ")", "\n", "for", "{", "log", ".", "Infof", "(", "\"", "\"", ")", "\n", "streamer", ":=", "binlog", ".", "NewStreamer", "(", "dbconfigs", ".", "DbaWithDB", "(", ")", ",", "rpw", ".", "se", ",", "nil", "/*clientCharset*/", ",", "mysql", ".", "Position", "{", "}", ",", "0", "/*timestamp*/", ",", "func", "(", "eventToken", "*", "querypb", ".", "EventToken", ",", "statements", "[", "]", "binlog", ".", "FullBinlogStatement", ")", "error", "{", "// Save the event token.", "rpw", ".", "mu", ".", "Lock", "(", ")", "\n", "rpw", ".", "eventToken", "=", "eventToken", "\n", "rpw", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// If it's a DDL, trigger a schema reload.", "for", "_", ",", "statement", ":=", "range", "statements", "{", "if", "statement", ".", "Statement", ".", "Category", "!=", "binlogdatapb", ".", "BinlogTransaction_Statement_BL_DDL", "{", "continue", "\n", "}", "\n", "err", ":=", "rpw", ".", "se", ".", "Reload", "(", "ctx", ")", "\n", "log", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n\n", "return", "nil", "\n", "}", ")", "\n\n", "if", "err", ":=", "streamer", ".", "Stream", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "log", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "\n", "case", "<-", "time", ".", "After", "(", "5", "*", "time", ".", "Second", ")", ":", "}", "\n", "}", "\n", "}" ]

[ "Process", "processes", "the", "replication", "stream", "." ]

[ "func", "(", "rpw", "*", "ReplicationWatcher", ")", "ComputeExtras", "(", "options", "*", "querypb", ".", "ExecuteOptions", ")", "*", "querypb", ".", "ResultExtras", "{", "if", "options", "==", "nil", "{", "// No options passed in.", "return", "nil", "\n", "}", "\n\n", "if", "!", "options", ".", "IncludeEventToken", "&&", "options", ".", "CompareEventToken", "==", "nil", "{", "// The flags that make extras exist are not there.", "return", "nil", "\n", "}", "\n\n", "et", ":=", "rpw", ".", "EventToken", "(", ")", "\n", "if", "et", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "var", "extras", "*", "querypb", ".", "ResultExtras", "\n\n", "// See if we need to fill in EventToken.", "if", "options", ".", "IncludeEventToken", "{", "extras", "=", "&", "querypb", ".", "ResultExtras", "{", "EventToken", ":", "et", ",", "}", "\n", "}", "\n\n", "// See if we need to compare.", "if", "options", ".", "CompareEventToken", "!=", "nil", "{", "if", "eventtoken", ".", "Fresher", "(", "et", ",", "options", ".", "CompareEventToken", ")", ">=", "0", "{", "// For a query, we are fresher if greater or equal", "// to the provided compare_event_token.", "if", "extras", "==", "nil", "{", "extras", "=", "&", "querypb", ".", "ResultExtras", "{", "Fresher", ":", "true", ",", "}", "\n", "}", "else", "{", "extras", ".", "Fresher", "=", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "extras", "\n", "}" ]

[ "ComputeExtras", "returns", "the", "requested", "ResultExtras", "based", "on", "the", "supplied", "options", "." ]