Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.1k

[ "func", "NewFactory", "(", "state", "*", "uniter", ".", "State", ",", "paths", "context", ".", "Paths", ",", "contextFactory", "context", ".", "ContextFactory", ",", ")", "(", "Factory", ",", "error", ",", ")", "{", "f", ":=", "&", "factory", "{", "state", ":", "state", ",", "paths", ":", "paths", ",", "contextFactory", ":", "contextFactory", ",", "}", "\n\n", "return", "f", ",", "nil", "\n", "}" ]

[ "NewFactory", "returns", "a", "Factory", "capable", "of", "creating", "runners", "for", "executing", "charm", "hooks", "actions", "and", "commands", "." ]

[ "func", "(", "f", "*", "factory", ")", "NewCommandRunner", "(", "commandInfo", "context", ".", "CommandInfo", ")", "(", "Runner", ",", "error", ")", "{", "ctx", ",", "err", ":=", "f", ".", "contextFactory", ".", "CommandContext", "(", "commandInfo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "runner", ":=", "NewRunner", "(", "ctx", ",", "f", ".", "paths", ")", "\n", "return", "runner", ",", "nil", "\n", "}" ]

[ "NewCommandRunner", "exists", "to", "satisfy", "the", "Factory", "interface", "." ]

[ "func", "(", "f", "*", "factory", ")", "NewHookRunner", "(", "hookInfo", "hook", ".", "Info", ")", "(", "Runner", ",", "error", ")", "{", "if", "err", ":=", "hookInfo", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "ctx", ",", "err", ":=", "f", ".", "contextFactory", ".", "HookContext", "(", "hookInfo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "runner", ":=", "NewRunner", "(", "ctx", ",", "f", ".", "paths", ")", "\n", "return", "runner", ",", "nil", "\n", "}" ]

[ "NewHookRunner", "exists", "to", "satisfy", "the", "Factory", "interface", "." ]

[ "func", "(", "f", "*", "factory", ")", "NewActionRunner", "(", "actionId", "string", ")", "(", "Runner", ",", "error", ")", "{", "ch", ",", "err", ":=", "getCharm", "(", "f", ".", "paths", ".", "GetCharmDir", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "ok", ":=", "names", ".", "IsValidAction", "(", "actionId", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "charmrunner", ".", "NewBadActionError", "(", "actionId", ",", "\"", "\"", ")", "\n", "}", "\n", "tag", ":=", "names", ".", "NewActionTag", "(", "actionId", ")", "\n", "action", ",", "err", ":=", "f", ".", "state", ".", "Action", "(", "tag", ")", "\n", "if", "params", ".", "IsCodeNotFoundOrCodeUnauthorized", "(", "err", ")", "{", "return", "nil", ",", "charmrunner", ".", "ErrActionNotAvailable", "\n", "}", "else", "if", "params", ".", "IsCodeActionNotAvailable", "(", "err", ")", "{", "return", "nil", ",", "charmrunner", ".", "ErrActionNotAvailable", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "name", ":=", "action", ".", "Name", "(", ")", "\n\n", "spec", ",", "ok", ":=", "actions", ".", "PredefinedActionsSpec", "[", "name", "]", "\n", "if", "!", "ok", "{", "var", "ok", "bool", "\n", "spec", ",", "ok", "=", "ch", ".", "Actions", "(", ")", ".", "ActionSpecs", "[", "name", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "charmrunner", ".", "NewBadActionError", "(", "name", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "params", ":=", "action", ".", "Params", "(", ")", "\n", "if", "err", ":=", "spec", ".", "ValidateParams", "(", "params", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "charmrunner", ".", "NewBadActionError", "(", "name", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "actionData", ":=", "context", ".", "NewActionData", "(", "name", ",", "&", "tag", ",", "params", ")", "\n", "ctx", ",", "err", ":=", "f", ".", "contextFactory", ".", "ActionContext", "(", "actionData", ")", "\n", "runner", ":=", "NewRunner", "(", "ctx", ",", "f", ".", "paths", ")", "\n", "return", "runner", ",", "nil", "\n", "}" ]

[ "NewActionRunner", "exists", "to", "satisfy", "the", "Factory", "interface", "." ]

[ "func", "(", "env", "*", "environ", ")", "prefixedInstances", "(", "prefix", "string", ")", "(", "[", "]", "*", "environInstance", ",", "error", ")", "{", "containers", ",", "err", ":=", "env", ".", "server", "(", ")", ".", "AliveContainers", "(", "prefix", ")", "\n", "err", "=", "errors", ".", "Trace", "(", "err", ")", "\n\n", "// Turn lxd.Container values into *environInstance values,", "// whether or not we got an error.", "var", "results", "[", "]", "*", "environInstance", "\n", "for", "_", ",", "c", ":=", "range", "containers", "{", "c", ":=", "c", "\n", "inst", ":=", "newInstance", "(", "&", "c", ",", "env", ")", "\n", "results", "=", "append", "(", "results", ",", "inst", ")", "\n", "}", "\n", "return", "results", ",", "err", "\n", "}" ]

[ "prefixedInstances", "returns", "instances", "with", "the", "specified", "prefix", "." ]

[ "func", "(", "env", "*", "environ", ")", "AdoptResources", "(", "ctx", "context", ".", "ProviderCallContext", ",", "controllerUUID", "string", ",", "fromVersion", "version", ".", "Number", ")", "error", "{", "instances", ",", "err", ":=", "env", ".", "AllInstances", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "common", ".", "HandleCredentialError", "(", "IsAuthorisationFailure", ",", "err", ",", "ctx", ")", "\n", "return", "errors", ".", "Annotate", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "var", "failed", "[", "]", "instance", ".", "Id", "\n", "qualifiedKey", ":=", "lxd", ".", "UserNamespacePrefix", "+", "tags", ".", "JujuController", "\n", "for", "_", ",", "instance", ":=", "range", "instances", "{", "id", ":=", "instance", ".", "Id", "(", ")", "\n", "// TODO (manadart 2018-06-27) This is a smell.", "// Everywhere else, we update the container config on a container and then call WriteContainer.", "// If we added a method directly to environInstance to do this, we wouldn't need this", "// implementation of UpdateContainerConfig at all, and the container representation we are", "// holding would be consistent with that on the server.", "err", ":=", "env", ".", "server", "(", ")", ".", "UpdateContainerConfig", "(", "string", "(", "id", ")", ",", "map", "[", "string", "]", "string", "{", "qualifiedKey", ":", "controllerUUID", "}", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "id", ",", "err", ")", "\n", "failed", "=", "append", "(", "failed", ",", "id", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "failed", ")", "!=", "0", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "failed", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "AdoptResources", "updates", "the", "controller", "tags", "on", "all", "instances", "to", "have", "the", "new", "controller", "id", ".", "It", "s", "part", "of", "the", "Environ", "interface", "." ]

[ "func", "NewStateCrossModelRelationsAPI", "(", "ctx", "facade", ".", "Context", ")", "(", "*", "CrossModelRelationsAPI", ",", "error", ")", "{", "authCtxt", ":=", "ctx", ".", "Resources", "(", ")", ".", "Get", "(", "\"", "\"", ")", ".", "(", "common", ".", "ValueResource", ")", ".", "Value", "\n", "st", ":=", "ctx", ".", "State", "(", ")", "\n", "model", ",", "err", ":=", "st", ".", "Model", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "NewCrossModelRelationsAPI", "(", "stateShim", "{", "st", ":", "st", ",", "Backend", ":", "commoncrossmodel", ".", "GetBackend", "(", "st", ")", ",", "}", ",", "firewall", ".", "StateShim", "(", "st", ",", "model", ")", ",", "ctx", ".", "Resources", "(", ")", ",", "ctx", ".", "Auth", "(", ")", ",", "authCtxt", ".", "(", "*", "commoncrossmodel", ".", "AuthContext", ")", ",", "firewall", ".", "WatchEgressAddressesForRelations", ",", "watchRelationLifeSuspendedStatus", ",", "watchOfferStatus", ",", ")", "\n", "}" ]

[ "NewStateCrossModelRelationsAPI", "creates", "a", "new", "server", "-", "side", "CrossModelRelations", "API", "facade", "backed", "by", "global", "state", "." ]

[ "func", "NewCrossModelRelationsAPI", "(", "st", "CrossModelRelationsState", ",", "fw", "firewall", ".", "State", ",", "resources", "facade", ".", "Resources", ",", "authorizer", "facade", ".", "Authorizer", ",", "authCtxt", "*", "commoncrossmodel", ".", "AuthContext", ",", "egressAddressWatcher", "egressAddressWatcherFunc", ",", "relationStatusWatcher", "relationStatusWatcherFunc", ",", "offerStatusWatcher", "offerStatusWatcherFunc", ",", ")", "(", "*", "CrossModelRelationsAPI", ",", "error", ")", "{", "return", "&", "CrossModelRelationsAPI", "{", "st", ":", "st", ",", "fw", ":", "fw", ",", "resources", ":", "resources", ",", "authorizer", ":", "authorizer", ",", "authCtxt", ":", "authCtxt", ",", "egressAddressWatcher", ":", "egressAddressWatcher", ",", "relationStatusWatcher", ":", "relationStatusWatcher", ",", "offerStatusWatcher", ":", "offerStatusWatcher", ",", "relationToOffer", ":", "make", "(", "map", "[", "string", "]", "string", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "NewCrossModelRelationsAPI", "returns", "a", "new", "server", "-", "side", "CrossModelRelationsAPI", "facade", "." ]

[ "func", "(", "api", "*", "CrossModelRelationsAPI", ")", "PublishRelationChanges", "(", "changes", "params", ".", "RemoteRelationsChanges", ",", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "results", ":=", "params", ".", "ErrorResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "changes", ".", "Changes", ")", ")", ",", "}", "\n", "for", "i", ",", "change", ":=", "range", "changes", ".", "Changes", "{", "relationTag", ",", "err", ":=", "api", ".", "st", ".", "GetRemoteEntity", "(", "change", ".", "RelationToken", ")", "\n", "if", "err", "!=", "nil", "{", "if", "errors", ".", "IsNotFound", "(", "err", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "change", ".", "RelationToken", ",", "api", ".", "st", ".", "ModelUUID", "(", ")", ")", "\n", "continue", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "change", ".", "RelationToken", ",", "relationTag", ")", "\n", "if", "err", ":=", "api", ".", "checkMacaroonsForRelation", "(", "relationTag", ",", "change", ".", "Macaroons", ")", ";", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "err", ":=", "commoncrossmodel", ".", "PublishRelationChange", "(", "api", ".", "st", ",", "relationTag", ",", "change", ")", ";", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "change", ".", "Life", "!=", "params", ".", "Alive", "{", "delete", "(", "api", ".", "relationToOffer", ",", "relationTag", ".", "Id", "(", ")", ")", "\n", "}", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "PublishRelationChanges", "publishes", "relation", "changes", "to", "the", "model", "hosting", "the", "remote", "application", "involved", "in", "the", "relation", "." ]

[ "func", "(", "api", "*", "CrossModelRelationsAPI", ")", "RegisterRemoteRelations", "(", "relations", "params", ".", "RegisterRemoteRelationArgs", ",", ")", "(", "params", ".", "RegisterRemoteRelationResults", ",", "error", ")", "{", "results", ":=", "params", ".", "RegisterRemoteRelationResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "RegisterRemoteRelationResult", ",", "len", "(", "relations", ".", "Relations", ")", ")", ",", "}", "\n", "for", "i", ",", "relation", ":=", "range", "relations", ".", "Relations", "{", "id", ",", "err", ":=", "api", ".", "registerRemoteRelation", "(", "relation", ")", "\n", "results", ".", "Results", "[", "i", "]", ".", "Result", "=", "id", "\n", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "RegisterRemoteRelationArgs", "sets", "up", "the", "model", "to", "participate", "in", "the", "specified", "relations", ".", "This", "operation", "is", "idempotent", "." ]

[ "func", "(", "api", "*", "CrossModelRelationsAPI", ")", "WatchRelationUnits", "(", "remoteRelationArgs", "params", ".", "RemoteEntityArgs", ")", "(", "params", ".", "RelationUnitsWatchResults", ",", "error", ")", "{", "results", ":=", "params", ".", "RelationUnitsWatchResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "RelationUnitsWatchResult", ",", "len", "(", "remoteRelationArgs", ".", "Args", ")", ")", ",", "}", "\n", "for", "i", ",", "arg", ":=", "range", "remoteRelationArgs", ".", "Args", "{", "relationTag", ",", "err", ":=", "api", ".", "st", ".", "GetRemoteEntity", "(", "arg", ".", "Token", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "err", ":=", "api", ".", "checkMacaroonsForRelation", "(", "relationTag", ",", "arg", ".", "Macaroons", ")", ";", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "w", ",", "err", ":=", "commoncrossmodel", ".", "WatchRelationUnits", "(", "api", ".", "st", ",", "relationTag", ".", "(", "names", ".", "RelationTag", ")", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "changes", ",", "ok", ":=", "<-", "w", ".", "Changes", "(", ")", "\n", "if", "!", "ok", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "watcher", ".", "EnsureErr", "(", "w", ")", ")", "\n", "continue", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "RelationUnitsWatcherId", "=", "api", ".", "resources", ".", "Register", "(", "w", ")", "\n", "results", ".", "Results", "[", "i", "]", ".", "Changes", "=", "changes", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "WatchRelationUnits", "starts", "a", "RelationUnitsWatcher", "for", "watching", "the", "relation", "units", "involved", "in", "each", "specified", "relation", "and", "returns", "the", "watcher", "IDs", "and", "initial", "values", "or", "an", "error", "if", "the", "relation", "units", "could", "not", "be", "watched", "." ]

[ "func", "(", "api", "*", "CrossModelRelationsAPI", ")", "RelationUnitSettings", "(", "relationUnits", "params", ".", "RemoteRelationUnits", ")", "(", "params", ".", "SettingsResults", ",", "error", ")", "{", "results", ":=", "params", ".", "SettingsResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "SettingsResult", ",", "len", "(", "relationUnits", ".", "RelationUnits", ")", ")", ",", "}", "\n", "for", "i", ",", "arg", ":=", "range", "relationUnits", ".", "RelationUnits", "{", "relationTag", ",", "err", ":=", "api", ".", "st", ".", "GetRemoteEntity", "(", "arg", ".", "RelationToken", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "err", ":=", "api", ".", "checkMacaroonsForRelation", "(", "relationTag", ",", "arg", ".", "Macaroons", ")", ";", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "ru", ":=", "params", ".", "RelationUnit", "{", "Relation", ":", "relationTag", ".", "String", "(", ")", ",", "Unit", ":", "arg", ".", "Unit", ",", "}", "\n", "settings", ",", "err", ":=", "commoncrossmodel", ".", "RelationUnitSettings", "(", "api", ".", "st", ",", "ru", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "Settings", "=", "settings", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "RelationUnitSettings", "returns", "the", "relation", "unit", "settings", "for", "the", "given", "relation", "units", "." ]

[ "func", "(", "api", "*", "CrossModelRelationsAPI", ")", "WatchRelationsSuspendedStatus", "(", "remoteRelationArgs", "params", ".", "RemoteEntityArgs", ",", ")", "(", "params", ".", "RelationStatusWatchResults", ",", "error", ")", "{", "results", ":=", "params", ".", "RelationStatusWatchResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "RelationLifeSuspendedStatusWatchResult", ",", "len", "(", "remoteRelationArgs", ".", "Args", ")", ")", ",", "}", "\n\n", "for", "i", ",", "arg", ":=", "range", "remoteRelationArgs", ".", "Args", "{", "relationTag", ",", "err", ":=", "api", ".", "st", ".", "GetRemoteEntity", "(", "arg", ".", "Token", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "err", ":=", "api", ".", "checkMacaroonsForRelation", "(", "relationTag", ",", "arg", ".", "Macaroons", ")", ";", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "w", ",", "err", ":=", "api", ".", "relationStatusWatcher", "(", "api", ".", "st", ",", "relationTag", ".", "(", "names", ".", "RelationTag", ")", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "changes", ",", "ok", ":=", "<-", "w", ".", "Changes", "(", ")", "\n", "if", "!", "ok", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "watcher", ".", "EnsureErr", "(", "w", ")", ")", "\n", "continue", "\n", "}", "\n", "changesParams", ":=", "make", "(", "[", "]", "params", ".", "RelationLifeSuspendedStatusChange", ",", "len", "(", "changes", ")", ")", "\n", "for", "j", ",", "key", ":=", "range", "changes", "{", "change", ",", "err", ":=", "commoncrossmodel", ".", "GetRelationLifeSuspendedStatusChange", "(", "api", ".", "st", ",", "key", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "changesParams", "=", "nil", "\n", "w", ".", "Stop", "(", ")", "\n", "break", "\n", "}", "\n", "changesParams", "[", "j", "]", "=", "*", "change", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "Changes", "=", "changesParams", "\n", "results", ".", "Results", "[", "i", "]", ".", "RelationStatusWatcherId", "=", "api", ".", "resources", ".", "Register", "(", "w", ")", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "WatchRelationsSuspendedStatus", "starts", "a", "RelationStatusWatcher", "for", "watching", "the", "life", "and", "suspended", "status", "of", "a", "relation", "." ]

[ "func", "(", "api", "*", "CrossModelRelationsAPI", ")", "WatchOfferStatus", "(", "offerArgs", "params", ".", "OfferArgs", ",", ")", "(", "params", ".", "OfferStatusWatchResults", ",", "error", ")", "{", "results", ":=", "params", ".", "OfferStatusWatchResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "OfferStatusWatchResult", ",", "len", "(", "offerArgs", ".", "Args", ")", ")", ",", "}", "\n\n", "for", "i", ",", "arg", ":=", "range", "offerArgs", ".", "Args", "{", "// Ensure the supplied macaroon allows access.", "auth", ":=", "api", ".", "authCtxt", ".", "Authenticator", "(", "api", ".", "st", ".", "ModelUUID", "(", ")", ",", "arg", ".", "OfferUUID", ")", "\n", "_", ",", "err", ":=", "auth", ".", "CheckOfferMacaroons", "(", "arg", ".", "OfferUUID", ",", "arg", ".", "Macaroons", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n\n", "w", ",", "err", ":=", "api", ".", "offerStatusWatcher", "(", "api", ".", "st", ",", "arg", ".", "OfferUUID", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "_", ",", "ok", ":=", "<-", "w", ".", "Changes", "(", ")", "\n", "if", "!", "ok", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "watcher", ".", "EnsureErr", "(", "w", ")", ")", "\n", "continue", "\n", "}", "\n", "change", ",", "err", ":=", "commoncrossmodel", ".", "GetOfferStatusChange", "(", "api", ".", "st", ",", "arg", ".", "OfferUUID", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "w", ".", "Stop", "(", ")", "\n", "break", "\n", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "Changes", "=", "[", "]", "params", ".", "OfferStatusChange", "{", "*", "change", "}", "\n", "results", ".", "Results", "[", "i", "]", ".", "OfferStatusWatcherId", "=", "api", ".", "resources", ".", "Register", "(", "w", ")", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "WatchOfferStatus", "starts", "an", "OfferStatusWatcher", "for", "watching", "the", "status", "of", "an", "offer", "." ]

[ "func", "(", "api", "*", "CrossModelRelationsAPI", ")", "PublishIngressNetworkChanges", "(", "changes", "params", ".", "IngressNetworksChanges", ",", ")", "(", "params", ".", "ErrorResults", ",", "error", ")", "{", "results", ":=", "params", ".", "ErrorResults", "{", "Results", ":", "make", "(", "[", "]", "params", ".", "ErrorResult", ",", "len", "(", "changes", ".", "Changes", ")", ")", ",", "}", "\n", "for", "i", ",", "change", ":=", "range", "changes", ".", "Changes", "{", "relationTag", ",", "err", ":=", "api", ".", "st", ".", "GetRemoteEntity", "(", "change", ".", "RelationToken", ")", "\n", "if", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "change", ".", "RelationToken", ",", "relationTag", ")", "\n\n", "if", "err", ":=", "api", ".", "checkMacaroonsForRelation", "(", "relationTag", ",", "change", ".", "Macaroons", ")", ";", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "err", ":=", "commoncrossmodel", ".", "PublishIngressNetworkChange", "(", "api", ".", "st", ",", "relationTag", ",", "change", ")", ";", "err", "!=", "nil", "{", "results", ".", "Results", "[", "i", "]", ".", "Error", "=", "common", ".", "ServerError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "PublishIngressNetworkChanges", "publishes", "changes", "to", "the", "required", "ingress", "addresses", "to", "the", "model", "hosting", "the", "offer", "in", "the", "relation", "." ]

[ "func", "(", "n", "*", "netPackageConfigSource", ")", "InterfaceAddresses", "(", "name", "string", ")", "(", "[", "]", "net", ".", "Addr", ",", "error", ")", "{", "iface", ",", "err", ":=", "net", ".", "InterfaceByName", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "iface", ".", "Addrs", "(", ")", "\n", "}" ]

[ "InterfaceAddresses", "implements", "NetworkConfigSource", "." ]

[ "func", "(", "c", "PublicClient", ")", "ListFull", "(", "patterns", "...", "string", ")", "(", "[", "]", "payload", ".", "FullPayloadInfo", ",", "error", ")", "{", "var", "result", "params", ".", "PayloadListResults", "\n\n", "args", ":=", "params", ".", "PayloadListArgs", "{", "Patterns", ":", "patterns", ",", "}", "\n", "if", "err", ":=", "c", ".", "FacadeCall", "(", "\"", "\"", ",", "&", "args", ",", "&", "result", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "payloads", ":=", "make", "(", "[", "]", "payload", ".", "FullPayloadInfo", ",", "len", "(", "result", ".", "Results", ")", ")", "\n", "for", "i", ",", "apiInfo", ":=", "range", "result", ".", "Results", "{", "payload", ",", "err", ":=", "api", ".", "API2Payload", "(", "apiInfo", ")", "\n", "if", "err", "!=", "nil", "{", "// We should never see this happen; we control the input safely.", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "payloads", "[", "i", "]", "=", "payload", "\n", "}", "\n", "return", "payloads", ",", "nil", "\n", "}" ]

[ "ListFull", "calls", "the", "List", "API", "server", "method", "." ]

[ "func", "ConvertActionResults", "(", "result", "params", ".", "ActionResult", ",", "query", "actionQuery", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "values", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "values", "[", "query", ".", "receiver", ".", "receiverType", "]", "=", "query", ".", "receiver", ".", "tag", ".", "Id", "(", ")", "\n", "if", "result", ".", "Error", "!=", "nil", "{", "values", "[", "\"", "\"", "]", "=", "result", ".", "Error", ".", "Error", "(", ")", "\n", "values", "[", "\"", "\"", "]", "=", "query", ".", "actionTag", ".", "Id", "(", ")", "\n", "return", "values", "\n", "}", "\n", "if", "result", ".", "Action", ".", "Tag", "!=", "query", ".", "actionTag", ".", "String", "(", ")", "{", "values", "[", "\"", "\"", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "query", ".", "actionTag", ".", "String", "(", ")", ",", "result", ".", "Action", ".", "Tag", ")", "\n", "values", "[", "\"", "\"", "]", "=", "query", ".", "actionTag", ".", "Id", "(", ")", "\n", "return", "values", "\n", "}", "\n", "if", "result", ".", "Action", ".", "Receiver", "!=", "query", ".", "receiver", ".", "tag", ".", "String", "(", ")", "{", "values", "[", "\"", "\"", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "query", ".", "receiver", ".", "tag", ".", "String", "(", ")", ",", "result", ".", "Action", ".", "Receiver", ")", "\n", "values", "[", "\"", "\"", "]", "=", "query", ".", "actionTag", ".", "Id", "(", ")", "\n", "return", "values", "\n", "}", "\n", "if", "result", ".", "Message", "!=", "\"", "\"", "{", "values", "[", "\"", "\"", "]", "=", "result", ".", "Message", "\n", "}", "\n", "// We always want to have a string for stdout, but only show stderr,", "// code and error if they are there.", "if", "res", ",", "ok", ":=", "result", ".", "Output", "[", "\"", "\"", "]", ".", "(", "string", ")", ";", "ok", "{", "values", "[", "\"", "\"", "]", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\\r", "\\n", "\"", ",", "\"", "\\n", "\"", ",", "-", "1", ")", "\n", "if", "res", ",", "ok", ":=", "result", ".", "Output", "[", "\"", "\"", "]", ".", "(", "string", ")", ";", "ok", "&&", "res", "!=", "\"", "\"", "{", "values", "[", "\"", "\"", "]", "=", "res", "\n", "}", "\n", "}", "else", "{", "values", "[", "\"", "\"", "]", "=", "\"", "\"", "\n", "}", "\n", "if", "res", ",", "ok", ":=", "result", ".", "Output", "[", "\"", "\"", "]", ".", "(", "string", ")", ";", "ok", "&&", "res", "!=", "\"", "\"", "{", "values", "[", "\"", "\"", "]", "=", "strings", ".", "Replace", "(", "res", ",", "\"", "\\r", "\\n", "\"", ",", "\"", "\\n", "\"", ",", "-", "1", ")", "\n", "if", "res", ",", "ok", ":=", "result", ".", "Output", "[", "\"", "\"", "]", ".", "(", "string", ")", ";", "ok", "&&", "res", "!=", "\"", "\"", "{", "values", "[", "\"", "\"", "]", "=", "res", "\n", "}", "\n", "}", "\n", "if", "res", ",", "ok", ":=", "result", ".", "Output", "[", "\"", "\"", "]", ".", "(", "string", ")", ";", "ok", "{", "code", ",", "err", ":=", "strconv", ".", "Atoi", "(", "res", ")", "\n", "if", "err", "==", "nil", "&&", "code", "!=", "0", "{", "values", "[", "\"", "\"", "]", "=", "code", "\n", "}", "\n", "}", "\n", "return", "values", "\n", "}" ]

[ "ConvertActionResults", "takes", "the", "results", "from", "the", "api", "and", "creates", "a", "map", "suitable", "for", "format", "conversion", "to", "YAML", "or", "JSON", "." ]

[ "func", "entities", "(", "actions", "[", "]", "actionQuery", ")", "params", ".", "Entities", "{", "entities", ":=", "params", ".", "Entities", "{", "Entities", ":", "make", "(", "[", "]", "params", ".", "Entity", ",", "len", "(", "actions", ")", ")", ",", "}", "\n", "for", "i", ",", "action", ":=", "range", "actions", "{", "entities", ".", "Entities", "[", "i", "]", ".", "Tag", "=", "action", ".", "actionTag", ".", "String", "(", ")", "\n", "}", "\n", "return", "entities", "\n", "}" ]

[ "entities", "is", "a", "convenience", "constructor", "for", "params", ".", "Entities", "." ]

[ "func", "(", "c", "*", "Client", ")", "SetMetricCredentials", "(", "application", "string", ",", "credentials", "[", "]", "byte", ")", "error", "{", "creds", ":=", "[", "]", "params", ".", "ApplicationMetricCredential", "{", "{", "application", ",", "credentials", "}", ",", "}", "\n", "p", ":=", "params", ".", "ApplicationMetricCredentials", "{", "Creds", ":", "creds", "}", "\n", "results", ":=", "new", "(", "params", ".", "ErrorResults", ")", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "p", ",", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "results", ".", "OneError", "(", ")", ")", "\n", "}" ]

[ "SetMetricCredentials", "sets", "the", "metric", "credentials", "for", "the", "application", "specified", "." ]

[ "func", "(", "c", "*", "Client", ")", "ModelUUID", "(", ")", "string", "{", "tag", ",", "ok", ":=", "c", ".", "st", ".", "ModelTag", "(", ")", "\n", "if", "!", "ok", "{", "logger", ".", "Warningf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "tag", ".", "Id", "(", ")", "\n", "}" ]

[ "ModelUUID", "returns", "the", "model", "UUID", "from", "the", "client", "connection", "." ]

[ "func", "(", "c", "*", "Client", ")", "Deploy", "(", "args", "DeployArgs", ")", "error", "{", "if", "len", "(", "args", ".", "AttachStorage", ")", ">", "0", "{", "if", "args", ".", "NumUnits", "!=", "1", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "BestAPIVersion", "(", ")", "<", "5", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "attachStorage", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "args", ".", "AttachStorage", ")", ")", "\n", "for", "i", ",", "id", ":=", "range", "args", ".", "AttachStorage", "{", "if", "!", "names", ".", "IsValidStorage", "(", "id", ")", "{", "return", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "attachStorage", "[", "i", "]", "=", "names", ".", "NewStorageTag", "(", "id", ")", ".", "String", "(", ")", "\n", "}", "\n", "deployArgs", ":=", "params", ".", "ApplicationsDeploy", "{", "Applications", ":", "[", "]", "params", ".", "ApplicationDeploy", "{", "{", "ApplicationName", ":", "args", ".", "ApplicationName", ",", "Series", ":", "args", ".", "Series", ",", "CharmURL", ":", "args", ".", "CharmID", ".", "URL", ".", "String", "(", ")", ",", "Channel", ":", "string", "(", "args", ".", "CharmID", ".", "Channel", ")", ",", "NumUnits", ":", "args", ".", "NumUnits", ",", "ConfigYAML", ":", "args", ".", "ConfigYAML", ",", "Config", ":", "args", ".", "Config", ",", "Constraints", ":", "args", ".", "Cons", ",", "Placement", ":", "args", ".", "Placement", ",", "Storage", ":", "args", ".", "Storage", ",", "Devices", ":", "args", ".", "Devices", ",", "AttachStorage", ":", "attachStorage", ",", "EndpointBindings", ":", "args", ".", "EndpointBindings", ",", "Resources", ":", "args", ".", "Resources", ",", "}", "}", ",", "}", "\n", "var", "results", "params", ".", "ErrorResults", "\n", "var", "err", "error", "\n", "err", "=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "deployArgs", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "errors", ".", "Trace", "(", "results", ".", "OneError", "(", ")", ")", "\n", "}" ]

[ "Deploy", "obtains", "the", "charm", "either", "locally", "or", "from", "the", "charm", "store", "and", "deploys", "it", ".", "Placement", "directives", "if", "provided", "specify", "the", "machine", "on", "which", "the", "charm", "is", "deployed", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetConfig", "(", "branchName", "string", ",", "appNames", "...", "string", ")", "(", "[", "]", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "v", ":=", "c", ".", "BestAPIVersion", "(", ")", "\n\n", "if", "v", "<", "5", "{", "settings", ",", "err", ":=", "c", ".", "getConfigV4", "(", "branchName", ",", "appNames", ")", "\n", "return", "settings", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "callName", ":=", "\"", "\"", "\n", "if", "v", "<", "6", "{", "callName", "=", "\"", "\"", "\n", "}", "\n\n", "var", "callArg", "interface", "{", "}", "\n", "if", "v", "<", "9", "{", "arg", ":=", "params", ".", "Entities", "{", "Entities", ":", "make", "(", "[", "]", "params", ".", "Entity", ",", "len", "(", "appNames", ")", ")", "}", "\n", "for", "i", ",", "appName", ":=", "range", "appNames", "{", "arg", ".", "Entities", "[", "i", "]", "=", "params", ".", "Entity", "{", "Tag", ":", "names", ".", "NewApplicationTag", "(", "appName", ")", ".", "String", "(", ")", "}", "\n", "}", "\n", "callArg", "=", "arg", "\n", "}", "else", "{", "// Version 9 of the API introduces generational config.", "arg", ":=", "params", ".", "ApplicationGetArgs", "{", "Args", ":", "make", "(", "[", "]", "params", ".", "ApplicationGet", ",", "len", "(", "appNames", ")", ")", "}", "\n", "for", "i", ",", "appName", ":=", "range", "appNames", "{", "arg", ".", "Args", "[", "i", "]", "=", "params", ".", "ApplicationGet", "{", "ApplicationName", ":", "appName", ",", "BranchName", ":", "branchName", "}", "\n", "}", "\n", "callArg", "=", "arg", "\n", "}", "\n\n", "var", "results", "params", ".", "ApplicationGetConfigResults", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "callName", ",", "callArg", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "var", "settings", "[", "]", "map", "[", "string", "]", "interface", "{", "}", "\n", "for", "i", ",", "result", ":=", "range", "results", ".", "Results", "{", "if", "result", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "appNames", "[", "i", "]", ")", "\n", "}", "\n", "settings", "=", "append", "(", "settings", ",", "result", ".", "Config", ")", "\n", "}", "\n", "return", "settings", ",", "nil", "\n", "}" ]

[ "GetConfig", "returns", "the", "charm", "configuration", "settings", "for", "each", "of", "the", "applications", ".", "If", "any", "of", "the", "applications", "are", "not", "found", "an", "error", "is", "returned", "." ]

[ "func", "(", "c", "*", "Client", ")", "getConfigV4", "(", "branchName", "string", ",", "appNames", "[", "]", "string", ")", "(", "[", "]", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "var", "allSettings", "[", "]", "map", "[", "string", "]", "interface", "{", "}", "\n", "for", "_", ",", "appName", ":=", "range", "appNames", "{", "results", ",", "err", ":=", "c", ".", "Get", "(", "branchName", ",", "appName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "appName", ")", "\n", "}", "\n", "settings", ",", "err", ":=", "describeV5", "(", "results", ".", "CharmConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Annotatef", "(", "err", ",", "\"", "\"", ",", "appName", ")", "\n", "}", "\n", "allSettings", "=", "append", "(", "allSettings", ",", "settings", ")", "\n", "}", "\n", "return", "allSettings", ",", "nil", "\n", "}" ]

[ "getConfigV4", "retrieves", "application", "config", "for", "versions", "of", "the", "API", "<", "5", "." ]

[ "func", "describeV5", "(", "config", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "for", "_", ",", "value", ":=", "range", "config", "{", "vMap", ",", "ok", ":=", "value", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "value", ",", "value", ")", "\n", "}", "\n", "if", "_", ",", "found", ":=", "vMap", "[", "\"", "\"", "]", ";", "found", "{", "v", ",", "hasValue", ":=", "vMap", "[", "\"", "\"", "]", "\n", "if", "hasValue", "{", "vMap", "[", "\"", "\"", "]", "=", "v", "\n", "vMap", "[", "\"", "\"", "]", "=", "\"", "\"", "\n", "}", "else", "{", "delete", "(", "vMap", ",", "\"", "\"", ")", "\n", "vMap", "[", "\"", "\"", "]", "=", "\"", "\"", "\n", "}", "\n", "}", "else", "{", "// If default isn't set, then the source is user.", "// And we have no idea what the charm default is or whether", "// there is one.", "vMap", "[", "\"", "\"", "]", "=", "\"", "\"", "\n", "}", "\n", "}", "\n", "return", "config", ",", "nil", "\n", "}" ]

[ "describeV5", "will", "take", "the", "results", "of", "describeV4", "from", "the", "apiserver", "and", "remove", "the", "default", "boolean", "and", "add", "in", "source", ".", "Mutates", "and", "returns", "the", "config", "map", "." ]

[ "func", "(", "c", "*", "Client", ")", "SetCharm", "(", "branchName", "string", ",", "cfg", "SetCharmConfig", ")", "error", "{", "var", "storageConstraints", "map", "[", "string", "]", "params", ".", "StorageConstraints", "\n", "if", "len", "(", "cfg", ".", "StorageConstraints", ")", ">", "0", "{", "storageConstraints", "=", "make", "(", "map", "[", "string", "]", "params", ".", "StorageConstraints", ")", "\n", "for", "name", ",", "cons", ":=", "range", "cfg", ".", "StorageConstraints", "{", "size", ",", "count", ":=", "cons", ".", "Size", ",", "cons", ".", "Count", "\n", "var", "sizePtr", ",", "countPtr", "*", "uint64", "\n", "if", "size", ">", "0", "{", "sizePtr", "=", "&", "size", "\n", "}", "\n", "if", "count", ">", "0", "{", "countPtr", "=", "&", "count", "\n", "}", "\n", "storageConstraints", "[", "name", "]", "=", "params", ".", "StorageConstraints", "{", "Pool", ":", "cons", ".", "Pool", ",", "Size", ":", "sizePtr", ",", "Count", ":", "countPtr", ",", "}", "\n", "}", "\n", "}", "\n", "args", ":=", "params", ".", "ApplicationSetCharm", "{", "ApplicationName", ":", "cfg", ".", "ApplicationName", ",", "CharmURL", ":", "cfg", ".", "CharmID", ".", "URL", ".", "String", "(", ")", ",", "Channel", ":", "string", "(", "cfg", ".", "CharmID", ".", "Channel", ")", ",", "ConfigSettings", ":", "cfg", ".", "ConfigSettings", ",", "ConfigSettingsYAML", ":", "cfg", ".", "ConfigSettingsYAML", ",", "Force", ":", "cfg", ".", "Force", ",", "ForceSeries", ":", "cfg", ".", "ForceSeries", ",", "ForceUnits", ":", "cfg", ".", "ForceUnits", ",", "ResourceIDs", ":", "cfg", ".", "ResourceIDs", ",", "StorageConstraints", ":", "storageConstraints", ",", "Generation", ":", "branchName", ",", "}", "\n", "return", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "nil", ")", "\n", "}" ]

[ "SetCharm", "sets", "the", "charm", "for", "a", "given", "application", "." ]

[ "func", "(", "c", "*", "Client", ")", "Update", "(", "args", "params", ".", "ApplicationUpdate", ")", "error", "{", "return", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "nil", ")", "\n", "}" ]

[ "Update", "updates", "the", "application", "attributes", "including", "charm", "URL", "minimum", "number", "of", "units", "settings", "and", "constraints", "." ]

[ "func", "(", "c", "*", "Client", ")", "UpdateApplicationSeries", "(", "appName", ",", "series", "string", ",", "force", "bool", ")", "error", "{", "args", ":=", "params", ".", "UpdateSeriesArgs", "{", "Args", ":", "[", "]", "params", ".", "UpdateSeriesArg", "{", "{", "Entity", ":", "params", ".", "Entity", "{", "Tag", ":", "names", ".", "NewApplicationTag", "(", "appName", ")", ".", "String", "(", ")", "}", ",", "Force", ":", "force", ",", "Series", ":", "series", ",", "}", "}", ",", "}", "\n\n", "results", ":=", "new", "(", "params", ".", "ErrorResults", ")", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "results", ".", "OneError", "(", ")", "\n", "}" ]

[ "UpdateApplicationSeries", "updates", "the", "application", "series", "in", "the", "db", "." ]

[ "func", "(", "c", "*", "Client", ")", "AddUnits", "(", "args", "AddUnitsParams", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "len", "(", "args", ".", "AttachStorage", ")", ">", "0", "{", "if", "args", ".", "NumUnits", "!=", "1", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "BestAPIVersion", "(", ")", "<", "5", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "attachStorage", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "args", ".", "AttachStorage", ")", ")", "\n", "for", "i", ",", "id", ":=", "range", "args", ".", "AttachStorage", "{", "if", "!", "names", ".", "IsValidStorage", "(", "id", ")", "{", "return", "nil", ",", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "attachStorage", "[", "i", "]", "=", "names", ".", "NewStorageTag", "(", "id", ")", ".", "String", "(", ")", "\n", "}", "\n", "results", ":=", "new", "(", "params", ".", "AddApplicationUnitsResults", ")", "\n", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "params", ".", "AddApplicationUnits", "{", "ApplicationName", ":", "args", ".", "ApplicationName", ",", "NumUnits", ":", "args", ".", "NumUnits", ",", "Placement", ":", "args", ".", "Placement", ",", "Policy", ":", "args", ".", "Policy", ",", "AttachStorage", ":", "attachStorage", ",", "}", ",", "results", ")", "\n", "return", "results", ".", "Units", ",", "err", "\n", "}" ]

[ "AddUnits", "adds", "a", "given", "number", "of", "units", "to", "an", "application", "using", "the", "specified", "placement", "directives", "to", "assign", "units", "to", "machines", "." ]

[ "func", "(", "c", "*", "Client", ")", "DestroyUnits", "(", "in", "DestroyUnitsParams", ")", "(", "[", "]", "params", ".", "DestroyUnitResult", ",", "error", ")", "{", "argsV5", ":=", "params", ".", "DestroyUnitsParams", "{", "Units", ":", "make", "(", "[", "]", "params", ".", "DestroyUnitParams", ",", "0", ",", "len", "(", "in", ".", "Units", ")", ")", ",", "}", "\n", "allResults", ":=", "make", "(", "[", "]", "params", ".", "DestroyUnitResult", ",", "len", "(", "in", ".", "Units", ")", ")", "\n", "index", ":=", "make", "(", "[", "]", "int", ",", "0", ",", "len", "(", "in", ".", "Units", ")", ")", "\n", "for", "i", ",", "name", ":=", "range", "in", ".", "Units", "{", "if", "!", "names", ".", "IsValidUnit", "(", "name", ")", "{", "allResults", "[", "i", "]", ".", "Error", "=", "&", "params", ".", "Error", "{", "Message", ":", "errors", ".", "NotValidf", "(", "\"", "\"", ",", "name", ")", ".", "Error", "(", ")", ",", "}", "\n", "continue", "\n", "}", "\n", "index", "=", "append", "(", "index", ",", "i", ")", "\n", "argsV5", ".", "Units", "=", "append", "(", "argsV5", ".", "Units", ",", "params", ".", "DestroyUnitParams", "{", "UnitTag", ":", "names", ".", "NewUnitTag", "(", "name", ")", ".", "String", "(", ")", ",", "DestroyStorage", ":", "in", ".", "DestroyStorage", ",", "Force", ":", "in", ".", "Force", ",", "MaxWait", ":", "in", ".", "MaxWait", ",", "}", ")", "\n", "}", "\n", "if", "len", "(", "argsV5", ".", "Units", ")", "==", "0", "{", "return", "allResults", ",", "nil", "\n", "}", "\n\n", "args", ":=", "interface", "{", "}", "(", "argsV5", ")", "\n", "if", "c", ".", "BestAPIVersion", "(", ")", "<", "5", "{", "if", "in", ".", "DestroyStorage", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "argsV4", ":=", "params", ".", "Entities", "{", "Entities", ":", "make", "(", "[", "]", "params", ".", "Entity", ",", "len", "(", "argsV5", ".", "Units", ")", ")", ",", "}", "\n", "for", "i", ",", "arg", ":=", "range", "argsV5", ".", "Units", "{", "argsV4", ".", "Entities", "[", "i", "]", ".", "Tag", "=", "arg", ".", "UnitTag", "\n", "}", "\n", "args", "=", "argsV4", "\n", "}", "\n\n", "var", "result", "params", ".", "DestroyUnitResults", "\n", "if", "err", ":=", "c", ".", "facade", ".", "FacadeCall", "(", "\"", "\"", ",", "args", ",", "&", "result", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "n", ":=", "len", "(", "result", ".", "Results", ")", ";", "n", "!=", "len", "(", "argsV5", ".", "Units", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "argsV5", ".", "Units", ")", ",", "n", ")", "\n", "}", "\n", "for", "i", ",", "result", ":=", "range", "result", ".", "Results", "{", "allResults", "[", "index", "[", "i", "]", "]", "=", "result", "\n", "}", "\n", "return", "allResults", ",", "nil", "\n", "}" ]

[ "DestroyUnits", "decreases", "the", "number", "of", "units", "dedicated", "to", "one", "or", "more", "applications", "." ]

[ "func", "(", "oa", "*", "orderedAggregate", ")", "SetGroupBy", "(", "groupBy", "sqlparser", ".", "GroupBy", ")", "error", "{", "colnum", ":=", "-", "1", "\n", "for", "_", ",", "expr", ":=", "range", "groupBy", "{", "switch", "node", ":=", "expr", ".", "(", "type", ")", "{", "case", "*", "sqlparser", ".", "ColName", ":", "c", ":=", "node", ".", "Metadata", ".", "(", "*", "column", ")", "\n", "if", "c", ".", "Origin", "(", ")", "==", "oa", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sqlparser", ".", "String", "(", "node", ")", ")", "\n", "}", "\n", "for", "i", ",", "rc", ":=", "range", "oa", ".", "resultColumns", "{", "if", "rc", ".", "column", "==", "c", "{", "colnum", "=", "i", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "colnum", "==", "-", "1", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "case", "*", "sqlparser", ".", "SQLVal", ":", "num", ",", "err", ":=", "ResultFromNumber", "(", "oa", ".", "resultColumns", ",", "node", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "colnum", "=", "num", "\n", "default", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "oa", ".", "eaggr", ".", "Keys", "=", "append", "(", "oa", ".", "eaggr", ".", "Keys", ",", "colnum", ")", "\n", "}", "\n\n", "_", "=", "oa", ".", "input", ".", "SetGroupBy", "(", "groupBy", ")", "\n", "return", "nil", "\n", "}" ]

[ "SetGroupBy", "satisfies", "the", "builder", "interface", "." ]

[ "func", "(", "oa", "*", "orderedAggregate", ")", "SetUpperLimit", "(", "count", "*", "sqlparser", ".", "SQLVal", ")", "{", "oa", ".", "input", ".", "SetUpperLimit", "(", "count", ")", "\n", "}" ]

[ "SetUpperLimit", "satisfies", "the", "builder", "interface", "." ]

[ "func", "(", "oa", "*", "orderedAggregate", ")", "Wireup", "(", "bldr", "builder", ",", "jt", "*", "jointab", ")", "error", "{", "for", "i", ",", "colnum", ":=", "range", "oa", ".", "eaggr", ".", "Keys", "{", "if", "sqltypes", ".", "IsText", "(", "oa", ".", "resultColumns", "[", "colnum", "]", ".", "column", ".", "typ", ")", "{", "// len(oa.resultColumns) does not change. No harm using the value multiple times.", "oa", ".", "eaggr", ".", "TruncateColumnCount", "=", "len", "(", "oa", ".", "resultColumns", ")", "\n", "oa", ".", "eaggr", ".", "Keys", "[", "i", "]", "=", "oa", ".", "input", ".", "SupplyWeightString", "(", "colnum", ")", "\n", "}", "\n", "}", "\n", "return", "oa", ".", "input", ".", "Wireup", "(", "bldr", ",", "jt", ")", "\n", "}" ]

[ "Wireup", "satisfies", "the", "builder", "interface", ".", "If", "text", "columns", "are", "detected", "in", "the", "keys", "then", "the", "function", "modifies", "the", "primitive", "to", "pull", "a", "corresponding", "weight_string", "from", "mysql", "and", "compare", "those", "instead", ".", "This", "is", "because", "we", "currently", "don", "t", "have", "the", "ability", "to", "mimic", "mysql", "s", "collation", "behavior", "." ]

[ "func", "(", "agent", "*", "ActionAgent", ")", "ExecuteFetchAsDba", "(", "ctx", "context", ".", "Context", ",", "query", "[", "]", "byte", ",", "dbName", "string", ",", "maxrows", "int", ",", "disableBinlogs", "bool", ",", "reloadSchema", "bool", ")", "(", "*", "querypb", ".", "QueryResult", ",", "error", ")", "{", "// get a connection", "conn", ",", "err", ":=", "agent", ".", "MysqlDaemon", ".", "GetDbaConnection", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "conn", ".", "Close", "(", ")", "\n\n", "// disable binlogs if necessary", "if", "disableBinlogs", "{", "_", ",", "err", ":=", "conn", ".", "ExecuteFetch", "(", "\"", "\"", ",", "0", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "if", "dbName", "!=", "\"", "\"", "{", "// This execute might fail if db does not exist.", "// Error is ignored because given query might create this database.", "conn", ".", "ExecuteFetch", "(", "\"", "\"", "+", "dbName", ",", "1", ",", "false", ")", "\n", "}", "\n\n", "// run the query", "result", ",", "err", ":=", "conn", ".", "ExecuteFetch", "(", "string", "(", "query", ")", ",", "maxrows", ",", "true", "/*wantFields*/", ")", "\n\n", "// re-enable binlogs if necessary", "if", "disableBinlogs", "&&", "!", "conn", ".", "IsClosed", "(", ")", "{", "_", ",", "err", ":=", "conn", ".", "ExecuteFetch", "(", "\"", "\"", ",", "0", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "// if we can't reset the sql_log_bin flag,", "// let's just close the connection.", "conn", ".", "Close", "(", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", "==", "nil", "&&", "reloadSchema", "{", "reloadErr", ":=", "agent", ".", "QueryServiceControl", ".", "ReloadSchema", "(", "ctx", ")", "\n", "if", "reloadErr", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "reloadErr", ")", "\n", "}", "\n", "}", "\n", "return", "sqltypes", ".", "ResultToProto3", "(", "result", ")", ",", "err", "\n", "}" ]

[ "ExecuteFetchAsDba", "will", "execute", "the", "given", "query", "possibly", "disabling", "binlogs", "and", "reload", "schema", "." ]

[ "func", "(", "agent", "*", "ActionAgent", ")", "ExecuteFetchAsAllPrivs", "(", "ctx", "context", ".", "Context", ",", "query", "[", "]", "byte", ",", "dbName", "string", ",", "maxrows", "int", ",", "reloadSchema", "bool", ")", "(", "*", "querypb", ".", "QueryResult", ",", "error", ")", "{", "// get a connection", "conn", ",", "err", ":=", "agent", ".", "MysqlDaemon", ".", "GetAllPrivsConnection", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "conn", ".", "Close", "(", ")", "\n\n", "if", "dbName", "!=", "\"", "\"", "{", "// This execute might fail if db does not exist.", "// Error is ignored because given query might create this database.", "conn", ".", "ExecuteFetch", "(", "\"", "\"", "+", "dbName", ",", "1", ",", "false", ")", "\n", "}", "\n\n", "// run the query", "result", ",", "err", ":=", "conn", ".", "ExecuteFetch", "(", "string", "(", "query", ")", ",", "maxrows", ",", "true", "/*wantFields*/", ")", "\n\n", "if", "err", "==", "nil", "&&", "reloadSchema", "{", "reloadErr", ":=", "agent", ".", "QueryServiceControl", ".", "ReloadSchema", "(", "ctx", ")", "\n", "if", "reloadErr", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "reloadErr", ")", "\n", "}", "\n", "}", "\n", "return", "sqltypes", ".", "ResultToProto3", "(", "result", ")", ",", "err", "\n", "}" ]

[ "ExecuteFetchAsAllPrivs", "will", "execute", "the", "given", "query", "possibly", "reloading", "schema", "." ]

[ "func", "(", "agent", "*", "ActionAgent", ")", "ExecuteFetchAsApp", "(", "ctx", "context", ".", "Context", ",", "query", "[", "]", "byte", ",", "maxrows", "int", ")", "(", "*", "querypb", ".", "QueryResult", ",", "error", ")", "{", "// get a connection", "conn", ",", "err", ":=", "agent", ".", "MysqlDaemon", ".", "GetAppConnection", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "conn", ".", "Recycle", "(", ")", "\n", "result", ",", "err", ":=", "conn", ".", "ExecuteFetch", "(", "string", "(", "query", ")", ",", "maxrows", ",", "true", "/*wantFields*/", ")", "\n", "return", "sqltypes", ".", "ResultToProto3", "(", "result", ")", ",", "err", "\n", "}" ]

[ "ExecuteFetchAsApp", "will", "execute", "the", "given", "query", "." ]

[ "func", "newV2Resolver", "(", "keyspaceInfo", "*", "topo", ".", "KeyspaceInfo", ",", "td", "*", "tabletmanagerdatapb", ".", "TableDefinition", ")", "(", "keyspaceIDResolver", ",", "error", ")", "{", "if", "keyspaceInfo", ".", "ShardingColumnName", "==", "\"", "\"", "{", "return", "nil", ",", "vterrors", ".", "New", "(", "vtrpc", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "keyspaceInfo", ".", "ShardingColumnType", "==", "topodatapb", ".", "KeyspaceIdType_UNSET", "{", "return", "nil", ",", "vterrors", ".", "New", "(", "vtrpc", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "td", ".", "Type", "!=", "tmutils", ".", "TableBaseTable", "{", "return", "nil", ",", "vterrors", ".", "Errorf", "(", "vtrpc", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ",", "td", ".", "Type", ")", "\n", "}", "\n\n", "// Find the sharding key column index.", "columnIndex", ",", "ok", ":=", "tmutils", ".", "TableDefinitionGetColumn", "(", "td", ",", "keyspaceInfo", ".", "ShardingColumnName", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "vterrors", ".", "Errorf", "(", "vtrpc", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ",", "td", ".", "Name", ",", "keyspaceInfo", ".", "ShardingColumnName", ")", "\n", "}", "\n\n", "return", "&", "v2Resolver", "{", "keyspaceInfo", ",", "columnIndex", "}", ",", "nil", "\n", "}" ]

[ "newV2Resolver", "returns", "a", "keyspaceIDResolver", "for", "a", "v2", "table", ".", "V2", "keyspaces", "have", "a", "preset", "sharding", "column", "name", "and", "type", "." ]

[ "func", "newV3ResolverFromTableDefinition", "(", "keyspaceSchema", "*", "vindexes", ".", "KeyspaceSchema", ",", "td", "*", "tabletmanagerdatapb", ".", "TableDefinition", ")", "(", "keyspaceIDResolver", ",", "error", ")", "{", "if", "td", ".", "Type", "!=", "tmutils", ".", "TableBaseTable", "{", "return", "nil", ",", "vterrors", ".", "Errorf", "(", "vtrpc", ".", "Code_INVALID_ARGUMENT", ",", "\"", "\"", ",", "td", ".", "Type", ")", "\n", "}", "\n", "tableSchema", ",", "ok", ":=", "keyspaceSchema", ".", "Tables", "[", "td", ".", "Name", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "vterrors", ".", "Errorf", "(", "vtrpc", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ",", "td", ".", "Name", ")", "\n", "}", "\n", "// use the lowest cost unique vindex as the sharding key", "colVindex", ",", "err", ":=", "vindexes", ".", "FindVindexForSharding", "(", "td", ".", "Name", ",", "tableSchema", ".", "ColumnVindexes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Find the sharding key column index.", "columnIndex", ",", "ok", ":=", "tmutils", ".", "TableDefinitionGetColumn", "(", "td", ",", "colVindex", ".", "Columns", "[", "0", "]", ".", "String", "(", ")", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "vterrors", ".", "Errorf", "(", "vtrpc", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ",", "td", ".", "Name", ",", "colVindex", ".", "Columns", "[", "0", "]", ")", "\n", "}", "\n\n", "return", "&", "v3Resolver", "{", "shardingColumnIndex", ":", "columnIndex", ",", "vindex", ":", "colVindex", ".", "Vindex", ",", "}", ",", "nil", "\n", "}" ]

[ "newV3ResolverFromTableDefinition", "returns", "a", "keyspaceIDResolver", "for", "a", "v3", "table", "." ]

[ "func", "newV3ResolverFromColumnList", "(", "keyspaceSchema", "*", "vindexes", ".", "KeyspaceSchema", ",", "name", "string", ",", "columns", "[", "]", "string", ")", "(", "keyspaceIDResolver", ",", "error", ")", "{", "tableSchema", ",", "ok", ":=", "keyspaceSchema", ".", "Tables", "[", "name", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "vterrors", ".", "Errorf", "(", "vtrpc", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "// use the lowest cost unique vindex as the sharding key", "colVindex", ",", "err", ":=", "vindexes", ".", "FindVindexForSharding", "(", "name", ",", "tableSchema", ".", "ColumnVindexes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Find the sharding key column index.", "columnIndex", ":=", "-", "1", "\n", "for", "i", ",", "n", ":=", "range", "columns", "{", "if", "colVindex", ".", "Columns", "[", "0", "]", ".", "EqualString", "(", "n", ")", "{", "columnIndex", "=", "i", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "columnIndex", "==", "-", "1", "{", "return", "nil", ",", "vterrors", ".", "Errorf", "(", "vtrpc", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ",", "name", ",", "colVindex", ".", "Columns", "[", "0", "]", ")", "\n", "}", "\n\n", "return", "&", "v3Resolver", "{", "shardingColumnIndex", ":", "columnIndex", ",", "vindex", ":", "colVindex", ".", "Vindex", ",", "}", ",", "nil", "\n", "}" ]

[ "newV3ResolverFromColumnList", "returns", "a", "keyspaceIDResolver", "for", "a", "v3", "table", "." ]

[ "func", "(", "zkd", "*", "Zkd", ")", "Shutdown", "(", ")", "error", "{", "log", ".", "Infof", "(", "\"", "\"", ")", "\n", "pidData", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "zkd", ".", "config", ".", "PidFile", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "pid", ",", "err", ":=", "strconv", ".", "Atoi", "(", "string", "(", "bytes", ".", "TrimSpace", "(", "pidData", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "syscall", ".", "Kill", "(", "pid", ",", "syscall", ".", "SIGKILL", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "syscall", ".", "ESRCH", "{", "return", "err", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "shutdownWaitTime", ";", "i", "++", "{", "if", "syscall", ".", "Kill", "(", "pid", ",", "syscall", ".", "SIGKILL", ")", "==", "syscall", ".", "ESRCH", "{", "return", "nil", "\n", "}", "\n", "time", ".", "Sleep", "(", "time", ".", "Second", ")", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pid", ")", "\n", "}" ]

[ "Shutdown", "kills", "a", "ZooKeeper", "server", "but", "keeps", "its", "data", "dir", "intact", "." ]

[ "func", "(", "zkd", "*", "Zkd", ")", "Init", "(", ")", "error", "{", "if", "zkd", ".", "Inited", "(", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "log", ".", "Infof", "(", "\"", "\"", ")", "\n", "for", "_", ",", "path", ":=", "range", "zkd", ".", "config", ".", "DirectoryList", "(", ")", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "path", ",", "0775", ")", ";", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "// FIXME(msolomon) validate permissions?", "}", "\n\n", "configData", ",", "err", ":=", "zkd", ".", "makeCfg", "(", ")", "\n", "if", "err", "==", "nil", "{", "err", "=", "ioutil", ".", "WriteFile", "(", "zkd", ".", "config", ".", "ConfigFile", "(", ")", ",", "[", "]", "byte", "(", "configData", ")", ",", "0664", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "zkd", ".", "config", ".", "ConfigFile", "(", ")", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "err", "=", "zkd", ".", "config", ".", "WriteMyid", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "zkd", ".", "config", ".", "MyidFile", "(", ")", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "if", "err", "=", "zkd", ".", "Start", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "zkd", ".", "config", ".", "LogDir", "(", ")", ")", "\n", "return", "err", "\n", "}", "\n\n", "zkAddr", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "zkd", ".", "config", ".", "ClientPort", ")", "\n", "zk", ",", "session", ",", "err", ":=", "zookeeper", ".", "Connect", "(", "[", "]", "string", "{", "zkAddr", "}", ",", "startWaitTime", "*", "time", ".", "Second", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "event", ":=", "<-", "session", "\n", "if", "event", ".", "State", "!=", "zookeeper", ".", "StateConnecting", "{", "return", "event", ".", "Err", "\n", "}", "\n", "event", "=", "<-", "session", "\n", "if", "event", ".", "State", "!=", "zookeeper", ".", "StateConnected", "{", "return", "event", ".", "Err", "\n", "}", "\n", "defer", "zk", ".", "Close", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Init", "generates", "a", "new", "config", "and", "then", "starts", "ZooKeeper", "." ]

[ "func", "(", "zkd", "*", "Zkd", ")", "Teardown", "(", ")", "error", "{", "log", ".", "Infof", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "zkd", ".", "Shutdown", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "var", "removalErr", "error", "\n", "for", "_", ",", "dir", ":=", "range", "zkd", ".", "config", ".", "DirectoryList", "(", ")", "{", "log", ".", "V", "(", "6", ")", ".", "Infof", "(", "\"", "\"", ",", "dir", ")", "\n", "if", "err", ":=", "os", ".", "RemoveAll", "(", "dir", ")", ";", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "dir", ",", "err", ".", "Error", "(", ")", ")", "\n", "removalErr", "=", "err", "\n", "}", "\n", "}", "\n", "return", "removalErr", "\n", "}" ]

[ "Teardown", "shuts", "down", "the", "server", "and", "removes", "its", "data", "dir", "." ]

[ "func", "(", "zkd", "*", "Zkd", ")", "Inited", "(", ")", "bool", "{", "myidFile", ":=", "zkd", ".", "config", ".", "MyidFile", "(", ")", "\n", "_", ",", "statErr", ":=", "os", ".", "Stat", "(", "myidFile", ")", "\n", "if", "statErr", "==", "nil", "{", "return", "true", "\n", "}", "else", "if", "statErr", ".", "(", "*", "os", ".", "PathError", ")", ".", "Err", "!=", "syscall", ".", "ENOENT", "{", "panic", "(", "\"", "\"", "+", "myidFile", "+", "\"", "\"", "+", "statErr", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Inited", "returns", "true", "if", "the", "server", "config", "has", "been", "initialized", "." ]

[ "func", "Init", "(", ")", "{", "mu", ".", "Lock", "(", ")", "\n", "defer", "mu", ".", "Unlock", "(", ")", "\n", "if", "inited", "{", "log", ".", "Fatal", "(", "\"", "\"", ")", "\n", "}", "\n", "inited", "=", "true", "\n\n", "// Once you run as root, you pretty much destroy the chances of a", "// non-privileged user starting the program correctly.", "if", "uid", ":=", "os", ".", "Getuid", "(", ")", ";", "uid", "==", "0", "{", "log", ".", "Exitf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "runtime", ".", "MemProfileRate", "=", "*", "memProfileRate", "\n\n", "if", "*", "mutexProfileFraction", "!=", "0", "{", "log", ".", "Infof", "(", "\"", "\"", ",", "*", "mutexProfileFraction", ")", "\n", "runtime", ".", "SetMutexProfileFraction", "(", "*", "mutexProfileFraction", ")", "\n", "}", "\n\n", "// We used to set this limit directly, but you pretty much have to", "// use a root account to allow increasing a limit reliably. Dropping", "// privileges is also tricky. The best strategy is to make a shell", "// script set up the limits as root and switch users before starting", "// the server.", "fdLimit", ":=", "&", "syscall", ".", "Rlimit", "{", "}", "\n", "if", "err", ":=", "syscall", ".", "Getrlimit", "(", "syscall", ".", "RLIMIT_NOFILE", ",", "fdLimit", ")", ";", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "fdl", ":=", "stats", ".", "NewGauge", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "fdl", ".", "Set", "(", "int64", "(", "fdLimit", ".", "Cur", ")", ")", "\n\n", "onInitHooks", ".", "Fire", "(", ")", "\n", "}" ]

[ "Init", "is", "the", "first", "phase", "of", "the", "server", "startup", "." ]

[ "func", "fireOnTermSyncHooks", "(", "timeout", "time", ".", "Duration", ")", "bool", "{", "log", ".", "Infof", "(", "\"", "\"", ",", "timeout", ")", "\n\n", "timer", ":=", "time", ".", "NewTimer", "(", "timeout", ")", "\n", "defer", "timer", ".", "Stop", "(", ")", "\n\n", "done", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "go", "func", "(", ")", "{", "onTermSyncHooks", ".", "Fire", "(", ")", "\n", "close", "(", "done", ")", "\n", "}", "(", ")", "\n\n", "select", "{", "case", "<-", "done", ":", "log", ".", "Infof", "(", "\"", "\"", ")", "\n", "return", "true", "\n", "case", "<-", "timer", ".", "C", ":", "log", ".", "Infof", "(", "\"", "\"", ")", "\n", "return", "false", "\n", "}", "\n", "}" ]

[ "fireOnTermSyncHooks", "returns", "true", "iff", "all", "the", "hooks", "finish", "before", "the", "timeout", "." ]

[ "func", "ParseFlags", "(", "cmd", "string", ")", "{", "flag", ".", "Parse", "(", ")", "\n\n", "if", "*", "Version", "{", "AppVersion", ".", "Print", "(", ")", "\n", "os", ".", "Exit", "(", "0", ")", "\n", "}", "\n\n", "args", ":=", "flag", ".", "Args", "(", ")", "\n", "if", "len", "(", "args", ")", ">", "0", "{", "flag", ".", "Usage", "(", ")", "\n", "log", ".", "Exitf", "(", "\"", "\"", ",", "cmd", ",", "strings", ".", "Join", "(", "args", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "}" ]

[ "ParseFlags", "initializes", "flags", "and", "handles", "the", "common", "case", "when", "no", "positional", "arguments", "are", "expected", "." ]

[ "func", "ParseFlagsWithArgs", "(", "cmd", "string", ")", "[", "]", "string", "{", "flag", ".", "Parse", "(", ")", "\n\n", "if", "*", "Version", "{", "AppVersion", ".", "Print", "(", ")", "\n", "os", ".", "Exit", "(", "0", ")", "\n", "}", "\n\n", "args", ":=", "flag", ".", "Args", "(", ")", "\n", "if", "len", "(", "args", ")", "==", "0", "{", "log", ".", "Exitf", "(", "\"", "\"", ",", "cmd", ")", "\n", "}", "\n\n", "return", "args", "\n", "}" ]

[ "ParseFlagsWithArgs", "initializes", "flags", "and", "returns", "the", "positional", "arguments" ]

[ "func", "NewTxEngine", "(", "checker", "connpool", ".", "MySQLChecker", ",", "config", "tabletenv", ".", "TabletConfig", ")", "*", "TxEngine", "{", "te", ":=", "&", "TxEngine", "{", "shutdownGracePeriod", ":", "time", ".", "Duration", "(", "config", ".", "TxShutDownGracePeriod", "*", "1e9", ")", ",", "}", "\n", "limiter", ":=", "txlimiter", ".", "New", "(", "config", ".", "TransactionCap", ",", "config", ".", "TransactionLimitPerUser", ",", "config", ".", "EnableTransactionLimit", ",", "config", ".", "EnableTransactionLimitDryRun", ",", "config", ".", "TransactionLimitByUsername", ",", "config", ".", "TransactionLimitByPrincipal", ",", "config", ".", "TransactionLimitByComponent", ",", "config", ".", "TransactionLimitBySubcomponent", ",", ")", "\n", "te", ".", "txPool", "=", "NewTxPool", "(", "config", ".", "PoolNamePrefix", ",", "config", ".", "TransactionCap", ",", "config", ".", "FoundRowsPoolSize", ",", "time", ".", "Duration", "(", "config", ".", "TransactionTimeout", "*", "1e9", ")", ",", "time", ".", "Duration", "(", "config", ".", "IdleTimeout", "*", "1e9", ")", ",", "config", ".", "TxPoolWaiterCap", ",", "checker", ",", "limiter", ",", ")", "\n", "te", ".", "twopcEnabled", "=", "config", ".", "TwoPCEnable", "\n", "if", "te", ".", "twopcEnabled", "{", "if", "config", ".", "TwoPCCoordinatorAddress", "==", "\"", "\"", "{", "log", ".", "Error", "(", "\"", "\"", ")", "\n", "te", ".", "twopcEnabled", "=", "false", "\n", "}", "\n", "if", "config", ".", "TwoPCAbandonAge", "<=", "0", "{", "log", ".", "Error", "(", "\"", "\"", ")", "\n", "te", ".", "twopcEnabled", "=", "false", "\n", "}", "\n", "}", "\n", "te", ".", "coordinatorAddress", "=", "config", ".", "TwoPCCoordinatorAddress", "\n", "te", ".", "abandonAge", "=", "time", ".", "Duration", "(", "config", ".", "TwoPCAbandonAge", "*", "1e9", ")", "\n", "te", ".", "ticks", "=", "timer", ".", "NewTimer", "(", "te", ".", "abandonAge", "/", "2", ")", "\n\n", "// Set the prepared pool capacity to something lower than", "// tx pool capacity. Those spare connections are needed to", "// perform metadata state change operations. Without this,", "// the system can deadlock if all connections get moved to", "// the TxPreparedPool.", "te", ".", "preparedPool", "=", "NewTxPreparedPool", "(", "config", ".", "TransactionCap", "-", "2", ")", "\n", "readPool", ":=", "connpool", ".", "New", "(", "config", ".", "PoolNamePrefix", "+", "\"", "\"", ",", "3", ",", "time", ".", "Duration", "(", "config", ".", "IdleTimeout", "*", "1e9", ")", ",", "checker", ",", ")", "\n", "te", ".", "twoPC", "=", "NewTwoPC", "(", "readPool", ")", "\n", "te", ".", "transitionSignal", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "// By immediately closing this channel, all state changes can simply be made blocking by issuing the", "// state change desired, and then selecting on this channel. It will contain an open channel while", "// transitioning.", "close", "(", "te", ".", "transitionSignal", ")", "\n", "te", ".", "nextState", "=", "-", "1", "\n", "te", ".", "state", "=", "NotServing", "\n", "return", "te", "\n", "}" ]

[ "NewTxEngine", "creates", "a", "new", "TxEngine", "." ]

[ "func", "(", "te", "*", "TxEngine", ")", "AcceptReadWrite", "(", ")", "error", "{", "te", ".", "beginRequests", ".", "Wait", "(", ")", "\n", "te", ".", "stateLock", ".", "Lock", "(", ")", "\n\n", "switch", "te", ".", "state", "{", "case", "AcceptingReadAndWrite", ":", "// Nothing to do", "te", ".", "stateLock", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n\n", "case", "NotServing", ":", "te", ".", "state", "=", "AcceptingReadAndWrite", "\n", "te", ".", "open", "(", ")", "\n", "te", ".", "stateLock", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n\n", "case", "Transitioning", ":", "te", ".", "nextState", "=", "AcceptingReadAndWrite", "\n", "te", ".", "stateLock", ".", "Unlock", "(", ")", "\n", "te", ".", "blockUntilEndOfTransition", "(", ")", "\n", "return", "nil", "\n\n", "case", "AcceptingReadOnly", ":", "// We need to restart the tx-pool to make sure we handle 2PC correctly", "te", ".", "close", "(", "true", ")", "\n", "te", ".", "state", "=", "AcceptingReadAndWrite", "\n", "te", ".", "open", "(", ")", "\n", "te", ".", "stateLock", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n\n", "default", ":", "return", "te", ".", "unknownStateError", "(", ")", "\n", "}", "\n", "}" ]

[ "AcceptReadWrite", "will", "start", "accepting", "all", "transactions", ".", "If", "transitioning", "from", "RO", "mode", "transactions", "might", "need", "to", "be", "rolled", "back", "before", "new", "transactions", "can", "be", "accepts", "." ]

[ "func", "(", "te", "*", "TxEngine", ")", "AcceptReadOnly", "(", ")", "error", "{", "te", ".", "beginRequests", ".", "Wait", "(", ")", "\n", "te", ".", "stateLock", ".", "Lock", "(", ")", "\n", "switch", "te", ".", "state", "{", "case", "AcceptingReadOnly", ":", "// Nothing to do", "te", ".", "stateLock", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n\n", "case", "NotServing", ":", "te", ".", "state", "=", "AcceptingReadOnly", "\n", "te", ".", "open", "(", ")", "\n", "te", ".", "stateLock", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n\n", "case", "AcceptingReadAndWrite", ":", "return", "te", ".", "transitionTo", "(", "AcceptingReadOnly", ")", "\n\n", "case", "Transitioning", ":", "te", ".", "nextState", "=", "AcceptingReadOnly", "\n", "te", ".", "stateLock", ".", "Unlock", "(", ")", "\n", "te", ".", "blockUntilEndOfTransition", "(", ")", "\n", "return", "nil", "\n\n", "default", ":", "te", ".", "stateLock", ".", "Unlock", "(", ")", "\n", "return", "te", ".", "unknownStateError", "(", ")", "\n", "}", "\n", "}" ]

[ "AcceptReadOnly", "will", "start", "accepting", "read", "-", "only", "transactions", "but", "not", "full", "read", "and", "write", "transactions", ".", "If", "the", "engine", "is", "currently", "accepting", "full", "read", "and", "write", "transactions", "they", "need", "to", "be", "rolled", "back", "." ]

[ "func", "(", "te", "*", "TxEngine", ")", "Init", "(", ")", "error", "{", "if", "te", ".", "twopcEnabled", "{", "return", "te", ".", "twoPC", ".", "Init", "(", "te", ".", "dbconfigs", ".", "SidecarDBName", ".", "Get", "(", ")", ",", "te", ".", "dbconfigs", ".", "DbaWithDB", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Init", "must", "be", "called", "once", "when", "vttablet", "starts", "for", "setting", "up", "the", "metadata", "tables", "." ]

[ "func", "(", "te", "*", "TxEngine", ")", "open", "(", ")", "{", "te", ".", "txPool", ".", "Open", "(", "te", ".", "dbconfigs", ".", "AppWithDB", "(", ")", ",", "te", ".", "dbconfigs", ".", "DbaWithDB", "(", ")", ",", "te", ".", "dbconfigs", ".", "AppDebugWithDB", "(", ")", ")", "\n\n", "if", "te", ".", "twopcEnabled", "&&", "te", ".", "state", "==", "AcceptingReadAndWrite", "{", "te", ".", "twoPC", ".", "Open", "(", "te", ".", "dbconfigs", ")", "\n", "if", "err", ":=", "te", ".", "prepareFromRedo", "(", ")", ";", "err", "!=", "nil", "{", "// If this operation fails, we choose to raise an alert and", "// continue anyway. Serving traffic is considered more important", "// than blocking everything for the sake of a few transactions.", "tabletenv", ".", "InternalErrors", ".", "Add", "(", "\"", "\"", ",", "1", ")", "\n", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "te", ".", "startWatchdog", "(", ")", "\n", "}", "\n", "}" ]

[ "open", "opens", "the", "TxEngine", ".", "If", "2pc", "is", "enabled", "it", "restores", "all", "previously", "prepared", "transactions", "from", "the", "redo", "log", ".", "this", "should", "only", "be", "called", "when", "the", "state", "is", "already", "locked" ]

[ "func", "(", "te", "*", "TxEngine", ")", "StopGently", "(", ")", "{", "te", ".", "stateLock", ".", "Lock", "(", ")", "\n", "defer", "te", ".", "stateLock", ".", "Unlock", "(", ")", "\n", "te", ".", "close", "(", "false", ")", "\n", "te", ".", "state", "=", "NotServing", "\n", "}" ]

[ "StopGently", "will", "disregard", "common", "rules", "for", "when", "to", "kill", "transactions", "and", "wait", "forever", "for", "transactions", "to", "wrap", "up" ]

[ "func", "(", "te", "*", "TxEngine", ")", "close", "(", "immediate", "bool", ")", "{", "// Shut down functions are idempotent.", "// No need to check if 2pc is enabled.", "te", ".", "stopWatchdog", "(", ")", "\n\n", "poolEmpty", ":=", "make", "(", "chan", "bool", ")", "\n", "rollbackDone", ":=", "make", "(", "chan", "bool", ")", "\n", "// This goroutine decides if transactions have to be", "// forced to rollback, and if so, when. Once done,", "// the function closes rollbackDone, which can be", "// verified to make sure it won't kick in later.", "go", "func", "(", ")", "{", "defer", "func", "(", ")", "{", "tabletenv", ".", "LogError", "(", ")", "\n", "close", "(", "rollbackDone", ")", "\n", "}", "(", ")", "\n", "if", "immediate", "{", "// Immediately rollback everything and return.", "log", ".", "Info", "(", "\"", "\"", ")", "\n", "te", ".", "rollbackTransactions", "(", ")", "\n", "return", "\n", "}", "\n", "if", "te", ".", "shutdownGracePeriod", "<=", "0", "{", "// No grace period was specified. Never rollback.", "te", ".", "rollbackPrepared", "(", ")", "\n", "log", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "tmr", ":=", "time", ".", "NewTimer", "(", "te", ".", "shutdownGracePeriod", ")", "\n", "defer", "tmr", ".", "Stop", "(", ")", "\n", "select", "{", "case", "<-", "tmr", ".", "C", ":", "log", ".", "Info", "(", "\"", "\"", ")", "\n", "te", ".", "rollbackTransactions", "(", ")", "\n", "case", "<-", "poolEmpty", ":", "// The pool cleared before the timer kicked in. Just return.", "log", ".", "Info", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "(", ")", "\n", "te", ".", "txPool", ".", "WaitForEmpty", "(", ")", "\n", "// If the goroutine is still running, signal that it can exit.", "close", "(", "poolEmpty", ")", "\n", "// Make sure the goroutine has returned.", "<-", "rollbackDone", "\n\n", "te", ".", "txPool", ".", "Close", "(", ")", "\n", "te", ".", "twoPC", ".", "Close", "(", ")", "\n", "}" ]

[ "Close", "closes", "the", "TxEngine", ".", "If", "the", "immediate", "flag", "is", "on", "then", "all", "current", "transactions", "are", "immediately", "rolled", "back", ".", "Otherwise", "the", "function", "waits", "for", "all", "current", "transactions", "to", "conclude", ".", "If", "a", "shutdown", "grace", "period", "was", "specified", "the", "transactions", "are", "rolled", "back", "if", "they", "re", "not", "resolved", "by", "that", "time", "." ]

[ "func", "(", "te", "*", "TxEngine", ")", "prepareFromRedo", "(", ")", "error", "{", "ctx", ":=", "tabletenv", ".", "LocalContext", "(", ")", "\n", "var", "allErr", "concurrency", ".", "AllErrorRecorder", "\n", "prepared", ",", "failed", ",", "err", ":=", "te", ".", "twoPC", ".", "ReadAllRedo", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "maxid", ":=", "int64", "(", "0", ")", "\n", "outer", ":", "for", "_", ",", "tx", ":=", "range", "prepared", "{", "txid", ",", "err", ":=", "dtids", ".", "TransactionID", "(", "tx", ".", "Dtid", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "txid", ">", "maxid", "{", "maxid", "=", "txid", "\n", "}", "\n", "conn", ",", "_", ",", "err", ":=", "te", ".", "txPool", ".", "LocalBegin", "(", "ctx", ",", "&", "querypb", ".", "ExecuteOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "allErr", ".", "RecordError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "for", "_", ",", "stmt", ":=", "range", "tx", ".", "Queries", "{", "conn", ".", "RecordQuery", "(", "stmt", ")", "\n", "_", ",", "err", ":=", "conn", ".", "Exec", "(", "ctx", ",", "stmt", ",", "1", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "allErr", ".", "RecordError", "(", "err", ")", "\n", "te", ".", "txPool", ".", "LocalConclude", "(", "ctx", ",", "conn", ")", "\n", "continue", "outer", "\n", "}", "\n", "}", "\n", "// We should not use the external Prepare because", "// we don't want to write again to the redo log.", "err", "=", "te", ".", "preparedPool", ".", "Put", "(", "conn", ",", "tx", ".", "Dtid", ")", "\n", "if", "err", "!=", "nil", "{", "allErr", ".", "RecordError", "(", "err", ")", "\n", "continue", "\n", "}", "\n", "}", "\n", "for", "_", ",", "tx", ":=", "range", "failed", "{", "txid", ",", "err", ":=", "dtids", ".", "TransactionID", "(", "tx", ".", "Dtid", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "txid", ">", "maxid", "{", "maxid", "=", "txid", "\n", "}", "\n", "te", ".", "preparedPool", ".", "SetFailed", "(", "tx", ".", "Dtid", ")", "\n", "}", "\n", "te", ".", "txPool", ".", "AdjustLastID", "(", "maxid", ")", "\n", "log", ".", "Infof", "(", "\"", "\"", ",", "len", "(", "prepared", ")", ",", "len", "(", "failed", ")", ")", "\n", "return", "allErr", ".", "Error", "(", ")", "\n", "}" ]

[ "prepareFromRedo", "replays", "and", "prepares", "the", "transactions", "from", "the", "redo", "log", "loads", "previously", "failed", "transactions", "into", "the", "reserved", "list", "and", "adjusts", "the", "txPool", "LastID", "to", "ensure", "there", "are", "no", "future", "collisions", "." ]

[ "func", "(", "te", "*", "TxEngine", ")", "rollbackTransactions", "(", ")", "{", "ctx", ":=", "tabletenv", ".", "LocalContext", "(", ")", "\n", "for", "_", ",", "c", ":=", "range", "te", ".", "preparedPool", ".", "FetchAll", "(", ")", "{", "te", ".", "txPool", ".", "LocalConclude", "(", "ctx", ",", "c", ")", "\n", "}", "\n", "// The order of rollbacks is currently not material because", "// we don't allow new statements or commits during", "// this function. In case of any such change, this will", "// have to be revisited.", "te", ".", "txPool", ".", "RollbackNonBusy", "(", "ctx", ")", "\n", "}" ]

[ "rollbackTransactions", "rolls", "back", "all", "open", "transactions", "including", "the", "prepared", "ones", ".", "This", "is", "used", "for", "transitioning", "from", "a", "master", "to", "a", "non", "-", "master", "serving", "type", "." ]

[ "func", "(", "te", "*", "TxEngine", ")", "startWatchdog", "(", ")", "{", "te", ".", "ticks", ".", "Start", "(", "func", "(", ")", "{", "ctx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "tabletenv", ".", "LocalContext", "(", ")", ",", "te", ".", "abandonAge", "/", "4", ")", "\n", "defer", "cancel", "(", ")", "\n\n", "// Raise alerts on prepares that have been unresolved for too long.", "// Use 5x abandonAge to give opportunity for watchdog to resolve these.", "count", ",", "err", ":=", "te", ".", "twoPC", ".", "CountUnresolvedRedo", "(", "ctx", ",", "time", ".", "Now", "(", ")", ".", "Add", "(", "-", "te", ".", "abandonAge", "*", "5", ")", ")", "\n", "if", "err", "!=", "nil", "{", "tabletenv", ".", "InternalErrors", ".", "Add", "(", "\"", "\"", ",", "1", ")", "\n", "log", ".", "Errorf", "(", "\"", "\"", ",", "te", ".", "coordinatorAddress", ",", "err", ")", "\n", "}", "\n", "tabletenv", ".", "Unresolved", ".", "Set", "(", "\"", "\"", ",", "count", ")", "\n\n", "// Resolve lingering distributed transactions.", "txs", ",", "err", ":=", "te", ".", "twoPC", ".", "ReadAbandoned", "(", "ctx", ",", "time", ".", "Now", "(", ")", ".", "Add", "(", "-", "te", ".", "abandonAge", ")", ")", "\n", "if", "err", "!=", "nil", "{", "tabletenv", ".", "InternalErrors", ".", "Add", "(", "\"", "\"", ",", "1", ")", "\n", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "if", "len", "(", "txs", ")", "==", "0", "{", "return", "\n", "}", "\n\n", "coordConn", ",", "err", ":=", "vtgateconn", ".", "Dial", "(", "ctx", ",", "te", ".", "coordinatorAddress", ")", "\n", "if", "err", "!=", "nil", "{", "tabletenv", ".", "InternalErrors", ".", "Add", "(", "\"", "\"", ",", "1", ")", "\n", "log", ".", "Errorf", "(", "\"", "\"", ",", "te", ".", "coordinatorAddress", ",", "err", ")", "\n", "return", "\n", "}", "\n", "defer", "coordConn", ".", "Close", "(", ")", "\n\n", "var", "wg", "sync", ".", "WaitGroup", "\n", "for", "tx", ":=", "range", "txs", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "dtid", "string", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "if", "err", ":=", "coordConn", ".", "ResolveTransaction", "(", "ctx", ",", "dtid", ")", ";", "err", "!=", "nil", "{", "tabletenv", ".", "InternalErrors", ".", "Add", "(", "\"", "\"", ",", "1", ")", "\n", "log", ".", "Errorf", "(", "\"", "\"", ",", "dtid", ",", "err", ")", "\n", "}", "\n", "}", "(", "tx", ")", "\n", "}", "\n", "wg", ".", "Wait", "(", ")", "\n", "}", ")", "\n", "}" ]

[ "startWatchdog", "starts", "the", "watchdog", "goroutine", "which", "looks", "for", "abandoned", "transactions", "and", "calls", "the", "notifier", "on", "them", "." ]

[ "func", "NewTxConn", "(", "gw", "gateway", ".", "Gateway", ",", "txMode", "vtgatepb", ".", "TransactionMode", ")", "*", "TxConn", "{", "return", "&", "TxConn", "{", "gateway", ":", "gw", ",", "mode", ":", "txMode", ",", "}", "\n", "}" ]

[ "NewTxConn", "builds", "a", "new", "TxConn", "." ]

[ "func", "(", "txc", "*", "TxConn", ")", "Begin", "(", "ctx", "context", ".", "Context", ",", "session", "*", "SafeSession", ")", "error", "{", "if", "session", ".", "InTransaction", "(", ")", "{", "if", "err", ":=", "txc", ".", "Commit", "(", "ctx", ",", "session", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "// UNSPECIFIED & SINGLE mode are always allowed.", "switch", "session", ".", "TransactionMode", "{", "case", "vtgatepb", ".", "TransactionMode_MULTI", ":", "if", "txc", ".", "mode", "==", "vtgatepb", ".", "TransactionMode_SINGLE", "{", "return", "vterrors", ".", "Errorf", "(", "vtrpcpb", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ",", "session", ".", "TransactionMode", ",", "txc", ".", "mode", ")", "\n", "}", "\n", "case", "vtgatepb", ".", "TransactionMode_TWOPC", ":", "if", "txc", ".", "mode", "!=", "vtgatepb", ".", "TransactionMode_TWOPC", "{", "return", "vterrors", ".", "Errorf", "(", "vtrpcpb", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ",", "session", ".", "TransactionMode", ",", "txc", ".", "mode", ")", "\n", "}", "\n", "}", "\n", "session", ".", "Session", ".", "InTransaction", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "Begin", "begins", "a", "new", "transaction", ".", "If", "one", "is", "already", "in", "progress", "it", "commmits", "it", "and", "starts", "a", "new", "one", "." ]

[ "func", "(", "txc", "*", "TxConn", ")", "Commit", "(", "ctx", "context", ".", "Context", ",", "session", "*", "SafeSession", ")", "error", "{", "defer", "session", ".", "Reset", "(", ")", "\n", "if", "!", "session", ".", "InTransaction", "(", ")", "{", "return", "nil", "\n", "}", "\n\n", "twopc", ":=", "false", "\n", "switch", "session", ".", "TransactionMode", "{", "case", "vtgatepb", ".", "TransactionMode_TWOPC", ":", "if", "txc", ".", "mode", "!=", "vtgatepb", ".", "TransactionMode_TWOPC", "{", "txc", ".", "Rollback", "(", "ctx", ",", "session", ")", "\n", "return", "vterrors", ".", "New", "(", "vtrpcpb", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ")", "\n", "}", "\n", "twopc", "=", "true", "\n", "case", "vtgatepb", ".", "TransactionMode_UNSPECIFIED", ":", "twopc", "=", "(", "txc", ".", "mode", "==", "vtgatepb", ".", "TransactionMode_TWOPC", ")", "\n", "}", "\n", "if", "twopc", "{", "return", "txc", ".", "commit2PC", "(", "ctx", ",", "session", ")", "\n", "}", "\n", "return", "txc", ".", "commitNormal", "(", "ctx", ",", "session", ")", "\n", "}" ]

[ "Commit", "commits", "the", "current", "transaction", ".", "The", "type", "of", "commit", "can", "be", "best", "effort", "or", "2pc", "depending", "on", "the", "session", "setting", "." ]

[ "func", "(", "txc", "*", "TxConn", ")", "Rollback", "(", "ctx", "context", ".", "Context", ",", "session", "*", "SafeSession", ")", "error", "{", "if", "!", "session", ".", "InTransaction", "(", ")", "{", "return", "nil", "\n", "}", "\n", "defer", "session", ".", "Reset", "(", ")", "\n\n", "return", "txc", ".", "runSessions", "(", "session", ".", "ShardSessions", ",", "func", "(", "s", "*", "vtgatepb", ".", "Session_ShardSession", ")", "error", "{", "return", "txc", ".", "gateway", ".", "Rollback", "(", "ctx", ",", "s", ".", "Target", ",", "s", ".", "TransactionId", ")", "\n", "}", ")", "\n", "}" ]

[ "Rollback", "rolls", "back", "the", "current", "transaction", ".", "There", "are", "no", "retries", "on", "this", "operation", "." ]

[ "func", "(", "txc", "*", "TxConn", ")", "Resolve", "(", "ctx", "context", ".", "Context", ",", "dtid", "string", ")", "error", "{", "mmShard", ",", "err", ":=", "dtids", ".", "ShardSession", "(", "dtid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "transaction", ",", "err", ":=", "txc", ".", "gateway", ".", "ReadTransaction", "(", "ctx", ",", "mmShard", ".", "Target", ",", "dtid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "transaction", "==", "nil", "||", "transaction", ".", "Dtid", "==", "\"", "\"", "{", "// It was already resolved.", "return", "nil", "\n", "}", "\n", "switch", "transaction", ".", "State", "{", "case", "querypb", ".", "TransactionState_PREPARE", ":", "// If state is PREPARE, make a decision to rollback and", "// fallthrough to the rollback workflow.", "if", "err", ":=", "txc", ".", "gateway", ".", "SetRollback", "(", "ctx", ",", "mmShard", ".", "Target", ",", "transaction", ".", "Dtid", ",", "mmShard", ".", "TransactionId", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "fallthrough", "\n", "case", "querypb", ".", "TransactionState_ROLLBACK", ":", "if", "err", ":=", "txc", ".", "resumeRollback", "(", "ctx", ",", "mmShard", ".", "Target", ",", "transaction", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "querypb", ".", "TransactionState_COMMIT", ":", "if", "err", ":=", "txc", ".", "resumeCommit", "(", "ctx", ",", "mmShard", ".", "Target", ",", "transaction", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "default", ":", "// Should never happen.", "return", "vterrors", ".", "Errorf", "(", "vtrpcpb", ".", "Code_INTERNAL", ",", "\"", "\"", ",", "transaction", ".", "State", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Resolve", "resolves", "the", "specified", "2PC", "transaction", "." ]

[ "func", "(", "txc", "*", "TxConn", ")", "runSessions", "(", "shardSessions", "[", "]", "*", "vtgatepb", ".", "Session_ShardSession", ",", "action", "func", "(", "*", "vtgatepb", ".", "Session_ShardSession", ")", "error", ")", "error", "{", "// Fastpath.", "if", "len", "(", "shardSessions", ")", "==", "1", "{", "return", "action", "(", "shardSessions", "[", "0", "]", ")", "\n", "}", "\n\n", "allErrors", ":=", "new", "(", "concurrency", ".", "AllErrorRecorder", ")", "\n", "var", "wg", "sync", ".", "WaitGroup", "\n", "for", "_", ",", "s", ":=", "range", "shardSessions", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "s", "*", "vtgatepb", ".", "Session_ShardSession", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "if", "err", ":=", "action", "(", "s", ")", ";", "err", "!=", "nil", "{", "allErrors", ".", "RecordError", "(", "err", ")", "\n", "}", "\n", "}", "(", "s", ")", "\n", "}", "\n", "wg", ".", "Wait", "(", ")", "\n", "return", "allErrors", ".", "AggrError", "(", "vterrors", ".", "Aggregate", ")", "\n", "}" ]

[ "runSessions", "executes", "the", "action", "for", "all", "shardSessions", "in", "parallel", "and", "returns", "a", "consolildated", "error", "." ]

[ "func", "(", "txc", "*", "TxConn", ")", "runTargets", "(", "targets", "[", "]", "*", "querypb", ".", "Target", ",", "action", "func", "(", "*", "querypb", ".", "Target", ")", "error", ")", "error", "{", "if", "len", "(", "targets", ")", "==", "1", "{", "return", "action", "(", "targets", "[", "0", "]", ")", "\n", "}", "\n", "allErrors", ":=", "new", "(", "concurrency", ".", "AllErrorRecorder", ")", "\n", "var", "wg", "sync", ".", "WaitGroup", "\n", "for", "_", ",", "t", ":=", "range", "targets", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "t", "*", "querypb", ".", "Target", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "if", "err", ":=", "action", "(", "t", ")", ";", "err", "!=", "nil", "{", "allErrors", ".", "RecordError", "(", "err", ")", "\n", "}", "\n", "}", "(", "t", ")", "\n", "}", "\n", "wg", ".", "Wait", "(", ")", "\n", "return", "allErrors", ".", "AggrError", "(", "vterrors", ".", "Aggregate", ")", "\n", "}" ]

[ "runTargets", "executes", "the", "action", "for", "all", "targets", "in", "parallel", "and", "returns", "a", "consolildated", "error", ".", "Flow", "is", "identical", "to", "runSessions", "." ]

[ "func", "NewComboActionAgent", "(", "batchCtx", "context", ".", "Context", ",", "ts", "*", "topo", ".", "Server", ",", "tabletAlias", "*", "topodatapb", ".", "TabletAlias", ",", "vtPort", ",", "grpcPort", "int32", ",", "queryServiceControl", "tabletserver", ".", "Controller", ",", "dbcfgs", "*", "dbconfigs", ".", "DBConfigs", ",", "mysqlDaemon", "mysqlctl", ".", "MysqlDaemon", ",", "keyspace", ",", "shard", ",", "dbname", ",", "tabletType", "string", ")", "*", "ActionAgent", "{", "agent", ":=", "&", "ActionAgent", "{", "QueryServiceControl", ":", "queryServiceControl", ",", "UpdateStream", ":", "binlog", ".", "NewUpdateStreamControlMock", "(", ")", ",", "HealthReporter", ":", "health", ".", "DefaultAggregator", ",", "batchCtx", ":", "batchCtx", ",", "TopoServer", ":", "ts", ",", "TabletAlias", ":", "tabletAlias", ",", "Cnf", ":", "nil", ",", "MysqlDaemon", ":", "mysqlDaemon", ",", "DBConfigs", ":", "dbcfgs", ",", "VREngine", ":", "vreplication", ".", "NewEngine", "(", "nil", ",", "\"", "\"", ",", "nil", ",", "nil", ",", "\"", "\"", ")", ",", "gotMysqlPort", ":", "true", ",", "History", ":", "history", ".", "New", "(", "historyLength", ")", ",", "_healthy", ":", "fmt", ".", "Errorf", "(", "\"", "\"", ")", ",", "}", "\n", "agent", ".", "registerQueryRuleSources", "(", ")", "\n\n", "// Initialize the tablet.", "*", "initDbNameOverride", "=", "dbname", "\n", "*", "initKeyspace", "=", "keyspace", "\n", "*", "initShard", "=", "shard", "\n", "*", "initTabletType", "=", "tabletType", "\n", "if", "err", ":=", "agent", ".", "InitTablet", "(", "vtPort", ",", "grpcPort", ")", ";", "err", "!=", "nil", "{", "panic", "(", "vterrors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", ")", "\n", "}", "\n\n", "// Start the agent.", "if", "err", ":=", "agent", ".", "Start", "(", "batchCtx", ",", "\"", "\"", ",", "0", ",", "vtPort", ",", "grpcPort", ",", "false", ")", ";", "err", "!=", "nil", "{", "panic", "(", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "tabletAlias", ")", ")", "\n", "}", "\n\n", "// And update our running state (need to take the Action lock).", "if", "err", ":=", "agent", ".", "lock", "(", "batchCtx", ")", ";", "err", "!=", "nil", "{", "panic", "(", "vterrors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "defer", "agent", ".", "unlock", "(", ")", "\n", "if", "err", ":=", "agent", ".", "refreshTablet", "(", "batchCtx", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "panic", "(", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "tabletAlias", ")", ")", "\n", "}", "\n\n", "return", "agent", "\n", "}" ]

[ "NewComboActionAgent", "creates", "an", "agent", "tailored", "specifically", "to", "run", "within", "the", "vtcombo", "binary", ".", "It", "cannot", "be", "called", "concurrently", "as", "it", "changes", "the", "flags", "." ]

[ "func", "(", "agent", "*", "ActionAgent", ")", "Healthy", "(", ")", "(", "time", ".", "Duration", ",", "error", ")", "{", "agent", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "agent", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "healthy", ":=", "agent", ".", "_healthy", "\n", "if", "healthy", "==", "nil", "{", "timeSinceLastCheck", ":=", "time", ".", "Since", "(", "agent", ".", "_healthyTime", ")", "\n", "if", "timeSinceLastCheck", ">", "*", "healthCheckInterval", "*", "3", "{", "healthy", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "timeSinceLastCheck", ",", "*", "healthCheckInterval", "*", "3", ")", "\n", "}", "\n", "}", "\n\n", "return", "agent", ".", "_replicationDelay", ",", "healthy", "\n", "}" ]

[ "Healthy", "reads", "the", "result", "of", "the", "latest", "healthcheck", "protected", "by", "mutex", ".", "If", "that", "status", "is", "too", "old", "it", "means", "healthcheck", "hasn", "t", "run", "for", "a", "while", "and", "is", "probably", "stuck", "this", "is", "not", "good", "we", "re", "not", "healthy", "." ]

[ "func", "(", "agent", "*", "ActionAgent", ")", "BlacklistedTables", "(", ")", "[", "]", "string", "{", "agent", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "agent", ".", "mutex", ".", "Unlock", "(", ")", "\n", "return", "agent", ".", "_blacklistedTables", "\n", "}" ]

[ "BlacklistedTables", "returns", "the", "list", "of", "currently", "blacklisted", "tables", "." ]

[ "func", "(", "agent", "*", "ActionAgent", ")", "DisallowQueryService", "(", ")", "string", "{", "agent", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "agent", ".", "mutex", ".", "Unlock", "(", ")", "\n", "return", "agent", ".", "_disallowQueryService", "\n", "}" ]

[ "DisallowQueryService", "returns", "the", "reason", "the", "query", "service", "should", "be", "disabled", "if", "any", "." ]

[ "func", "(", "agent", "*", "ActionAgent", ")", "EnableUpdateStream", "(", ")", "bool", "{", "agent", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "agent", ".", "mutex", ".", "Unlock", "(", ")", "\n", "return", "agent", ".", "_enableUpdateStream", "\n", "}" ]

[ "EnableUpdateStream", "returns", "if", "we", "should", "enable", "update", "stream", "or", "not" ]

[ "func", "(", "agent", "*", "ActionAgent", ")", "Close", "(", ")", "{", "// cleanup initialized fields in the tablet entry", "f", ":=", "func", "(", "tablet", "*", "topodatapb", ".", "Tablet", ")", "error", "{", "if", "err", ":=", "topotools", ".", "CheckOwnership", "(", "agent", ".", "initialTablet", ",", "tablet", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "tablet", ".", "Hostname", "=", "\"", "\"", "\n", "tablet", ".", "MysqlHostname", "=", "\"", "\"", "\n", "tablet", ".", "PortMap", "=", "nil", "\n", "return", "nil", "\n", "}", "\n", "if", "_", ",", "err", ":=", "agent", ".", "TopoServer", ".", "UpdateTabletFields", "(", "context", ".", "Background", "(", ")", ",", "agent", ".", "TabletAlias", ",", "f", ")", ";", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "Close", "prepares", "a", "tablet", "for", "shutdown", ".", "First", "we", "check", "our", "tablet", "ownership", "and", "then", "prune", "the", "tablet", "topology", "entry", "of", "all", "post", "-", "init", "fields", ".", "This", "prevents", "stale", "identifiers", "from", "hanging", "around", "in", "topology", "." ]

[ "func", "(", "agent", "*", "ActionAgent", ")", "Stop", "(", ")", "{", "if", "agent", ".", "UpdateStream", "!=", "nil", "{", "agent", ".", "UpdateStream", ".", "Disable", "(", ")", "\n", "}", "\n", "agent", ".", "VREngine", ".", "Close", "(", ")", "\n", "if", "agent", ".", "MysqlDaemon", "!=", "nil", "{", "agent", ".", "MysqlDaemon", ".", "Close", "(", ")", "\n", "}", "\n", "}" ]

[ "Stop", "shuts", "down", "the", "agent", ".", "Normally", "this", "is", "not", "necessary", "since", "we", "use", "servenv", "OnTerm", "and", "OnClose", "hooks", "to", "coordinate", "shutdown", "automatically", "while", "taking", "lameduck", "into", "account", ".", "However", "this", "may", "be", "useful", "for", "tests", "when", "you", "want", "to", "clean", "up", "an", "agent", "immediately", "." ]

[ "func", "(", "agent", "*", "ActionAgent", ")", "hookExtraEnv", "(", ")", "map", "[", "string", "]", "string", "{", "return", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "topoproto", ".", "TabletAliasString", "(", "agent", ".", "TabletAlias", ")", "}", "\n", "}" ]

[ "hookExtraEnv", "returns", "the", "map", "to", "pass", "to", "local", "hooks" ]

[ "func", "(", "agent", "*", "ActionAgent", ")", "checkTabletMysqlPort", "(", "ctx", "context", ".", "Context", ",", "tablet", "*", "topodatapb", ".", "Tablet", ")", "*", "topodatapb", ".", "Tablet", "{", "agent", ".", "checkLock", "(", ")", "\n", "mport", ",", "err", ":=", "agent", ".", "MysqlDaemon", ".", "GetMysqlPort", "(", ")", "\n", "if", "err", "!=", "nil", "{", "// Only log the first time, so we don't spam the logs.", "if", "!", "agent", ".", "waitingForMysql", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "agent", ".", "waitingForMysql", "=", "true", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "if", "mport", "==", "topoproto", ".", "MysqlPort", "(", "tablet", ")", "{", "// The topology record contains the right port.", "// Remember we successfully checked it, and that we're", "// not waiting on MySQL to start any more.", "agent", ".", "gotMysqlPort", "=", "true", "\n", "agent", ".", "waitingForMysql", "=", "false", "\n", "return", "nil", "\n", "}", "\n\n", "// Update the port in the topology. Use a shorter timeout, so if", "// the topo server is busy / throttling us, we don't hang forever here.", "// The healthcheck go routine will try again next time.", "ctx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "ctx", ",", "10", "*", "time", ".", "Second", ")", "\n", "defer", "cancel", "(", ")", "\n", "if", "!", "agent", ".", "waitingForMysql", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "topoproto", ".", "MysqlPort", "(", "tablet", ")", ",", "mport", ")", "\n", "}", "\n", "newTablet", ",", "err", ":=", "agent", ".", "TopoServer", ".", "UpdateTabletFields", "(", "ctx", ",", "tablet", ".", "Alias", ",", "func", "(", "t", "*", "topodatapb", ".", "Tablet", ")", "error", "{", "if", "err", ":=", "topotools", ".", "CheckOwnership", "(", "agent", ".", "initialTablet", ",", "tablet", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "topoproto", ".", "SetMysqlPort", "(", "t", ",", "mport", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "agent", ".", "waitingForMysql", "{", "// After this, we will try again on every", "// heartbeat to go through this code, but we", "// won't log it.", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "agent", ".", "waitingForMysql", "=", "true", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "// Update worked, return the new record, so the agent can save it.", "// This should not happen often, so we can log it.", "log", ".", "Infof", "(", "\"", "\"", ",", "topoproto", ".", "MysqlPort", "(", "tablet", ")", ",", "mport", ")", "\n", "agent", ".", "gotMysqlPort", "=", "true", "\n", "agent", ".", "waitingForMysql", "=", "false", "\n", "return", "newTablet", "\n", "}" ]

[ "checkTabletMysqlPort", "will", "check", "the", "mysql", "port", "for", "the", "tablet", "is", "good", "and", "if", "not", "will", "try", "to", "update", "it", ".", "It", "returns", "the", "modified", "Tablet", "record", "if", "it", "was", "updated", "successfully", "in", "the", "topology", "server", ".", "We", "use", "the", "agent", ".", "waitingForMysql", "flag", "to", "log", "only", "the", "first", "error", "we", "get", "when", "trying", "to", "get", "the", "port", "from", "MySQL", "and", "store", "it", "in", "the", "topology", ".", "That", "way", "we", "don", "t", "spam", "the", "logs", ".", "The", "actionMutex", "lock", "must", "be", "held", "when", "calling", "this", "function", "." ]

[ "func", "ResultToProto3", "(", "qr", "*", "Result", ")", "*", "querypb", ".", "QueryResult", "{", "if", "qr", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "&", "querypb", ".", "QueryResult", "{", "Fields", ":", "qr", ".", "Fields", ",", "RowsAffected", ":", "qr", ".", "RowsAffected", ",", "InsertId", ":", "qr", ".", "InsertID", ",", "Rows", ":", "RowsToProto3", "(", "qr", ".", "Rows", ")", ",", "Extras", ":", "qr", ".", "Extras", ",", "}", "\n", "}" ]

[ "ResultToProto3", "converts", "Result", "to", "proto3", "." ]

[ "func", "Proto3ToResult", "(", "qr", "*", "querypb", ".", "QueryResult", ")", "*", "Result", "{", "if", "qr", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "&", "Result", "{", "Fields", ":", "qr", ".", "Fields", ",", "RowsAffected", ":", "qr", ".", "RowsAffected", ",", "InsertID", ":", "qr", ".", "InsertId", ",", "Rows", ":", "proto3ToRows", "(", "qr", ".", "Fields", ",", "qr", ".", "Rows", ")", ",", "Extras", ":", "qr", ".", "Extras", ",", "}", "\n", "}" ]

[ "Proto3ToResult", "converts", "a", "proto3", "Result", "to", "an", "internal", "data", "structure", ".", "This", "function", "should", "be", "used", "only", "if", "the", "field", "info", "is", "populated", "in", "qr", "." ]

[ "func", "CustomProto3ToResult", "(", "fields", "[", "]", "*", "querypb", ".", "Field", ",", "qr", "*", "querypb", ".", "QueryResult", ")", "*", "Result", "{", "if", "qr", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "&", "Result", "{", "Fields", ":", "qr", ".", "Fields", ",", "RowsAffected", ":", "qr", ".", "RowsAffected", ",", "InsertID", ":", "qr", ".", "InsertId", ",", "Rows", ":", "proto3ToRows", "(", "fields", ",", "qr", ".", "Rows", ")", ",", "Extras", ":", "qr", ".", "Extras", ",", "}", "\n", "}" ]

[ "CustomProto3ToResult", "converts", "a", "proto3", "Result", "to", "an", "internal", "data", "structure", ".", "This", "function", "takes", "a", "separate", "fields", "input", "because", "not", "all", "QueryResults", "contain", "the", "field", "info", ".", "In", "particular", "only", "the", "first", "packet", "of", "streaming", "queries", "contain", "the", "field", "info", "." ]

[ "func", "Proto3ResultsEqual", "(", "r1", ",", "r2", "[", "]", "*", "querypb", ".", "QueryResult", ")", "bool", "{", "if", "len", "(", "r1", ")", "!=", "len", "(", "r2", ")", "{", "return", "false", "\n", "}", "\n", "for", "i", ",", "r", ":=", "range", "r1", "{", "if", "!", "proto", ".", "Equal", "(", "r", ",", "r2", "[", "i", "]", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Proto3ResultsEqual", "compares", "two", "arrays", "of", "proto3", "Result", ".", "reflect", ".", "DeepEqual", "shouldn", "t", "be", "used", "because", "of", "the", "protos", "." ]

[ "func", "Proto3QueryResponsesEqual", "(", "r1", ",", "r2", "[", "]", "*", "querypb", ".", "ResultWithError", ")", "bool", "{", "if", "len", "(", "r1", ")", "!=", "len", "(", "r2", ")", "{", "return", "false", "\n", "}", "\n", "for", "i", ",", "r", ":=", "range", "r1", "{", "if", "!", "proto", ".", "Equal", "(", "r", ",", "r2", "[", "i", "]", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Proto3QueryResponsesEqual", "compares", "two", "arrays", "of", "proto3", "QueryResponse", ".", "reflect", ".", "DeepEqual", "shouldn", "t", "be", "used", "because", "of", "the", "protos", "." ]

[ "func", "Proto3ValuesEqual", "(", "v1", ",", "v2", "[", "]", "*", "querypb", ".", "Value", ")", "bool", "{", "if", "len", "(", "v1", ")", "!=", "len", "(", "v2", ")", "{", "return", "false", "\n", "}", "\n", "for", "i", ",", "v", ":=", "range", "v1", "{", "if", "!", "proto", ".", "Equal", "(", "v", ",", "v2", "[", "i", "]", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Proto3ValuesEqual", "compares", "two", "arrays", "of", "proto3", "Value", "." ]

[ "func", "SplitQueryResponsePartsEqual", "(", "s1", ",", "s2", "[", "]", "*", "vtgatepb", ".", "SplitQueryResponse_Part", ")", "bool", "{", "if", "len", "(", "s1", ")", "!=", "len", "(", "s2", ")", "{", "return", "false", "\n", "}", "\n", "for", "i", ",", "s", ":=", "range", "s1", "{", "if", "!", "proto", ".", "Equal", "(", "s", ",", "s2", "[", "i", "]", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "SplitQueryResponsePartsEqual", "compares", "two", "arrays", "of", "SplitQueryResponse_Part", "." ]

[ "func", "ParseStrictDDL", "(", "sql", "string", ")", "(", "Statement", ",", "error", ")", "{", "tokenizer", ":=", "NewStringTokenizer", "(", "sql", ")", "\n", "if", "yyParsePooled", "(", "tokenizer", ")", "!=", "0", "{", "return", "nil", ",", "tokenizer", ".", "LastError", "\n", "}", "\n", "if", "tokenizer", ".", "ParseTree", "==", "nil", "{", "return", "nil", ",", "ErrEmpty", "\n", "}", "\n", "return", "tokenizer", ".", "ParseTree", ",", "nil", "\n", "}" ]

[ "ParseStrictDDL", "is", "the", "same", "as", "Parse", "except", "it", "errors", "on", "partially", "parsed", "DDL", "statements", "." ]

[ "func", "SplitStatement", "(", "blob", "string", ")", "(", "string", ",", "string", ",", "error", ")", "{", "tokenizer", ":=", "NewStringTokenizer", "(", "blob", ")", "\n", "tkn", ":=", "0", "\n", "for", "{", "tkn", ",", "_", "=", "tokenizer", ".", "Scan", "(", ")", "\n", "if", "tkn", "==", "0", "||", "tkn", "==", "';'", "||", "tkn", "==", "eofChar", "{", "break", "\n", "}", "\n", "}", "\n", "if", "tokenizer", ".", "LastError", "!=", "nil", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "tokenizer", ".", "LastError", "\n", "}", "\n", "if", "tkn", "==", "';'", "{", "return", "blob", "[", ":", "tokenizer", ".", "Position", "-", "2", "]", ",", "blob", "[", "tokenizer", ".", "Position", "-", "1", ":", "]", ",", "nil", "\n", "}", "\n", "return", "blob", ",", "\"", "\"", ",", "nil", "\n", "}" ]

[ "SplitStatement", "returns", "the", "first", "sql", "statement", "up", "to", "either", "a", ";", "or", "EOF", "and", "the", "remainder", "from", "the", "given", "buffer" ]

[ "func", "SplitStatementToPieces", "(", "blob", "string", ")", "(", "pieces", "[", "]", "string", ",", "err", "error", ")", "{", "pieces", "=", "make", "(", "[", "]", "string", ",", "0", ",", "16", ")", "\n", "tokenizer", ":=", "NewStringTokenizer", "(", "blob", ")", "\n\n", "tkn", ":=", "0", "\n", "var", "stmt", "string", "\n", "stmtBegin", ":=", "0", "\n", "for", "{", "tkn", ",", "_", "=", "tokenizer", ".", "Scan", "(", ")", "\n", "if", "tkn", "==", "';'", "{", "stmt", "=", "blob", "[", "stmtBegin", ":", "tokenizer", ".", "Position", "-", "2", "]", "\n", "pieces", "=", "append", "(", "pieces", ",", "stmt", ")", "\n", "stmtBegin", "=", "tokenizer", ".", "Position", "-", "1", "\n\n", "}", "else", "if", "tkn", "==", "0", "||", "tkn", "==", "eofChar", "{", "blobTail", ":=", "tokenizer", ".", "Position", "-", "2", "\n\n", "if", "stmtBegin", "<", "blobTail", "{", "stmt", "=", "blob", "[", "stmtBegin", ":", "blobTail", "+", "1", "]", "\n", "pieces", "=", "append", "(", "pieces", ",", "stmt", ")", "\n", "}", "\n", "break", "\n", "}", "\n", "}", "\n\n", "err", "=", "tokenizer", ".", "LastError", "\n", "return", "\n", "}" ]

[ "SplitStatementToPieces", "split", "raw", "sql", "statement", "that", "may", "have", "multi", "sql", "pieces", "to", "sql", "pieces", "returns", "the", "sql", "pieces", "blob", "contains", ";", "or", "error", "if", "sql", "cannot", "be", "parsed" ]

[ "func", "Walk", "(", "visit", "Visit", ",", "nodes", "...", "SQLNode", ")", "error", "{", "for", "_", ",", "node", ":=", "range", "nodes", "{", "if", "node", "==", "nil", "{", "continue", "\n", "}", "\n", "kontinue", ",", "err", ":=", "visit", "(", "node", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "kontinue", "{", "err", "=", "node", ".", "walkSubtree", "(", "visit", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Walk", "calls", "visit", "on", "every", "node", ".", "If", "visit", "returns", "true", "the", "underlying", "nodes", "are", "also", "visited", ".", "If", "it", "returns", "an", "error", "walking", "is", "interrupted", "and", "the", "error", "is", "returned", "." ]

[ "func", "String", "(", "node", "SQLNode", ")", "string", "{", "if", "node", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n\n", "buf", ":=", "NewTrackedBuffer", "(", "nil", ")", "\n", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "node", ")", "\n", "return", "buf", ".", "String", "(", ")", "\n", "}" ]

[ "String", "returns", "a", "string", "representation", "of", "an", "SQLNode", "." ]

[ "func", "Append", "(", "buf", "*", "strings", ".", "Builder", ",", "node", "SQLNode", ")", "{", "tbuf", ":=", "&", "TrackedBuffer", "{", "Builder", ":", "buf", ",", "}", "\n", "node", ".", "Format", "(", "tbuf", ")", "\n", "}" ]

[ "Append", "appends", "the", "SQLNode", "to", "the", "buffer", "." ]

[ "func", "(", "node", "*", "Select", ")", "AddWhere", "(", "expr", "Expr", ")", "{", "if", "_", ",", "ok", ":=", "expr", ".", "(", "*", "OrExpr", ")", ";", "ok", "{", "expr", "=", "&", "ParenExpr", "{", "Expr", ":", "expr", "}", "\n", "}", "\n", "if", "node", ".", "Where", "==", "nil", "{", "node", ".", "Where", "=", "&", "Where", "{", "Type", ":", "WhereStr", ",", "Expr", ":", "expr", ",", "}", "\n", "return", "\n", "}", "\n", "node", ".", "Where", ".", "Expr", "=", "&", "AndExpr", "{", "Left", ":", "node", ".", "Where", ".", "Expr", ",", "Right", ":", "expr", ",", "}", "\n", "}" ]

[ "AddWhere", "adds", "the", "boolean", "expression", "to", "the", "WHERE", "clause", "as", "an", "AND", "condition", ".", "If", "the", "expression", "is", "an", "OR", "clause", "it", "parenthesizes", "it", ".", "Currently", "the", "OR", "operator", "is", "the", "only", "one", "that", "s", "lower", "precedence", "than", "AND", "." ]

[ "func", "(", "node", "*", "Select", ")", "AddHaving", "(", "expr", "Expr", ")", "{", "if", "_", ",", "ok", ":=", "expr", ".", "(", "*", "OrExpr", ")", ";", "ok", "{", "expr", "=", "&", "ParenExpr", "{", "Expr", ":", "expr", "}", "\n", "}", "\n", "if", "node", ".", "Having", "==", "nil", "{", "node", ".", "Having", "=", "&", "Where", "{", "Type", ":", "HavingStr", ",", "Expr", ":", "expr", ",", "}", "\n", "return", "\n", "}", "\n", "node", ".", "Having", ".", "Expr", "=", "&", "AndExpr", "{", "Left", ":", "node", ".", "Having", ".", "Expr", ",", "Right", ":", "expr", ",", "}", "\n", "}" ]

[ "AddHaving", "adds", "the", "boolean", "expression", "to", "the", "HAVING", "clause", "as", "an", "AND", "condition", ".", "If", "the", "expression", "is", "an", "OR", "clause", "it", "parenthesizes", "it", ".", "Currently", "the", "OR", "operator", "is", "the", "only", "one", "that", "s", "lower", "precedence", "than", "AND", "." ]

[ "func", "(", "node", "*", "DDL", ")", "AffectedTables", "(", ")", "TableNames", "{", "if", "node", ".", "Action", "==", "RenameStr", "||", "node", ".", "Action", "==", "DropStr", "{", "list", ":=", "make", "(", "TableNames", ",", "0", ",", "len", "(", "node", ".", "FromTables", ")", "+", "len", "(", "node", ".", "ToTables", ")", ")", "\n", "list", "=", "append", "(", "list", ",", "node", ".", "FromTables", "...", ")", "\n", "list", "=", "append", "(", "list", ",", "node", ".", "ToTables", "...", ")", "\n", "return", "list", "\n", "}", "\n", "return", "TableNames", "{", "node", ".", "Table", "}", "\n", "}" ]

[ "AffectedTables", "returns", "the", "list", "table", "names", "affected", "by", "the", "DDL", "." ]

[ "func", "(", "ts", "*", "TableSpec", ")", "AddColumn", "(", "cd", "*", "ColumnDefinition", ")", "{", "ts", ".", "Columns", "=", "append", "(", "ts", ".", "Columns", ",", "cd", ")", "\n", "}" ]

[ "AddColumn", "appends", "the", "given", "column", "to", "the", "list", "in", "the", "spec" ]

[ "func", "(", "ts", "*", "TableSpec", ")", "AddIndex", "(", "id", "*", "IndexDefinition", ")", "{", "ts", ".", "Indexes", "=", "append", "(", "ts", ".", "Indexes", ",", "id", ")", "\n", "}" ]

[ "AddIndex", "appends", "the", "given", "index", "to", "the", "list", "in", "the", "spec" ]

[ "func", "(", "ts", "*", "TableSpec", ")", "AddConstraint", "(", "cd", "*", "ConstraintDefinition", ")", "{", "ts", ".", "Constraints", "=", "append", "(", "ts", ".", "Constraints", ",", "cd", ")", "\n", "}" ]

[ "AddConstraint", "appends", "the", "given", "index", "to", "the", "list", "in", "the", "spec" ]

[ "func", "(", "ct", "*", "ColumnType", ")", "Format", "(", "buf", "*", "TrackedBuffer", ")", "{", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "ct", ".", "Type", ")", "\n\n", "if", "ct", ".", "Length", "!=", "nil", "&&", "ct", ".", "Scale", "!=", "nil", "{", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "ct", ".", "Length", ",", "ct", ".", "Scale", ")", "\n\n", "}", "else", "if", "ct", ".", "Length", "!=", "nil", "{", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "ct", ".", "Length", ")", "\n", "}", "\n\n", "if", "ct", ".", "EnumValues", "!=", "nil", "{", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "ct", ".", "EnumValues", ",", "\"", "\"", ")", ")", "\n", "}", "\n\n", "opts", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "16", ")", "\n", "if", "ct", ".", "Unsigned", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "UNSIGNED", "]", ")", "\n", "}", "\n", "if", "ct", ".", "Zerofill", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "ZEROFILL", "]", ")", "\n", "}", "\n", "if", "ct", ".", "Charset", "!=", "\"", "\"", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "CHARACTER", "]", ",", "keywordStrings", "[", "SET", "]", ",", "ct", ".", "Charset", ")", "\n", "}", "\n", "if", "ct", ".", "Collate", "!=", "\"", "\"", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "COLLATE", "]", ",", "ct", ".", "Collate", ")", "\n", "}", "\n", "if", "ct", ".", "NotNull", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "NOT", "]", ",", "keywordStrings", "[", "NULL", "]", ")", "\n", "}", "\n", "if", "ct", ".", "Default", "!=", "nil", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "DEFAULT", "]", ",", "String", "(", "ct", ".", "Default", ")", ")", "\n", "}", "\n", "if", "ct", ".", "OnUpdate", "!=", "nil", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "ON", "]", ",", "keywordStrings", "[", "UPDATE", "]", ",", "String", "(", "ct", ".", "OnUpdate", ")", ")", "\n", "}", "\n", "if", "ct", ".", "Autoincrement", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "AUTO_INCREMENT", "]", ")", "\n", "}", "\n", "if", "ct", ".", "Comment", "!=", "nil", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "COMMENT_KEYWORD", "]", ",", "String", "(", "ct", ".", "Comment", ")", ")", "\n", "}", "\n", "if", "ct", ".", "KeyOpt", "==", "colKeyPrimary", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "PRIMARY", "]", ",", "keywordStrings", "[", "KEY", "]", ")", "\n", "}", "\n", "if", "ct", ".", "KeyOpt", "==", "colKeyUnique", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "UNIQUE", "]", ")", "\n", "}", "\n", "if", "ct", ".", "KeyOpt", "==", "colKeyUniqueKey", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "UNIQUE", "]", ",", "keywordStrings", "[", "KEY", "]", ")", "\n", "}", "\n", "if", "ct", ".", "KeyOpt", "==", "colKeySpatialKey", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "SPATIAL", "]", ",", "keywordStrings", "[", "KEY", "]", ")", "\n", "}", "\n", "if", "ct", ".", "KeyOpt", "==", "colKey", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "KEY", "]", ")", "\n", "}", "\n\n", "if", "len", "(", "opts", ")", "!=", "0", "{", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "opts", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "}" ]

[ "Format", "returns", "a", "canonical", "string", "representation", "of", "the", "type", "and", "all", "relevant", "options" ]

[ "func", "(", "ct", "*", "ColumnType", ")", "DescribeType", "(", ")", "string", "{", "buf", ":=", "NewTrackedBuffer", "(", "nil", ")", "\n", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "ct", ".", "Type", ")", "\n", "if", "ct", ".", "Length", "!=", "nil", "&&", "ct", ".", "Scale", "!=", "nil", "{", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "ct", ".", "Length", ",", "ct", ".", "Scale", ")", "\n", "}", "else", "if", "ct", ".", "Length", "!=", "nil", "{", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "ct", ".", "Length", ")", "\n", "}", "\n\n", "opts", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "16", ")", "\n", "if", "ct", ".", "Unsigned", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "UNSIGNED", "]", ")", "\n", "}", "\n", "if", "ct", ".", "Zerofill", "{", "opts", "=", "append", "(", "opts", ",", "keywordStrings", "[", "ZEROFILL", "]", ")", "\n", "}", "\n", "if", "len", "(", "opts", ")", "!=", "0", "{", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "opts", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "return", "buf", ".", "String", "(", ")", "\n", "}" ]

[ "DescribeType", "returns", "the", "abbreviated", "type", "information", "as", "required", "for", "describe", "table" ]

[ "func", "(", "node", "*", "VindexSpec", ")", "ParseParams", "(", ")", "(", "string", ",", "map", "[", "string", "]", "string", ")", "{", "var", "owner", "string", "\n", "params", ":=", "map", "[", "string", "]", "string", "{", "}", "\n", "for", "_", ",", "p", ":=", "range", "node", ".", "Params", "{", "if", "p", ".", "Key", ".", "Lowered", "(", ")", "==", "VindexOwnerStr", "{", "owner", "=", "p", ".", "Val", "\n", "}", "else", "{", "params", "[", "p", ".", "Key", ".", "String", "(", ")", "]", "=", "p", ".", "Val", "\n", "}", "\n", "}", "\n", "return", "owner", ",", "params", "\n", "}" ]

[ "ParseParams", "parses", "the", "vindex", "parameter", "list", "pulling", "out", "the", "special", "-", "case", "owner", "parameter" ]

[ "func", "(", "node", "*", "VindexSpec", ")", "Format", "(", "buf", "*", "TrackedBuffer", ")", "{", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "node", ".", "Type", ")", "\n\n", "numParams", ":=", "len", "(", "node", ".", "Params", ")", "\n", "if", "numParams", "!=", "0", "{", "buf", ".", "Myprintf", "(", "\"", "\"", ")", "\n", "for", "i", ",", "p", ":=", "range", "node", ".", "Params", "{", "if", "i", "!=", "0", "{", "buf", ".", "Myprintf", "(", "\"", "\"", ")", "\n", "}", "\n", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "p", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Format", "formats", "the", "node", ".", "The", "CREATE", "VINDEX", "preamble", "was", "formatted", "in", "the", "containing", "DDL", "node", "Format", "so", "this", "just", "prints", "the", "type", "any", "parameters", "and", "optionally", "the", "owner" ]

[ "func", "(", "node", "Columns", ")", "FindColumn", "(", "col", "ColIdent", ")", "int", "{", "for", "i", ",", "colName", ":=", "range", "node", "{", "if", "colName", ".", "Equal", "(", "col", ")", "{", "return", "i", "\n", "}", "\n", "}", "\n", "return", "-", "1", "\n", "}" ]

[ "FindColumn", "finds", "a", "column", "in", "the", "column", "list", "returning", "the", "index", "if", "it", "exists", "or", "-", "1", "otherwise" ]

[ "func", "(", "node", "*", "AliasedTableExpr", ")", "RemoveHints", "(", ")", "*", "AliasedTableExpr", "{", "noHints", ":=", "*", "node", "\n", "noHints", ".", "Hints", "=", "nil", "\n", "return", "&", "noHints", "\n", "}" ]

[ "RemoveHints", "returns", "a", "new", "AliasedTableExpr", "with", "the", "hints", "removed", "." ]

[ "func", "(", "node", "TableName", ")", "ToViewName", "(", ")", "TableName", "{", "return", "TableName", "{", "Qualifier", ":", "node", ".", "Qualifier", ",", "Name", ":", "NewTableIdent", "(", "strings", ".", "ToLower", "(", "node", ".", "Name", ".", "v", ")", ")", ",", "}", "\n", "}" ]

[ "ToViewName", "returns", "a", "TableName", "acceptable", "for", "use", "as", "a", "VIEW", ".", "VIEW", "names", "are", "always", "lowercase", "so", "ToViewName", "lowercasese", "the", "name", ".", "Databases", "are", "case", "-", "sensitive", "so", "Qualifier", "is", "left", "untouched", "." ]

[ "func", "ReplaceExpr", "(", "root", ",", "from", ",", "to", "Expr", ")", "Expr", "{", "if", "root", "==", "from", "{", "return", "to", "\n", "}", "\n", "root", ".", "replace", "(", "from", ",", "to", ")", "\n", "return", "root", "\n", "}" ]

[ "ReplaceExpr", "finds", "the", "from", "expression", "from", "root", "and", "replaces", "it", "with", "to", ".", "If", "from", "matches", "root", "then", "to", "is", "returned", "." ]