Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "(", "rc", "*", "Connector", ")", "Shutdown", "(", ")", "error", "{", "hasError", ":=", "false", "\n", "rConnErr", ":=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "for", "_", ",", "c", ":=", "range", "rc", ".", "connectors", "{", "err", ":=", "c", ".", "Shutdown", "(", ")", "\n", "if", "err", "!=", "nil", "{", "// save errors here, continue to shut down other connectors", "hasError", "=", "true", "\n", "err", "=", "errors", ".", "Wrap", "(", "rConnErr", ",", "err", ".", "Error", "(", ")", ")", "\n", "continue", "\n", "}", "\n", "}", "\n\n", "if", "hasError", "{", "return", "rConnErr", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Shutdown", "shut", "down", "all", "connectors", "that", "routing", "connector", "talks", "to" ]

[ "func", "(", "m", "*", "MockScope", ")", "Counter", "(", "name", "string", ")", "metrics", ".", "Counter", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "name", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "metrics", ".", "Counter", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Counter", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockScope", ")", "Tagged", "(", "tags", "map", "[", "string", "]", "string", ")", "metrics", ".", "Scope", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "tags", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "metrics", ".", "Scope", ")", "\n", "return", "ret0", "\n", "}" ]

[ "Tagged", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockScopeMockRecorder", ")", "Tagged", "(", "tags", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockScope", ")", "(", "nil", ")", ".", "Tagged", ")", ",", "tags", ")", "\n", "}" ]

[ "Tagged", "indicates", "an", "expected", "call", "of", "Tagged" ]

[ "func", "(", "m", "*", "MockScope", ")", "SubScope", "(", "name", "string", ")", "metrics", ".", "Scope", "{", "ret", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "name", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "metrics", ".", "Scope", ")", "\n", "return", "ret0", "\n", "}" ]

[ "SubScope", "mocks", "base", "method" ]

[ "func", "(", "mr", "*", "MockScopeMockRecorder", ")", "Timer", "(", "name", "interface", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockScope", ")", "(", "nil", ")", ".", "Timer", ")", ",", "name", ")", "\n", "}" ]

[ "Timer", "indicates", "an", "expected", "call", "of", "Timer" ]

[ "func", "(", "m", "*", "MockCounter", ")", "Inc", "(", "delta", "int64", ")", "{", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "delta", ")", "\n", "}" ]

[ "Inc", "mocks", "base", "method" ]

[ "func", "(", "c", "*", "ScopeCreate", ")", "Execute", "(", "args", "[", "]", "string", ")", "error", "{", "typ", ",", "err", ":=", "parseType", "(", "c", ".", "Type", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "len", "(", "c", ".", "Owner", ")", "==", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "c", ".", "doScopeOp", "(", "\"", "\"", ",", "func", "(", "client", "dosa", ".", "AdminClient", ",", "ctx", "context", ".", "Context", ",", "scope", "string", ")", "error", "{", "return", "dosa", ".", "AdminClient", ".", "CreateScope", "(", "client", ",", "ctx", ",", "&", "dosa", ".", "ScopeMetadata", "{", "Name", ":", "scope", ",", "Owner", ":", "c", ".", "Owner", ",", "Type", ":", "int32", "(", "typ", ")", ",", "Creator", ":", "*", "dosa", ".", "GetUsername", "(", ")", ",", "Cluster", ":", "c", ".", "Cluster", ",", "ReadMaxRPS", ":", "c", ".", "ReadRPS", ",", "WriteMaxRPS", ":", "c", ".", "WriteRPS", ",", "}", ")", "\n", "}", ",", "c", ".", "Args", ".", "Scopes", ")", "\n", "}" ]

[ "Execute", "executes", "a", "scope", "create", "command" ]

[ "func", "(", "c", "*", "ScopeDrop", ")", "Execute", "(", "args", "[", "]", "string", ")", "error", "{", "return", "c", ".", "doScopeOp", "(", "\"", "\"", ",", "dosa", ".", "AdminClient", ".", "DropScope", ",", "c", ".", "Args", ".", "Scopes", ")", "\n", "}" ]

[ "Execute", "executes", "a", "scope", "drop", "command" ]

[ "func", "(", "c", "*", "ScopeTruncate", ")", "Execute", "(", "args", "[", "]", "string", ")", "error", "{", "return", "c", ".", "doScopeOp", "(", "\"", "\"", ",", "dosa", ".", "AdminClient", ".", "TruncateScope", ",", "c", ".", "Args", ".", "Scopes", ")", "\n", "}" ]

[ "Execute", "executes", "a", "scope", "truncate", "command" ]

[ "func", "parseType", "(", "t", "string", ")", "(", "dosa", ".", "ScopeType", ",", "error", ")", "{", "if", "len", "(", "t", ")", "==", "0", "{", "return", "dosa", ".", "Development", ",", "nil", "\n", "}", "\n", "lt", ":=", "strings", ".", "ToLower", "(", "t", ")", "\n", "if", "strings", ".", "HasPrefix", "(", "\"", "\"", ",", "lt", ")", "{", "return", "dosa", ".", "Production", ",", "nil", "\n", "}", "\n", "if", "strings", ".", "HasPrefix", "(", "\"", "\"", ",", "lt", ")", "{", "return", "dosa", ".", "Staging", ",", "nil", "\n", "}", "\n", "if", "strings", ".", "HasPrefix", "(", "\"", "\"", ",", "lt", ")", "{", "return", "dosa", ".", "Development", ",", "nil", "\n", "}", "\n", "return", "dosa", ".", "Development", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "t", ")", "\n", "}" ]

[ "Parse", "a", "string", "into", "a", "scope", "type", "." ]

[ "func", "FindEntityByName", "(", "path", "string", ",", "structName", "string", ")", "(", "*", "Table", ",", "error", ")", "{", "// find all entites in the given path", "entities", ",", "_", ",", "err", ":=", "findEntities", "(", "[", "]", "string", "{", "path", "}", ",", "[", "]", "string", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// filter entites with the given struct name", "entitiesFilteredByName", ":=", "[", "]", "*", "Table", "{", "}", "\n", "for", "_", ",", "table", ":=", "range", "entities", "{", "if", "table", ".", "StructName", "==", "structName", "{", "entitiesFilteredByName", "=", "append", "(", "entitiesFilteredByName", ",", "table", ")", "\n", "}", "\n", "}", "\n\n", "// only one entity with given name should be found", "if", "len", "(", "entitiesFilteredByName", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "structName", ",", "path", ")", "\n", "}", "\n", "if", "len", "(", "entitiesFilteredByName", ")", ">", "1", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "structName", ",", "path", ")", "\n", "}", "\n\n", "return", "entitiesFilteredByName", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "FindEntityByName", "returns", "the", "entity", "with", "given", "name", "in", "the", "path", "." ]

[ "func", "(", "f", "*", "entityRecordingVisitor", ")", "Visit", "(", "n", "ast", ".", "Node", ")", "ast", ".", "Visitor", "{", "switch", "n", ":=", "n", ".", "(", "type", ")", "{", "case", "*", "ast", ".", "File", ",", "*", "ast", ".", "Package", ",", "*", "ast", ".", "BlockStmt", ",", "*", "ast", ".", "DeclStmt", ",", "*", "ast", ".", "FuncDecl", ",", "*", "ast", ".", "GenDecl", ":", "return", "f", "\n", "case", "*", "ast", ".", "TypeSpec", ":", "if", "structType", ",", "ok", ":=", "n", ".", "Type", ".", "(", "*", "ast", ".", "StructType", ")", ";", "ok", "{", "// look for a Entity with a dosa annotation", "if", "isDosaEntity", "(", "structType", ")", "{", "table", ",", "err", ":=", "tableFromStructType", "(", "n", ".", "Name", ".", "Name", ",", "structType", ",", "f", ".", "packagePrefix", ")", "\n", "if", "err", "==", "nil", "{", "f", ".", "entities", "=", "append", "(", "f", ".", "entities", ",", "table", ")", "\n", "}", "else", "{", "f", ".", "warnings", "=", "append", "(", "f", ".", "warnings", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Visit", "records", "all", "the", "entities", "seen", "into", "the", "entityRecordingVisitor", "structure" ]

[ "func", "newSimpleRegistrar", "(", "scope", ",", "namePrefix", "string", ",", "table", "*", "dosa", ".", "Table", ")", "(", "dosa", ".", "Registrar", ",", "error", ")", "{", "if", "err", ":=", "dosa", ".", "IsValidNamePrefix", "(", "namePrefix", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "re", ":=", "dosa", ".", "NewRegisteredEntity", "(", "scope", ",", "namePrefix", ",", "table", ")", "\n\n", "return", "&", "simpleRegistrar", "{", "scope", ":", "scope", ",", "namePrefix", ":", "namePrefix", ",", "entity", ":", "re", ",", "}", ",", "nil", "\n", "}" ]

[ "newSimpleRegistrar", "creates", "a", "new", "simpleRegistrar" ]

[ "func", "(", "r", "*", "simpleRegistrar", ")", "Find", "(", "entity", "dosa", ".", "DomainObject", ")", "(", "*", "dosa", ".", "RegisteredEntity", ",", "error", ")", "{", "if", "r", ".", "entity", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "r", ".", "entity", ",", "nil", "\n", "}" ]

[ "Find", "returns", "the", "embedded", "entity" ]

[ "func", "(", "r", "*", "Routers", ")", "UnmarshalYAML", "(", "unmarshal", "func", "(", "interface", "{", "}", ")", "error", ")", "error", "{", "routers", ":=", "make", "(", "Routers", ",", "0", ")", "\n", "scopes", ":=", "make", "(", "[", "]", "map", "[", "string", "]", "interface", "{", "}", ",", "0", ")", "\n", "if", "err", ":=", "unmarshal", "(", "&", "scopes", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defaultRouterExist", ":=", "false", "\n", "for", "_", ",", "scopeMap", ":=", "range", "scopes", "{", "for", "scope", ",", "namePrefixes", ":=", "range", "scopeMap", "{", "namePrefixesMap", ",", "ok", ":=", "namePrefixes", ".", "(", "map", "[", "interface", "{", "}", "]", "interface", "{", "}", ")", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "namePrefixes", ")", "\n", "}", "\n\n", "for", "namePrefix", ",", "connector", ":=", "range", "namePrefixesMap", "{", "namePrefixStr", ":=", "namePrefix", ".", "(", "string", ")", "\n", "connectorName", ",", "ok", ":=", "connector", ".", "(", "string", ")", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "namePrefixesMap", ")", "\n", "}", "\n", "router", ",", "err", ":=", "NewRule", "(", "scope", ",", "namePrefixStr", ",", "connectorName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "routers", "=", "append", "(", "routers", ",", "router", ")", "\n", "if", "scope", "==", "DefaultScope", "{", "defaultRouterExist", "=", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "!", "defaultRouterExist", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "sort", ".", "Sort", "(", "routers", ")", "\n", "*", "r", "=", "routers", "\n", "return", "nil", "\n", "}" ]

[ "UnmarshalYAML", "unmarshals", "the", "config", "into", "gocql", "cluster", "config" ]

[ "func", "(", "c", "*", "Config", ")", "FindRouter", "(", "scope", ",", "namePrefix", "string", ")", "*", "Rule", "{", "for", "_", ",", "router", ":=", "range", "c", ".", "Routers", "{", "if", "router", ".", "RouteTo", "(", "scope", ",", "namePrefix", ")", "{", "return", "router", "\n", "}", "\n", "}", "\n\n", "return", "c", ".", "findDefaultRouter", "(", ")", "\n", "}" ]

[ "FindRouter", "finds", "the", "router", "information", "based", "on", "scope", "and", "namePrefix", "." ]

[ "func", "(", "c", "*", "Config", ")", "findDefaultRouter", "(", ")", "*", "Rule", "{", "for", "_", ",", "router", ":=", "range", "c", ".", "Routers", "{", "if", "router", ".", "Scope", "==", "DefaultScope", "{", "return", "router", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "findDefaultRouter", "finds", "the", "default", "router", "information", "." ]

[ "func", "NewRemoveRangeOp", "(", "object", "DomainObject", ")", "*", "RemoveRangeOp", "{", "rop", ":=", "&", "RemoveRangeOp", "{", "conditioner", ":", "conditioner", "{", "object", ":", "object", ",", "conditions", ":", "map", "[", "string", "]", "[", "]", "*", "Condition", "{", "}", ",", "}", ",", "}", "\n", "return", "rop", "\n", "}" ]

[ "NewRemoveRangeOp", "returns", "a", "new", "RangeOp", "instance" ]

[ "func", "(", "r", "*", "RemoveRangeOp", ")", "Eq", "(", "fieldName", "string", ",", "value", "interface", "{", "}", ")", "*", "RemoveRangeOp", "{", "r", ".", "appendOp", "(", "Eq", ",", "fieldName", ",", "value", ")", "\n", "return", "r", "\n", "}" ]

[ "Eq", "is", "used", "to", "express", "an", "equality", "constraint", "for", "a", "remove", "range", "operation" ]

[ "func", "(", "r", "*", "RemoveRangeOp", ")", "Gt", "(", "fieldName", "string", ",", "value", "interface", "{", "}", ")", "*", "RemoveRangeOp", "{", "r", ".", "appendOp", "(", "Gt", ",", "fieldName", ",", "value", ")", "\n", "return", "r", "\n", "}" ]

[ "Gt", "is", "used", "to", "express", "an", "greater", "than", "constraint", "for", "a", "remove", "range", "operation" ]

[ "func", "(", "r", "*", "RemoveRangeOp", ")", "GtOrEq", "(", "fieldName", "string", ",", "value", "interface", "{", "}", ")", "*", "RemoveRangeOp", "{", "r", ".", "appendOp", "(", "GtOrEq", ",", "fieldName", ",", "value", ")", "\n", "return", "r", "\n", "}" ]

[ "GtOrEq", "is", "used", "to", "express", "an", "greater", "than", "or", "equal", "constraint", "for", "a", "remove", "range", "operation" ]

[ "func", "(", "r", "*", "RemoveRangeOp", ")", "Lt", "(", "fieldName", "string", ",", "value", "interface", "{", "}", ")", "*", "RemoveRangeOp", "{", "r", ".", "appendOp", "(", "Lt", ",", "fieldName", ",", "value", ")", "\n", "return", "r", "\n", "}" ]

[ "Lt", "is", "used", "to", "express", "a", "less", "than", "constraint", "for", "a", "remove", "range", "operation" ]

[ "func", "(", "r", "*", "RemoveRangeOp", ")", "LtOrEq", "(", "fieldName", "string", ",", "value", "interface", "{", "}", ")", "*", "RemoveRangeOp", "{", "r", ".", "appendOp", "(", "LtOrEq", ",", "fieldName", ",", "value", ")", "\n", "return", "r", "\n", "}" ]

[ "LtOrEq", "is", "used", "to", "express", "a", "less", "than", "or", "equal", "constraint", "for", "a", "remove", "range", "operation" ]

[ "func", "RawValueAsInterface", "(", "val", "dosarpc", ".", "RawValue", ",", "typ", "dosa", ".", "Type", ")", "interface", "{", "}", "{", "switch", "typ", "{", "case", "dosa", ".", "Blob", ":", "return", "val", ".", "BinaryValue", "\n", "case", "dosa", ".", "TUUID", ":", "if", "len", "(", "val", ".", "BinaryValue", ")", "==", "0", "{", "return", "(", "*", "dosa", ".", "UUID", ")", "(", "nil", ")", "\n", "}", "\n", "uuid", ",", "_", ":=", "dosa", ".", "BytesToUUID", "(", "val", ".", "BinaryValue", ")", "// TODO: should we handle this error?", "\n", "return", "&", "uuid", "\n", "case", "dosa", ".", "String", ":", "return", "val", ".", "StringValue", "\n", "case", "dosa", ".", "Int32", ":", "return", "val", ".", "Int32Value", "\n", "case", "dosa", ".", "Int64", ":", "return", "val", ".", "Int64Value", "\n", "case", "dosa", ".", "Double", ":", "return", "val", ".", "DoubleValue", "\n", "case", "dosa", ".", "Timestamp", ":", "if", "val", ".", "Int64Value", "==", "nil", "{", "return", "(", "*", "time", ".", "Time", ")", "(", "nil", ")", "\n", "}", "\n", "t", ":=", "time", ".", "Unix", "(", "0", ",", "*", "val", ".", "Int64Value", ")", "\n", "return", "&", "t", "\n", "case", "dosa", ".", "Bool", ":", "return", "val", ".", "BoolValue", "\n", "}", "\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "RawValueAsInterface", "converts", "a", "value", "from", "the", "wire", "to", "an", "object", "implementing", "the", "interface", "based", "on", "the", "dosa", "type", ".", "For", "example", "a", "TUUID", "type", "will", "get", "a", "dosa", ".", "UUID", "object" ]

[ "func", "RawValueFromInterface", "(", "i", "interface", "{", "}", ")", "(", "*", "dosarpc", ".", "RawValue", ",", "error", ")", "{", "// TODO: Do we do type compatibility checks here? We should know the schema,", "// but the callers are all well known and should match the types", "switch", "v", ":=", "i", ".", "(", "type", ")", "{", "case", "string", ":", "return", "&", "dosarpc", ".", "RawValue", "{", "StringValue", ":", "&", "v", "}", ",", "nil", "\n", "case", "bool", ":", "return", "&", "dosarpc", ".", "RawValue", "{", "BoolValue", ":", "&", "v", "}", ",", "nil", "\n", "case", "int64", ":", "return", "&", "dosarpc", ".", "RawValue", "{", "Int64Value", ":", "&", "v", "}", ",", "nil", "\n", "case", "int32", ":", "return", "&", "dosarpc", ".", "RawValue", "{", "Int32Value", ":", "&", "v", "}", ",", "nil", "\n", "case", "float64", ":", "return", "&", "dosarpc", ".", "RawValue", "{", "DoubleValue", ":", "&", "v", "}", ",", "nil", "\n", "case", "[", "]", "byte", ":", "// If we set nil to BinaryValue, thrift cannot encode it", "// as it thought we didn't set any field in the union", "if", "v", "==", "nil", "{", "v", "=", "[", "]", "byte", "{", "}", "\n", "}", "\n", "return", "&", "dosarpc", ".", "RawValue", "{", "BinaryValue", ":", "v", "}", ",", "nil", "\n", "case", "time", ".", "Time", ":", "time", ":=", "v", ".", "UnixNano", "(", ")", "\n", "return", "&", "dosarpc", ".", "RawValue", "{", "Int64Value", ":", "&", "time", "}", ",", "nil", "\n", "case", "dosa", ".", "UUID", ":", "bytes", ",", "err", ":=", "v", ".", "Bytes", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "dosarpc", ".", "RawValue", "{", "BinaryValue", ":", "bytes", "}", ",", "nil", "\n", "case", "*", "dosa", ".", "UUID", ":", "if", "v", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "bytes", ",", "err", ":=", "v", ".", "Bytes", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "dosarpc", ".", "RawValue", "{", "BinaryValue", ":", "bytes", "}", ",", "nil", "\n", "case", "*", "string", ":", "if", "v", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "&", "dosarpc", ".", "RawValue", "{", "StringValue", ":", "v", "}", ",", "nil", "\n", "case", "*", "int32", ":", "if", "v", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "&", "dosarpc", ".", "RawValue", "{", "Int32Value", ":", "v", "}", ",", "nil", "\n", "case", "*", "int64", ":", "if", "v", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "&", "dosarpc", ".", "RawValue", "{", "Int64Value", ":", "v", "}", ",", "nil", "\n", "case", "*", "float64", ":", "if", "v", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "&", "dosarpc", ".", "RawValue", "{", "DoubleValue", ":", "v", "}", ",", "nil", "\n", "case", "*", "bool", ":", "if", "v", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "&", "dosarpc", ".", "RawValue", "{", "BoolValue", ":", "v", "}", ",", "nil", "\n", "case", "*", "time", ".", "Time", ":", "if", "v", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "t", ":=", "v", ".", "UnixNano", "(", ")", "\n", "return", "&", "dosarpc", ".", "RawValue", "{", "Int64Value", ":", "&", "t", "}", ",", "nil", "\n", "}", "\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "RawValueFromInterface", "takes", "an", "interface", "introspects", "the", "type", "and", "then", "returns", "a", "RawValue", "object", "that", "represents", "this", ".", "It", "panics", "if", "the", "type", "is", "not", "in", "the", "list", "which", "should", "be", "a", "dosa", "bug" ]

[ "func", "RPCTypeFromClientType", "(", "t", "dosa", ".", "Type", ")", "dosarpc", ".", "ElemType", "{", "switch", "t", "{", "case", "dosa", ".", "Bool", ":", "return", "dosarpc", ".", "ElemTypeBool", "\n", "case", "dosa", ".", "Blob", ":", "return", "dosarpc", ".", "ElemTypeBlob", "\n", "case", "dosa", ".", "String", ":", "return", "dosarpc", ".", "ElemTypeString", "\n", "case", "dosa", ".", "Int32", ":", "return", "dosarpc", ".", "ElemTypeInt32", "\n", "case", "dosa", ".", "Int64", ":", "return", "dosarpc", ".", "ElemTypeInt64", "\n", "case", "dosa", ".", "Double", ":", "return", "dosarpc", ".", "ElemTypeDouble", "\n", "case", "dosa", ".", "Timestamp", ":", "return", "dosarpc", ".", "ElemTypeTimestamp", "\n", "case", "dosa", ".", "TUUID", ":", "return", "dosarpc", ".", "ElemTypeUUID", "\n", "}", "\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "RPCTypeFromClientType", "returns", "the", "RPC", "ElemType", "from", "a", "DOSA", "Type" ]

[ "func", "PrimaryKeyToThrift", "(", "key", "*", "dosa", ".", "PrimaryKey", ")", "*", "dosarpc", ".", "PrimaryKey", "{", "ck", ":=", "make", "(", "[", "]", "*", "dosarpc", ".", "ClusteringKey", ",", "len", "(", "key", ".", "ClusteringKeys", ")", ")", "\n", "for", "ckinx", ",", "clusteringKey", ":=", "range", "key", ".", "ClusteringKeys", "{", "// TODO: The client uses 'descending' but the RPC uses 'ascending'? Fix this insanity!", "ascending", ":=", "!", "clusteringKey", ".", "Descending", "\n", "name", ":=", "clusteringKey", ".", "Name", "\n", "ck", "[", "ckinx", "]", "=", "&", "dosarpc", ".", "ClusteringKey", "{", "Name", ":", "&", "name", ",", "Asc", ":", "&", "ascending", "}", "\n", "}", "\n", "return", "&", "dosarpc", ".", "PrimaryKey", "{", "PartitionKeys", ":", "key", ".", "PartitionKeys", ",", "ClusteringKeys", ":", "ck", "}", "\n", "}" ]

[ "PrimaryKeyToThrift", "converts", "the", "dosa", "primary", "key", "to", "the", "thrift", "primary", "key", "type" ]

[ "func", "ETLStateToThrift", "(", "etl", "dosa", ".", "ETLState", ")", "dosarpc", ".", "ETLState", "{", "switch", "etl", "{", "case", "dosa", ".", "EtlOn", ":", "return", "dosarpc", ".", "ETLStateOn", "\n", "case", "dosa", ".", "EtlOff", ":", "return", "dosarpc", ".", "ETLStateOff", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "etl", ")", ")", "\n", "}", "\n", "}" ]

[ "ETLStateToThrift", "convert", "the", "dosa", "ETLState", "to", "the", "thrift", "ETLState", "enum", "type" ]

[ "func", "EntityDefsToThrift", "(", "eds", "[", "]", "*", "dosa", ".", "EntityDefinition", ")", "[", "]", "*", "dosarpc", ".", "EntityDefinition", "{", "rpcEntityDefs", ":=", "make", "(", "[", "]", "*", "dosarpc", ".", "EntityDefinition", ",", "len", "(", "eds", ")", ")", "\n", "for", "i", ",", "ed", ":=", "range", "eds", "{", "rpcEntityDefs", "[", "i", "]", "=", "entityDefToThrift", "(", "ed", ")", "\n", "}", "\n", "return", "rpcEntityDefs", "\n", "}" ]

[ "EntityDefsToThrift", "coverts", "a", "set", "of", "client", "EntityDefinition", "to", "the", "corresponding", "RPC", "EntityDefinitions" ]

[ "func", "FromThriftToPrimaryKey", "(", "key", "*", "dosarpc", ".", "PrimaryKey", ")", "*", "dosa", ".", "PrimaryKey", "{", "pk", ":=", "key", ".", "PartitionKeys", "\n", "ck", ":=", "make", "(", "[", "]", "*", "dosa", ".", "ClusteringKey", ",", "len", "(", "key", ".", "ClusteringKeys", ")", ")", "\n", "for", "i", ",", "v", ":=", "range", "key", ".", "ClusteringKeys", "{", "ck", "[", "i", "]", "=", "&", "dosa", ".", "ClusteringKey", "{", "Name", ":", "*", "v", ".", "Name", ",", "Descending", ":", "!", "*", "v", ".", "Asc", ",", "}", "\n", "}", "\n\n", "return", "&", "dosa", ".", "PrimaryKey", "{", "PartitionKeys", ":", "pk", ",", "ClusteringKeys", ":", "ck", ",", "}", "\n", "}" ]

[ "FromThriftToPrimaryKey", "converts", "thrift", "primary", "key", "type", "to", "dosa", "primary", "key", "type" ]

[ "func", "FromThriftToEntityDefinition", "(", "ed", "*", "dosarpc", ".", "EntityDefinition", ")", "*", "dosa", ".", "EntityDefinition", "{", "fields", ":=", "make", "(", "[", "]", "*", "dosa", ".", "ColumnDefinition", ",", "len", "(", "ed", ".", "FieldDescs", ")", ")", "\n", "i", ":=", "0", "\n", "for", "k", ",", "v", ":=", "range", "ed", ".", "FieldDescs", "{", "fields", "[", "i", "]", "=", "&", "dosa", ".", "ColumnDefinition", "{", "Name", ":", "k", ",", "Type", ":", "RPCTypeToClientType", "(", "*", "v", ".", "Type", ")", ",", "// TODO Tag", "}", "\n", "i", "++", "\n", "}", "\n\n", "indexes", ":=", "make", "(", "map", "[", "string", "]", "*", "dosa", ".", "IndexDefinition", ")", "\n", "for", "name", ",", "index", ":=", "range", "ed", ".", "Indexes", "{", "indexes", "[", "name", "]", "=", "&", "dosa", ".", "IndexDefinition", "{", "Key", ":", "FromThriftToPrimaryKey", "(", "index", ".", "Key", ")", ",", "}", "\n", "}", "\n\n", "etlState", ":=", "dosa", ".", "EtlOff", "\n", "if", "ed", ".", "Etl", "!=", "nil", "{", "etlState", "=", "fromThriftToETLState", "(", "ed", ".", "Etl", ")", "\n", "}", "\n\n", "return", "&", "dosa", ".", "EntityDefinition", "{", "Name", ":", "*", "ed", ".", "Name", ",", "Columns", ":", "fields", ",", "Key", ":", "FromThriftToPrimaryKey", "(", "ed", ".", "PrimaryKey", ")", ",", "Indexes", ":", "indexes", ",", "ETL", ":", "etlState", ",", "}", "\n", "}" ]

[ "FromThriftToEntityDefinition", "converts", "the", "RPC", "EntityDefinition", "to", "client", "EntityDefinition" ]

[ "func", "getHeaders", "(", "headers", "map", "[", "string", "]", "string", ")", "[", "]", "rpc", ".", "CallOption", "{", "hdrs", ":=", "make", "(", "[", "]", "rpc", ".", "CallOption", ",", "0", ",", "len", "(", "headers", ")", "+", "1", ")", "\n", "hdrs", "=", "append", "(", "hdrs", ",", "rpc", ".", "WithHeader", "(", "_version", ",", "dosa", ".", "VERSION", ")", ")", "\n", "for", "h", ",", "v", ":=", "range", "headers", "{", "hdrs", "=", "append", "(", "hdrs", ",", "rpc", ".", "WithHeader", "(", "h", ",", "v", ")", ")", "\n", "}", "\n", "return", "hdrs", "\n", "}" ]

[ "getHeaders", "converts", "the", "provided", "headers", "into", "rpc", ".", "CallOption", "values", ".", "A", "header", "for", "Version", "is", "also", "added", "." ]

[ "func", "NewRegisteredEntity", "(", "scope", ",", "namePrefix", "string", ",", "table", "*", "Table", ")", "*", "RegisteredEntity", "{", "return", "&", "RegisteredEntity", "{", "table", ":", "table", ",", "schemaRef", ":", "&", "SchemaRef", "{", "Scope", ":", "scope", ",", "NamePrefix", ":", "namePrefix", ",", "EntityName", ":", "table", ".", "Name", ",", "}", ",", "}", "\n", "}" ]

[ "NewRegisteredEntity", "is", "a", "constructor", "for", "creating", "a", "RegisteredEntity" ]

[ "func", "(", "e", "*", "RegisteredEntity", ")", "EntityInfo", "(", ")", "*", "EntityInfo", "{", "return", "&", "EntityInfo", "{", "Ref", ":", "e", ".", "schemaRef", ",", "Def", ":", "&", "e", ".", "table", ".", "EntityDefinition", ",", "TTL", ":", "&", "e", ".", "table", ".", "TTL", ",", "}", "\n", "}" ]

[ "EntityInfo", "is", "a", "helper", "for", "accessing", "the", "registered", "entity", "s", "EntityInfo", "instance", "which", "is", "required", "by", "clients", "to", "call", "connector", "methods", "." ]

[ "func", "(", "e", "*", "RegisteredEntity", ")", "KeyFieldValues", "(", "entity", "DomainObject", ")", "map", "[", "string", "]", "FieldValue", "{", "v", ":=", "reflect", ".", "ValueOf", "(", "entity", ")", ".", "Elem", "(", ")", "\n", "fieldValues", ":=", "make", "(", "map", "[", "string", "]", "FieldValue", ")", "\n\n", "// populate partition key values", "for", "_", ",", "pk", ":=", "range", "e", ".", "table", ".", "Key", ".", "PartitionKeys", "{", "fieldName", ":=", "e", ".", "table", ".", "ColToField", "[", "pk", "]", "\n", "value", ":=", "v", ".", "FieldByName", "(", "fieldName", ")", "\n", "fieldValues", "[", "pk", "]", "=", "value", ".", "Interface", "(", ")", "\n", "}", "\n\n", "// populate clustering key values", "for", "_", ",", "ck", ":=", "range", "e", ".", "table", ".", "Key", ".", "ClusteringKeys", "{", "fieldName", ":=", "e", ".", "table", ".", "ColToField", "[", "ck", ".", "Name", "]", "\n", "value", ":=", "v", ".", "FieldByName", "(", "fieldName", ")", "\n", "if", "!", "value", ".", "IsValid", "(", ")", "{", "// this should never happen", "panic", "(", "\"", "\"", "+", "fieldName", "+", "\"", "\"", "+", "e", ".", "table", ".", "StructName", ")", "\n", "}", "\n", "fieldValues", "[", "ck", ".", "Name", "]", "=", "value", ".", "Interface", "(", ")", "\n", "}", "\n\n", "return", "fieldValues", "\n", "}" ]

[ "KeyFieldValues", "is", "a", "helper", "for", "generating", "a", "map", "of", "field", "values", "to", "be", "used", "in", "a", "query", "." ]

[ "func", "(", "e", "*", "RegisteredEntity", ")", "OnlyFieldValues", "(", "entity", "DomainObject", ",", "fieldNames", "[", "]", "string", ")", "(", "map", "[", "string", "]", "FieldValue", ",", "error", ")", "{", "if", "fieldNames", "==", "nil", "||", "len", "(", "fieldNames", ")", "==", "0", "{", "for", "_", ",", "field", ":=", "range", "e", ".", "table", ".", "ColToField", "{", "fieldNames", "=", "append", "(", "fieldNames", ",", "field", ")", "\n", "}", "\n", "}", "\n", "v", ":=", "reflect", ".", "ValueOf", "(", "entity", ")", ".", "Elem", "(", ")", "\n", "fieldValues", ":=", "make", "(", "map", "[", "string", "]", "FieldValue", ")", "\n\n", "for", "_", ",", "fieldName", ":=", "range", "fieldNames", "{", "columnName", ",", "ok", ":=", "e", ".", "table", ".", "FieldToCol", "[", "fieldName", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "fieldName", ",", "e", ".", "table", ".", "StructName", ")", "\n", "}", "\n", "value", ":=", "v", ".", "FieldByName", "(", "fieldName", ")", "\n", "if", "!", "value", ".", "IsValid", "(", ")", "{", "// this should never happen", "panic", "(", "\"", "\"", "+", "fieldName", "+", "\"", "\"", "+", "e", ".", "table", ".", "StructName", ")", "\n", "}", "\n", "fieldValues", "[", "columnName", "]", "=", "value", ".", "Interface", "(", ")", "\n", "}", "\n", "return", "fieldValues", ",", "nil", "\n", "}" ]

[ "OnlyFieldValues", "is", "a", "helper", "for", "generating", "a", "map", "of", "field", "values", "for", "a", "a", "subset", "of", "fields", ".", "If", "a", "field", "name", "provided", "does", "not", "map", "to", "an", "entity", "field", "an", "error", "will", "be", "returned", "." ]

[ "func", "(", "e", "*", "RegisteredEntity", ")", "ColumnNames", "(", "fieldNames", "[", "]", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "fieldNames", "==", "nil", "||", "len", "(", "fieldNames", ")", "==", "0", "{", "for", "_", ",", "field", ":=", "range", "e", ".", "table", ".", "ColToField", "{", "fieldNames", "=", "append", "(", "fieldNames", ",", "field", ")", "\n", "}", "\n", "}", "\n", "columnNames", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "fieldNames", ")", ")", "\n", "for", "i", ",", "fieldName", ":=", "range", "fieldNames", "{", "columnName", ",", "ok", ":=", "e", ".", "table", ".", "FieldToCol", "[", "fieldName", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "fieldName", ",", "e", ".", "table", ".", "StructName", ")", "\n", "}", "\n", "columnNames", "[", "i", "]", "=", "columnName", "\n", "}", "\n", "return", "columnNames", ",", "nil", "\n", "}" ]

[ "ColumnNames", "translates", "field", "names", "to", "column", "names", "." ]

[ "func", "(", "e", "*", "RegisteredEntity", ")", "SetFieldValues", "(", "entity", "DomainObject", ",", "fieldValues", "map", "[", "string", "]", "FieldValue", ",", "fieldsToRead", "[", "]", "string", ")", "{", "r", ":=", "reflect", ".", "ValueOf", "(", "entity", ")", ".", "Elem", "(", ")", "\n", "if", "fieldsToRead", "==", "nil", "{", "for", "columnName", ":=", "range", "fieldValues", "{", "fieldsToRead", "=", "append", "(", "fieldsToRead", ",", "columnName", ")", "\n", "}", "\n", "}", "\n", "//for columnName, fieldValue := range fieldValues {", "for", "_", ",", "columnName", ":=", "range", "fieldsToRead", "{", "// column name may be different from the entity's field name, so we", "// have to look it up along the way.", "fieldName", ",", "ok", ":=", "e", ".", "table", ".", "ColToField", "[", "columnName", "]", "\n", "if", "!", "ok", "{", "continue", "// we ignore fields that we don't know about", "\n", "}", "\n", "fieldValue", ":=", "fieldValues", "[", "columnName", "]", "\n", "val", ":=", "r", ".", "FieldByName", "(", "fieldName", ")", "\n", "if", "!", "val", ".", "IsValid", "(", ")", "{", "panic", "(", "\"", "\"", "+", "fieldName", "+", "\"", "\"", "+", "e", ".", "table", ".", "StructName", ")", "\n", "}", "\n\n", "var", "fv", "reflect", ".", "Value", "\n", "if", "fieldValue", "!=", "nil", "{", "fv", "=", "reflect", ".", "ValueOf", "(", "fieldValue", ")", "\n", "}", "\n", "if", "!", "fv", ".", "IsValid", "(", ")", "||", "fv", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "&&", "fv", ".", "IsNil", "(", ")", "{", "val", ".", "Set", "(", "reflect", ".", "Zero", "(", "val", ".", "Type", "(", ")", ")", ")", "\n", "continue", "\n", "}", "\n\n", "switch", "val", ".", "Type", "(", ")", "{", "case", "uuidType", ",", "boolType", ",", "int64Type", ",", "stringType", ",", "int32Type", ",", "doubleType", ",", "timestampType", ",", "blobType", ":", "val", ".", "Set", "(", "reflect", ".", "Indirect", "(", "fv", ")", ")", "\n", "case", "nullUUIDType", ",", "nullStringType", ",", "nullInt32Type", ",", "nullInt64Type", ",", "nullDoubleType", ",", "nullBoolType", ",", "nullTimeType", ":", "if", "fv", ".", "CanAddr", "(", ")", "{", "val", ".", "Set", "(", "fv", ".", "Addr", "(", ")", ")", "\n", "}", "else", "{", "val", ".", "Set", "(", "fv", ")", "\n", "}", "\n", "}", "\n\n", "}", "\n", "}" ]

[ "SetFieldValues", "is", "a", "helper", "for", "populating", "a", "DOSA", "entity", "with", "the", "given", "fieldName", "-", ">", "value", "map" ]

[ "func", "NewRegistrar", "(", "scope", ",", "namePrefix", "string", ",", "entities", "...", "DomainObject", ")", "(", "Registrar", ",", "error", ")", "{", "if", "err", ":=", "IsValidNamePrefix", "(", "namePrefix", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "typeIndex", ":=", "make", "(", "map", "[", "reflect", ".", "Type", "]", "*", "RegisteredEntity", ")", "\n\n", "for", "_", ",", "e", ":=", "range", "entities", "{", "table", ",", "err", ":=", "TableFromInstance", "(", "e", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// use entity type as internal lookup key", "typ", ":=", "reflect", ".", "TypeOf", "(", "e", ")", ".", "Elem", "(", ")", "\n\n", "// create instance and index it", "re", ":=", "NewRegisteredEntity", "(", "scope", ",", "namePrefix", ",", "table", ")", "\n", "typeIndex", "[", "typ", "]", "=", "re", "\n", "}", "\n\n", "return", "&", "prefixedRegistrar", "{", "scope", ":", "scope", ",", "namePrefix", ":", "namePrefix", ",", "typeIndex", ":", "typeIndex", ",", "}", ",", "nil", "\n", "}" ]

[ "NewRegistrar", "returns", "a", "new", "Registrar", "for", "the", "scope", "name", "prefix", "and", "entities", "provided", ".", "dosa", ".", "Client", "implementations", "are", "intended", "to", "use", "scope", "and", "prefix", "to", "uniquely", "identify", "where", "entities", "should", "live", "but", "the", "registrar", "itself", "is", "only", "responsible", "for", "basic", "accounting", "of", "entities", "." ]

[ "func", "(", "r", "*", "prefixedRegistrar", ")", "Find", "(", "entity", "DomainObject", ")", "(", "*", "RegisteredEntity", ",", "error", ")", "{", "t", ":=", "reflect", ".", "TypeOf", "(", "entity", ")", ".", "Elem", "(", ")", "\n", "re", ",", "ok", ":=", "r", ".", "typeIndex", "[", "t", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "t", ".", "Name", "(", ")", ")", "\n", "}", "\n", "return", "re", ",", "nil", "\n", "}" ]

[ "Find", "looks", "at", "its", "internal", "index", "to", "find", "a", "registration", "that", "matches", "the", "entity", "instance", "provided", ".", "Return", "an", "error", "when", "not", "found", "." ]

[ "func", "(", "r", "*", "prefixedRegistrar", ")", "FindAll", "(", ")", "[", "]", "*", "RegisteredEntity", "{", "res", ":=", "[", "]", "*", "RegisteredEntity", "{", "}", "\n", "for", "_", ",", "re", ":=", "range", "r", ".", "typeIndex", "{", "res", "=", "append", "(", "res", ",", "re", ")", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "FindAll", "returns", "all", "registered", "entities", "from", "its", "internal", "index", "." ]

[ "func", "NewRedigoClient", "(", "config", "ServerConfig", ",", "scope", "metrics", ".", "Scope", ")", "SimpleRedis", "{", "c", ":=", "&", "simpleRedis", "{", "config", ":", "config", ",", "stats", ":", "metrics", ".", "CheckIfNilStats", "(", "scope", ")", "}", "\n", "c", ".", "pool", "=", "&", "redis", ".", "Pool", "{", "MaxActive", ":", "config", ".", "MaxActive", ",", "MaxIdle", ":", "config", ".", "MaxIdle", ",", "IdleTimeout", ":", "config", ".", "IdleTimeout", ",", "Dial", ":", "func", "(", ")", "(", "redis", ".", "Conn", ",", "error", ")", "{", "c", ",", "err", ":=", "redis", ".", "Dial", "(", "\"", "\"", ",", "c", ".", "getURL", "(", ")", ",", "redis", ".", "DialConnectTimeout", "(", "config", ".", "ConnectTimeout", ")", ",", "redis", ".", "DialReadTimeout", "(", "config", ".", "ReadTimeout", ")", ",", "redis", ".", "DialWriteTimeout", "(", "config", ".", "WriteTimeout", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "c", ",", "err", "\n", "}", ",", "Wait", ":", "false", ",", "}", "\n", "return", "c", "\n", "}" ]

[ "NewRedigoClient", "returns", "a", "redigo", "implementation", "of", "SimpleRedis" ]

[ "func", "(", "c", "*", "simpleRedis", ")", "Get", "(", "key", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "bytes", ",", "err", ":=", "redis", ".", "Bytes", "(", "c", ".", "do", "(", "\"", "\"", ",", "key", ")", ")", "\n", "if", "err", "==", "redis", ".", "ErrNil", "{", "err", "=", "&", "dosa", ".", "ErrNotFound", "{", "}", "\n", "}", "\n", "return", "bytes", ",", "err", "\n", "}" ]

[ "Get", "returns", "an", "error", "if", "the", "key", "is", "not", "found", "in", "cache" ]

[ "func", "(", "c", "*", "simpleRedis", ")", "do", "(", "commandName", "string", ",", "args", "...", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "t", ":=", "c", ".", "stats", ".", "SubScope", "(", "\"", "\"", ")", ".", "SubScope", "(", "\"", "\"", ")", ".", "Timer", "(", "commandName", ")", "\n", "t", ".", "Start", "(", ")", "\n", "defer", "t", ".", "Stop", "(", ")", "\n\n", "conn", ":=", "c", ".", "pool", ".", "Get", "(", ")", "\n", "defer", "func", "(", ")", "{", "_", "=", "conn", ".", "Close", "(", ")", "}", "(", ")", "\n", "return", "conn", ".", "Do", "(", "commandName", ",", "args", "...", ")", "\n", "}" ]

[ "Do", "is", "a", "proxy", "method", "that", "calls", "Redigo", "s", "Do", "method", "and", "returns", "its", "output", ".", "It", "remembers", "to", "close", "connections", "taken", "from", "the", "pool" ]

[ "func", "ToProtoMsgChan", "(", "ch", "chan", "ProtoMessage", ",", "opts", "...", "interface", "{", "}", ")", "func", "(", "ProtoMessage", ")", "{", "timeout", ",", "logger", ":=", "ParseOpts", "(", "opts", "...", ")", "\n\n", "return", "func", "(", "msg", "ProtoMessage", ")", "{", "select", "{", "case", "ch", "<-", "msg", ":", "case", "<-", "time", ".", "After", "(", "timeout", ")", ":", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "ToProtoMsgChan", "allows", "to", "receive", "messages", "through", "channel", "instead", "of", "callback", "." ]

[ "func", "ToProtoMsgErrChan", "(", "ch", "chan", "ProtoMessageErr", ",", "opts", "...", "interface", "{", "}", ")", "func", "(", "ProtoMessageErr", ")", "{", "timeout", ",", "logger", ":=", "ParseOpts", "(", "opts", "...", ")", "\n\n", "return", "func", "(", "msg", "ProtoMessageErr", ")", "{", "select", "{", "case", "ch", "<-", "msg", ":", "case", "<-", "time", ".", "After", "(", "timeout", ")", ":", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "ToProtoMsgErrChan", "allows", "to", "receive", "error", "messages", "through", "channel", "instead", "of", "callback", "." ]

[ "func", "ParseOpts", "(", "opts", "...", "interface", "{", "}", ")", "(", "time", ".", "Duration", ",", "logging", ".", "Logger", ")", "{", "timeout", ":=", "DefaultMsgTimeout", "\n", "var", "logger", "logging", ".", "Logger", "=", "logrus", ".", "DefaultLogger", "(", ")", "\n\n", "for", "_", ",", "opt", ":=", "range", "opts", "{", "switch", "opt", ".", "(", "type", ")", "{", "case", "*", "WithLoggerOpt", ":", "logger", "=", "opt", ".", "(", "*", "WithLoggerOpt", ")", ".", "logger", "\n", "case", "*", "WithTimeoutOpt", ":", "timeout", "=", "opt", ".", "(", "*", "WithTimeoutOpt", ")", ".", "timeout", "\n", "}", "\n", "}", "\n", "return", "timeout", ",", "logger", "\n\n", "}" ]

[ "ParseOpts", "returns", "timeout", "and", "logger", "to", "be", "used", "based", "on", "the", "given", "options", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "Init", "(", ")", "error", "{", "p", ".", "Log", ".", "Debugf", "(", "\"", "\"", ")", "\n\n", "templatePath", ",", "err", ":=", "p", ".", "getPMConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "templatePath", "!=", "\"", "\"", "{", "if", "p", ".", "tReader", ",", "err", "=", "template", ".", "NewTemplateReader", "(", "templatePath", ",", "p", ".", "Log", ")", ";", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n", "templates", ",", "err", ":=", "p", ".", "tReader", ".", "GetAllTemplates", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "tmp", ":=", "range", "templates", "{", "pr", ":=", "p", ".", "NewProcessFromTemplate", "(", "tmp", ")", "\n", "if", "pr", "==", "nil", "{", "continue", "\n", "}", "\n", "if", "tmp", ".", "POptions", "!=", "nil", "&&", "tmp", ".", "POptions", ".", "RunOnStartup", "{", "if", "err", "=", "pr", ".", "Start", "(", ")", ";", "err", "!=", "nil", "{", "p", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "tmp", ".", "Name", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Init", "reads", "plugin", "config", "file", "for", "process", "template", "path", ".", "If", "exists", "plugin", "initializes", "template", "reader", "reads", "all", "existing", "templates", "and", "initializes", "them", ".", "Those", "marked", "as", "run", "on", "startup", "are", "immediately", "started" ]

[ "func", "(", "p", "*", "Plugin", ")", "AttachProcess", "(", "name", "string", ",", "cmd", "string", ",", "pid", "int", ",", "options", "...", "POption", ")", "(", "ProcessInstance", ",", "error", ")", "{", "pr", ",", "err", ":=", "os", ".", "FindProcess", "(", "pid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "pid", ",", "err", ")", "\n", "}", "\n", "attachedPr", ":=", "&", "Process", "{", "log", ":", "p", ".", "Log", ",", "name", ":", "name", ",", "cmd", ":", "cmd", ",", "options", ":", "&", "POptions", "{", "}", ",", "command", ":", "&", "exec", ".", "Cmd", "{", "Process", ":", "pr", "}", ",", "sh", ":", "&", "status", ".", "Reader", "{", "Log", ":", "p", ".", "Log", "}", ",", "cancelChan", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "for", "_", ",", "option", ":=", "range", "options", "{", "option", "(", "attachedPr", ".", "options", ")", "\n", "}", "\n", "p", ".", "processes", "=", "append", "(", "p", ".", "processes", ",", "attachedPr", ")", "\n\n", "attachedPr", ".", "status", ",", "err", "=", "attachedPr", ".", "sh", ".", "ReadStatusFromPID", "(", "attachedPr", ".", "GetPid", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "p", ".", "Log", ".", "Warnf", "(", "\"", "\"", ",", "pid", ",", "err", ")", "\n", "}", "\n\n", "go", "attachedPr", ".", "watch", "(", ")", "\n\n", "if", "attachedPr", ".", "options", ".", "template", "{", "p", ".", "writeAsTemplate", "(", "attachedPr", ")", "\n", "}", "\n\n", "return", "attachedPr", ",", "nil", "\n", "}" ]

[ "AttachProcess", "attaches", "to", "existing", "process", "reads", "its", "status", "and", "starts", "process", "status", "watcher" ]

[ "func", "(", "p", "*", "Plugin", ")", "NewProcess", "(", "name", ",", "cmd", "string", ",", "options", "...", "POption", ")", "ProcessInstance", "{", "newPr", ":=", "&", "Process", "{", "log", ":", "p", ".", "Log", ",", "name", ":", "name", ",", "cmd", ":", "cmd", ",", "options", ":", "&", "POptions", "{", "}", ",", "sh", ":", "&", "status", ".", "Reader", "{", "Log", ":", "p", ".", "Log", "}", ",", "status", ":", "&", "status", ".", "File", "{", "State", ":", "status", ".", "Initial", ",", "}", ",", "cancelChan", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "for", "_", ",", "option", ":=", "range", "options", "{", "option", "(", "newPr", ".", "options", ")", "\n", "}", "\n", "p", ".", "processes", "=", "append", "(", "p", ".", "processes", ",", "newPr", ")", "\n\n", "if", "newPr", ".", "options", ".", "template", "{", "p", ".", "writeAsTemplate", "(", "newPr", ")", "\n", "}", "\n\n", "return", "newPr", "\n", "}" ]

[ "NewProcess", "creates", "a", "new", "process", "and", "saves", "its", "template", "if", "required" ]

[ "func", "(", "p", "*", "Plugin", ")", "NewProcessFromTemplate", "(", "tmp", "*", "process", ".", "Template", ")", "ProcessInstance", "{", "newTmpPr", ",", "err", ":=", "p", ".", "templateToProcess", "(", "tmp", ")", "\n", "if", "err", "!=", "nil", "{", "p", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "p", ".", "processes", "=", "append", "(", "p", ".", "processes", ",", "newTmpPr", ")", "\n\n", "go", "newTmpPr", ".", "watch", "(", ")", "\n\n", "return", "newTmpPr", "\n", "}" ]

[ "NewProcessFromTemplate", "creates", "a", "new", "process", "from", "template", "file" ]

[ "func", "(", "p", "*", "Plugin", ")", "GetProcessByName", "(", "name", "string", ")", "ProcessInstance", "{", "for", "_", ",", "pr", ":=", "range", "p", ".", "processes", "{", "if", "pr", ".", "name", "==", "name", "{", "return", "pr", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetProcessByName", "uses", "process", "name", "to", "find", "a", "desired", "instance" ]

[ "func", "(", "p", "*", "Plugin", ")", "GetProcessByPID", "(", "pid", "int", ")", "ProcessInstance", "{", "for", "_", ",", "pr", ":=", "range", "p", ".", "processes", "{", "if", "pr", ".", "status", ".", "Pid", "==", "pid", "{", "return", "pr", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetProcessByPID", "uses", "process", "ID", "to", "find", "a", "desired", "instance" ]

[ "func", "(", "p", "*", "Plugin", ")", "GetAllProcesses", "(", ")", "[", "]", "ProcessInstance", "{", "var", "processes", "[", "]", "ProcessInstance", "\n", "for", "_", ",", "pr", ":=", "range", "p", ".", "processes", "{", "processes", "=", "append", "(", "processes", ",", "pr", ")", "\n", "}", "\n", "return", "processes", "\n", "}" ]

[ "GetAllProcesses", "returns", "all", "processes", "known", "to", "plugin" ]

[ "func", "(", "p", "*", "Plugin", ")", "Delete", "(", "name", "string", ")", "error", "{", "var", "updated", "[", "]", "*", "Process", "\n", "for", "_", ",", "pr", ":=", "range", "p", ".", "processes", "{", "if", "pr", ".", "name", "==", "name", "{", "if", "err", ":=", "pr", ".", "deleteProcess", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "{", "updated", "=", "append", "(", "updated", ",", "pr", ")", "\n", "}", "\n", "}", "\n\n", "p", ".", "processes", "=", "updated", "\n\n", "return", "nil", "\n", "}" ]

[ "Delete", "releases", "the", "process", "resources", "and", "removes", "it", "from", "the", "plugin", "cache" ]

[ "func", "(", "p", "*", "Plugin", ")", "GetTemplate", "(", "name", "string", ")", "(", "*", "process", ".", "Template", ",", "error", ")", "{", "if", "p", ".", "tReader", "==", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "templates", ",", "err", ":=", "p", ".", "tReader", ".", "GetAllTemplates", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "tmp", ":=", "range", "templates", "{", "if", "tmp", ".", "Name", "==", "name", "{", "return", "tmp", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "GetTemplate", "returns", "template", "with", "given", "name" ]

[ "func", "(", "p", "*", "Plugin", ")", "GetAllTemplates", "(", ")", "(", "[", "]", "*", "process", ".", "Template", ",", "error", ")", "{", "if", "p", ".", "tReader", "==", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "p", ".", "tReader", ".", "GetAllTemplates", "(", ")", "\n", "}" ]

[ "GetAllTemplates", "returns", "all", "templates" ]

[ "func", "(", "p", "*", "Plugin", ")", "getPMConfig", "(", ")", "(", "path", "string", ",", "err", "error", ")", "{", "var", "pmConfig", "Config", "\n", "found", ",", "err", ":=", "p", ".", "Cfg", ".", "LoadValue", "(", "&", "pmConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "path", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "found", "{", "return", "pmConfig", ".", "TemplatePath", ",", "nil", "\n", "}", "\n", "return", "path", ",", "nil", "\n", "}" ]

[ "Reads", "plugin", "config", "file" ]

[ "func", "(", "p", "*", "Plugin", ")", "writeAsTemplate", "(", "pr", "*", "Process", ")", "{", "tmp", ",", "err", ":=", "p", ".", "processToTemplate", "(", "pr", ")", "\n", "if", "err", "!=", "nil", "{", "p", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "if", "p", ".", "tReader", "==", "nil", "{", "p", ".", "Log", ".", "Warnf", "(", "\"", "\"", ",", "pr", ".", "name", ")", "\n", "return", "\n", "}", "\n", "if", "err", "=", "p", ".", "tReader", ".", "WriteTemplate", "(", "tmp", ",", "template", ".", "DefaultMode", ")", ";", "err", "!=", "nil", "{", "p", ".", "Log", ".", "Warnf", "(", "\"", "\"", ",", "tmp", ".", "Name", ",", "err", ")", "\n", "return", "\n", "}", "\n", "}" ]

[ "Writes", "process", "as", "template", "to", "the", "filesystem", ".", "Errors", "are", "logged", "but", "not", "returned" ]

[ "func", "(", "p", "*", "Plugin", ")", "processToTemplate", "(", "pr", "*", "Process", ")", "(", "*", "process", ".", "Template", ",", "error", ")", "{", "if", "pr", ".", "name", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "pr", ".", "cmd", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "pOptions", ":=", "&", "process", ".", "TemplatePOptions", "{", "Args", ":", "pr", ".", "options", ".", "args", ",", "Restart", ":", "pr", ".", "options", ".", "restart", ",", "OutWriter", ":", "func", "(", "w", "io", ".", "Writer", ")", "bool", "{", "return", "w", "!=", "nil", "\n", "}", "(", "pr", ".", "options", ".", "outWriter", ")", ",", "ErrWriter", ":", "func", "(", "w", "io", ".", "Writer", ")", "bool", "{", "return", "w", "!=", "nil", "\n", "}", "(", "pr", ".", "options", ".", "errWriter", ")", ",", "Detach", ":", "pr", ".", "options", ".", "detach", ",", "RunOnStartup", ":", "pr", ".", "options", ".", "runOnStartup", ",", "Notify", ":", "func", "(", "notifyChan", "chan", "status", ".", "ProcessStatus", ")", "bool", "{", "if", "notifyChan", "==", "nil", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}", "(", "pr", ".", "options", ".", "notifyChan", ")", ",", "AutoTerminate", ":", "pr", ".", "options", ".", "autoTerm", ",", "}", "\n\n", "return", "&", "process", ".", "Template", "{", "Name", ":", "pr", ".", "name", ",", "Cmd", ":", "pr", ".", "cmd", ",", "POptions", ":", "pOptions", ",", "}", ",", "nil", "\n", "}" ]

[ "Create", "a", "template", "object", "from", "process", ".", "A", "name", "and", "a", "command", "are", "mandatory" ]

[ "func", "(", "p", "*", "Plugin", ")", "templateToProcess", "(", "tmp", "*", "process", ".", "Template", ")", "(", "*", "Process", ",", "error", ")", "{", "if", "tmp", ".", "Name", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "tmp", ".", "Cmd", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "pOptions", ":=", "&", "POptions", "{", "}", "\n", "if", "tmp", ".", "POptions", "!=", "nil", "{", "pOptions", ".", "args", "=", "tmp", ".", "POptions", ".", "Args", "\n", "pOptions", ".", "outWriter", "=", "func", "(", "isSet", "bool", ")", "io", ".", "Writer", "{", "if", "isSet", "{", "return", "os", ".", "Stdout", "\n", "}", "\n", "return", "nil", "\n", "}", "(", "tmp", ".", "POptions", ".", "OutWriter", ")", "\n", "pOptions", ".", "errWriter", "=", "func", "(", "isSet", "bool", ")", "io", ".", "Writer", "{", "if", "isSet", "{", "return", "os", ".", "Stderr", "\n", "}", "\n", "return", "nil", "\n", "}", "(", "tmp", ".", "POptions", ".", "ErrWriter", ")", "\n", "pOptions", ".", "detach", "=", "tmp", ".", "POptions", ".", "Detach", "\n", "pOptions", ".", "restart", "=", "tmp", ".", "POptions", ".", "Restart", "\n", "pOptions", ".", "runOnStartup", "=", "tmp", ".", "POptions", ".", "RunOnStartup", "\n", "pOptions", ".", "notifyChan", "=", "func", "(", "notify", "bool", ")", "chan", "status", ".", "ProcessStatus", "{", "if", "notify", "{", "return", "make", "(", "chan", "status", ".", "ProcessStatus", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "(", "tmp", ".", "POptions", ".", "Notify", ")", "\n", "pOptions", ".", "autoTerm", "=", "tmp", ".", "POptions", ".", "AutoTerminate", "\n", "}", "\n\n", "return", "&", "Process", "{", "log", ":", "p", ".", "Log", ",", "name", ":", "tmp", ".", "Name", ",", "cmd", ":", "tmp", ".", "Cmd", ",", "options", ":", "pOptions", ",", "sh", ":", "&", "status", ".", "Reader", "{", "Log", ":", "p", ".", "Log", "}", ",", "status", ":", "&", "status", ".", "File", "{", "State", ":", "status", ".", "Initial", ",", "}", ",", "cancelChan", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "Create", "a", "process", "object", "from", "template", ".", "A", "name", "and", "a", "command", "are", "mandatory" ]

[ "func", "(", "p", "*", "Plugin", ")", "OnConnect", "(", "callback", "func", "(", ")", "error", ")", "{", "if", "err", ":=", "callback", "(", ")", ";", "err", "!=", "nil", "{", "p", ".", "Log", ".", "Error", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "OnConnect", "executes", "callback", "from", "datasync" ]

[ "func", "(", "p", "*", "Plugin", ")", "Init", "(", ")", "(", "err", "error", ")", "{", "if", "p", ".", "Config", "==", "nil", "{", "p", ".", "Config", ",", "err", "=", "p", ".", "getConfig", "(", ")", "\n", "if", "err", "!=", "nil", "||", "p", ".", "disabled", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "p", ".", "boltClient", ",", "err", "=", "NewClient", "(", "p", ".", "Config", ")", "\n", "if", "err", "!=", "nil", "{", "p", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "p", ".", "protoWrapper", "=", "kvproto", ".", "NewProtoWrapper", "(", "p", ".", "boltClient", ",", "&", "keyval", ".", "SerializerJSON", "{", "}", ")", "\n\n", "p", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "p", ".", "Config", ".", "DbPath", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Init", "initializes", "Bolt", "plugin", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "Close", "(", ")", "error", "{", "if", "p", ".", "boltClient", "!=", "nil", "{", "return", "p", ".", "boltClient", ".", "Close", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Close", "closes", "the", "Bolt", "client", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "NewBroker", "(", "keyPrefix", "string", ")", "keyval", ".", "ProtoBroker", "{", "return", "p", ".", "protoWrapper", ".", "NewBroker", "(", "keyPrefix", ")", "\n", "}" ]

[ "NewBroker", "creates", "new", "instance", "of", "prefixed", "broker", "that", "provides", "API", "with", "arguments", "of", "type", "proto", ".", "Message", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "NewWatcher", "(", "keyPrefix", "string", ")", "keyval", ".", "ProtoWatcher", "{", "return", "p", ".", "protoWrapper", ".", "NewWatcher", "(", "keyPrefix", ")", "\n", "}" ]

[ "NewWatcher", "creates", "new", "instance", "of", "prefixed", "broker", "that", "provides", "API", "with", "arguments", "of", "type", "proto", ".", "Message", "." ]

[ "func", "processArgs", "(", ")", "(", "cfg", "*", "etcd", ".", "ClientConfig", ",", "op", "int", ",", "data", "[", "]", "string", ",", "err", "error", ")", "{", "var", "task", "[", "]", "string", "\n\n", "// default args", "fileConfig", ":=", "&", "etcd", ".", "Config", "{", "}", "\n", "op", "=", "Put", "\n\n", "if", "len", "(", "os", ".", "Args", ")", ">", "2", "{", "if", "os", ".", "Args", "[", "1", "]", "==", "\"", "\"", "{", "err", "=", "config", ".", "ParseConfigFromYamlFile", "(", "os", ".", "Args", "[", "2", "]", ",", "fileConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "cfg", ",", "err", "=", "etcd", ".", "ConfigToClient", "(", "fileConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "task", "=", "os", ".", "Args", "[", "3", ":", "]", "\n", "}", "else", "{", "task", "=", "os", ".", "Args", "[", "1", ":", "]", "\n", "}", "\n", "}", "else", "{", "return", "cfg", ",", "0", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "task", ")", "<", "2", "||", "(", "task", "[", "0", "]", "==", "\"", "\"", "&&", "len", "(", "task", ")", "<", "4", ")", "{", "return", "cfg", ",", "0", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "task", "[", "0", "]", "==", "\"", "\"", "{", "op", "=", "Delete", "\n", "}", "else", "if", "task", "[", "0", "]", "==", "\"", "\"", "{", "op", "=", "PutTxn", "\n", "}", "\n\n", "return", "cfg", ",", "op", ",", "task", "[", "1", ":", "]", ",", "nil", "\n", "}" ]

[ "processArgs", "processes", "input", "arguments", "." ]

[ "func", "(", "db", "*", "BytesConnectionRedis", ")", "Close", "(", ")", "error", "{", "if", "db", ".", "closed", "{", "db", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "db", ".", "Debug", "(", "\"", "\"", ")", "\n", "db", ".", "closed", "=", "true", "\n", "safeclose", ".", "Close", "(", "db", ".", "closeCh", ")", "\n", "if", "db", ".", "client", "!=", "nil", "{", "err", ":=", "safeclose", ".", "Close", "(", "db", ".", "client", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Close", "closes", "the", "connection", "to", "redis", "." ]

[ "func", "(", "db", "*", "BytesConnectionRedis", ")", "GetValue", "(", "key", "string", ")", "(", "data", "[", "]", "byte", ",", "found", "bool", ",", "revision", "int64", ",", "err", "error", ")", "{", "if", "db", ".", "closed", "{", "return", "nil", ",", "false", ",", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "key", ")", "\n", "}", "\n", "db", ".", "Debugf", "(", "\"", "\"", ",", "key", ")", "\n\n", "statusCmd", ":=", "db", ".", "client", ".", "Get", "(", "key", ")", "\n", "data", ",", "err", "=", "statusCmd", ".", "Bytes", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "GoRedisNil", "{", "return", "data", ",", "false", ",", "0", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "false", ",", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "key", ",", "err", ")", "\n", "}", "\n", "return", "data", ",", "true", ",", "0", ",", "nil", "\n", "}" ]

[ "GetValue", "retrieves", "the", "value", "of", "the", "key", "from", "Redis", "." ]

[ "func", "(", "db", "*", "BytesConnectionRedis", ")", "Delete", "(", "key", "string", ",", "opts", "...", "datasync", ".", "DelOption", ")", "(", "found", "bool", ",", "err", "error", ")", "{", "if", "db", ".", "closed", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "key", ")", "\n", "}", "\n", "db", ".", "Debugf", "(", "\"", "\"", ",", "key", ")", "\n\n", "keysToDelete", ":=", "[", "]", "string", "{", "}", "\n\n", "var", "keyIsPrefix", "bool", "\n", "for", "_", ",", "o", ":=", "range", "opts", "{", "if", "_", ",", "ok", ":=", "o", ".", "(", "*", "datasync", ".", "WithPrefixOpt", ")", ";", "ok", "{", "keyIsPrefix", "=", "true", "\n", "}", "\n", "}", "\n", "if", "keyIsPrefix", "{", "iterator", ",", "err", ":=", "db", ".", "ListKeys", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "for", "{", "k", ",", "_", ",", "last", ":=", "iterator", ".", "GetNext", "(", ")", "\n", "if", "last", "{", "break", "\n", "}", "\n", "keysToDelete", "=", "append", "(", "keysToDelete", ",", "k", ")", "\n", "}", "\n", "if", "len", "(", "keysToDelete", ")", "==", "0", "{", "return", "false", ",", "nil", "\n", "}", "\n", "db", ".", "Debugf", "(", "\"", "\"", ",", "key", ",", "keysToDelete", ")", "\n", "}", "else", "{", "keysToDelete", "=", "append", "(", "keysToDelete", ",", "key", ")", "\n", "}", "\n\n", "intCmd", ":=", "db", ".", "client", ".", "Del", "(", "keysToDelete", "...", ")", "\n", "if", "intCmd", ".", "Err", "(", ")", "!=", "nil", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "key", ",", "intCmd", ".", "Err", "(", ")", ")", "\n", "}", "\n", "return", "(", "intCmd", ".", "Val", "(", ")", "!=", "0", ")", ",", "nil", "\n", "}" ]

[ "Delete", "deletes", "all", "the", "keys", "that", "start", "with", "the", "given", "match", "string", "." ]

[ "func", "(", "pdb", "*", "BytesBrokerWatcherRedis", ")", "NewTxn", "(", ")", "keyval", ".", "BytesTxn", "{", "if", "pdb", ".", "delegate", ".", "closed", "{", "pdb", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "pdb", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "return", "&", "Txn", "{", "db", ":", "pdb", ".", "delegate", ",", "ops", ":", "[", "]", "op", "{", "}", ",", "addPrefix", ":", "pdb", ".", "addPrefix", "}", "\n", "}" ]

[ "NewTxn", "creates", "new", "transaction", ".", "Prefix", "will", "be", "prepended", "to", "the", "key", "argument", "." ]

[ "func", "(", "pdb", "*", "BytesBrokerWatcherRedis", ")", "Put", "(", "key", "string", ",", "data", "[", "]", "byte", ",", "opts", "...", "datasync", ".", "PutOption", ")", "error", "{", "if", "pdb", ".", "delegate", ".", "closed", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "key", ")", "\n", "}", "\n", "pdb", ".", "Debugf", "(", "\"", "\"", ",", "key", ")", "\n\n", "return", "pdb", ".", "delegate", ".", "Put", "(", "pdb", ".", "addPrefix", "(", "key", ")", ",", "data", ",", "opts", "...", ")", "\n", "}" ]

[ "Put", "calls", "Put", "function", "of", "BytesConnectionRedis", ".", "Prefix", "will", "be", "prepended", "to", "the", "key", "argument", "." ]

[ "func", "(", "pdb", "*", "BytesBrokerWatcherRedis", ")", "GetValue", "(", "key", "string", ")", "(", "data", "[", "]", "byte", ",", "found", "bool", ",", "revision", "int64", ",", "err", "error", ")", "{", "if", "pdb", ".", "delegate", ".", "closed", "{", "return", "nil", ",", "false", ",", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "key", ")", "\n", "}", "\n", "pdb", ".", "Debugf", "(", "\"", "\"", ",", "key", ")", "\n\n", "return", "pdb", ".", "delegate", ".", "GetValue", "(", "pdb", ".", "addPrefix", "(", "key", ")", ")", "\n", "}" ]

[ "GetValue", "calls", "GetValue", "function", "of", "BytesConnectionRedis", ".", "Prefix", "will", "be", "prepended", "to", "the", "key", "argument", "when", "searching", "." ]

[ "func", "(", "pdb", "*", "BytesBrokerWatcherRedis", ")", "Delete", "(", "match", "string", ",", "opts", "...", "datasync", ".", "DelOption", ")", "(", "found", "bool", ",", "err", "error", ")", "{", "if", "pdb", ".", "delegate", ".", "closed", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "match", ")", "\n", "}", "\n", "pdb", ".", "Debugf", "(", "\"", "\"", ",", "match", ")", "\n\n", "return", "pdb", ".", "delegate", ".", "Delete", "(", "pdb", ".", "addPrefix", "(", "match", ")", ",", "opts", "...", ")", "\n", "}" ]

[ "Delete", "calls", "Delete", "function", "of", "BytesConnectionRedis", ".", "Prefix", "will", "be", "prepended", "to", "key", "argument", "when", "searching", "." ]

[ "func", "(", "p", "*", "Plugin", ")", "Init", "(", ")", "error", "{", "p", ".", "registrations", "=", "make", "(", "map", "[", "string", "]", "*", "registration", ")", "\n", "return", "nil", "\n", "}" ]

[ "Init", "initializes", "variables", "." ]

[ "func", "(", "plugin", "*", "ExamplePlugin", ")", "AfterInit", "(", ")", "(", "err", "error", ")", "{", "db", ":=", "plugin", ".", "DB", ".", "NewBroker", "(", "keyval", ".", "Root", ")", "\n", "db", ".", "ListKeys", "(", "keyval", ".", "Root", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "AfterInit", "is", "meant", "to", "use", "DB", "if", "needed" ]

[ "func", "ToBytesMsgChan", "(", "ch", "chan", "*", "client", ".", "ConsumerMessage", ",", "opts", "...", "interface", "{", "}", ")", "func", "(", "*", "client", ".", "ConsumerMessage", ")", "{", "timeout", ",", "logger", ":=", "messaging", ".", "ParseOpts", "(", "opts", "...", ")", "\n\n", "return", "func", "(", "msg", "*", "client", ".", "ConsumerMessage", ")", "{", "select", "{", "case", "ch", "<-", "msg", ":", "case", "<-", "time", ".", "After", "(", "timeout", ")", ":", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "ToBytesMsgChan", "allows", "to", "receive", "ConsumerMessage", "through", "channel", ".", "This", "function", "can", "be", "used", "as", "an", "argument", "for", "ConsumeTopic", "call", "." ]

[ "func", "ToBytesProducerChan", "(", "ch", "chan", "*", "client", ".", "ProducerMessage", ",", "opts", "...", "interface", "{", "}", ")", "func", "(", "*", "client", ".", "ProducerMessage", ")", "{", "timeout", ",", "logger", ":=", "messaging", ".", "ParseOpts", "(", "opts", "...", ")", "\n\n", "return", "func", "(", "msg", "*", "client", ".", "ProducerMessage", ")", "{", "select", "{", "case", "ch", "<-", "msg", ":", "case", "<-", "time", ".", "After", "(", "timeout", ")", ":", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "ToBytesProducerChan", "allows", "to", "receive", "ProducerMessage", "through", "channel", ".", "This", "function", "can", "be", "used", "as", "an", "argument", "for", "methods", "publishing", "using", "async", "API", "." ]

[ "func", "ToBytesProducerErrChan", "(", "ch", "chan", "*", "client", ".", "ProducerError", ",", "opts", "...", "interface", "{", "}", ")", "func", "(", "*", "client", ".", "ProducerError", ")", "{", "timeout", ",", "logger", ":=", "messaging", ".", "ParseOpts", "(", "opts", "...", ")", "\n\n", "return", "func", "(", "msg", "*", "client", ".", "ProducerError", ")", "{", "select", "{", "case", "ch", "<-", "msg", ":", "case", "<-", "time", ".", "After", "(", "timeout", ")", ":", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "ToBytesProducerErrChan", "allows", "to", "receive", "ProducerMessage", "through", "channel", ".", "This", "function", "can", "be", "used", "as", "an", "argument", "for", "methods", "publishing", "using", "async", "API", "." ]

[ "func", "main", "(", ")", "{", "// Read args", "args", ":=", "os", ".", "Args", "\n", "if", "len", "(", "args", ")", "!=", "3", "{", "usage", "(", ")", "\n", "return", "\n", "}", "\n\n", "pass", ":=", "args", "[", "1", "]", "\n", "cost", ",", "err", ":=", "strconv", ".", "Atoi", "(", "args", "[", "2", "]", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "DefaultLogger", "(", ")", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n", "if", "cost", "<", "4", "||", "cost", ">", "31", "{", "logrus", ".", "DefaultLogger", "(", ")", ".", "Errorf", "(", "\"", "\"", ",", "cost", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n", "hash", ",", "err", ":=", "bcrypt", ".", "GenerateFromPassword", "(", "[", "]", "byte", "(", "pass", ")", ",", "cost", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "DefaultLogger", "(", ")", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n\n", "logrus", ".", "DefaultLogger", "(", ")", ".", "Print", "(", "string", "(", "hash", ")", ")", "\n", "}" ]

[ "A", "simple", "utility", "to", "help", "with", "password", "hashing", ".", "Hashed", "password", "can", "be", "stored", "as", "user", "password", "in", "config", "file", ".", "Always", "provide", "two", "parameters", ";", "password", "and", "cost", "." ]

[ "func", "ToChan", "(", "respCh", "chan", "BytesWatchResp", ",", "opts", "...", "interface", "{", "}", ")", "func", "(", "dto", "BytesWatchResp", ")", "{", "return", "func", "(", "dto", "BytesWatchResp", ")", "{", "select", "{", "case", "respCh", "<-", "dto", ":", "// success", "case", "<-", "time", ".", "After", "(", "datasync", ".", "DefaultNotifTimeout", ")", ":", "logging", ".", "DefaultLogger", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "ToChan", "creates", "a", "callback", "that", "can", "be", "passed", "to", "the", "Watch", "function", "in", "order", "to", "receive", "notifications", "through", "a", "channel", ".", "If", "the", "notification", "cannot", "be", "delivered", "until", "timeout", "it", "is", "dropped", "." ]

[ "func", "sendMessage", "(", "producer", "*", "client", ".", "AsyncProducer", ",", "msg", "utils", ".", "Message", ")", "error", "{", "var", "(", "msgKey", "[", "]", "byte", "\n", "msgMeta", "[", "]", "byte", "\n", "msgValue", "[", "]", "byte", "\n", ")", "\n\n", "// init message", "if", "msg", ".", "Key", "!=", "\"", "\"", "{", "msgKey", "=", "[", "]", "byte", "(", "msg", ".", "Key", ")", "\n", "}", "\n", "if", "msg", ".", "Metadata", "!=", "\"", "\"", "{", "msgMeta", "=", "[", "]", "byte", "(", "msg", ".", "Metadata", ")", "\n", "}", "\n", "msgValue", "=", "[", "]", "byte", "(", "msg", ".", "Text", ")", "\n\n", "// send message", "producer", ".", "SendMsgByte", "(", "msg", ".", "Topic", ",", "msgKey", ",", "msgValue", ",", "msgMeta", ")", "\n\n", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "sendMessage", "demonstrates", "AsyncProducer", ".", "SendMsgByte", "API", "to", "publish", "a", "single", "message", "to", "a", "Kafka", "topic", "." ]

[ "func", "NewResyncEventDB", "(", "ctx", "context", ".", "Context", ",", "its", "map", "[", "string", "]", "datasync", ".", "KeyValIterator", ")", "*", "ResyncEventDB", "{", "return", "&", "ResyncEventDB", "{", "ctx", ":", "ctx", ",", "its", ":", "its", ",", "DoneChannel", ":", "&", "DoneChannel", "{", "make", "(", "chan", "error", ",", "1", ")", "}", ",", "}", "\n", "}" ]

[ "NewResyncEventDB", "creates", "a", "new", "instance", "of", "ResyncEventDB", "using", "the", "given", "map", "of", "iterators", "." ]

[ "func", "(", "ev", "*", "ChangeResp", ")", "GetValue", "(", "val", "proto", ".", "Message", ")", "(", "err", "error", ")", "{", "return", "ev", ".", "CurrVal", ".", "GetValue", "(", "val", ")", "\n", "}" ]

[ "GetValue", "-", "see", "the", "comments", "in", "the", "interface", "datasync", ".", "ChangeEvent" ]

[ "func", "(", "f1", "*", "File", ")", "CompareTo", "(", "f2", "*", "File", ")", "(", "changed", ",", "removed", "[", "]", "*", "FileDataEntry", ")", "{", "if", "f1", ".", "Path", "!=", "f2", ".", "Path", "{", "return", "f1", ".", "Data", ",", "f2", ".", "Data", "\n", "}", "\n", "for", "_", ",", "f2Data", ":=", "range", "f2", ".", "Data", "{", "var", "found", "bool", "\n", "for", "_", ",", "f1Data", ":=", "range", "f1", ".", "Data", "{", "if", "f1Data", ".", "Key", "==", "f2Data", ".", "Key", "{", "found", "=", "true", "\n", "if", "!", "bytes", ".", "Equal", "(", "f1Data", ".", "Value", ",", "f2Data", ".", "Value", ")", "{", "changed", "=", "append", "(", "changed", ",", "f1Data", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "removed", "=", "append", "(", "removed", ",", "f2Data", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "f1Data", ":=", "range", "f1", ".", "Data", "{", "var", "found", "bool", "\n", "for", "_", ",", "f2Data", ":=", "range", "f2", ".", "Data", "{", "if", "f1Data", ".", "Key", "==", "f2Data", ".", "Key", "{", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "changed", "=", "append", "(", "changed", ",", "f1Data", ")", "\n", "}", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "CompareTo", "compares", "two", "files", "-", "new", "modified", "and", "deleted", "entries", ".", "Result", "is", "against", "the", "parameter", "." ]

[ "func", "(", "s", "*", "DataMsgServiceServer", ")", "DataChanges", "(", "stream", "msg", ".", "DataMsgService_DataChangesServer", ")", "error", "{", "for", "{", "chng", ",", "err", ":=", "stream", ".", "Recv", "(", ")", "\n\n", "if", "err", "==", "io", ".", "EOF", "{", "return", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "_", ",", "sub", ":=", "range", "s", ".", "adapter", ".", "base", ".", "Subscriptions", "(", ")", "{", "for", "_", ",", "keyPrefix", ":=", "range", "sub", ".", "KeyPrefixes", "{", "if", "strings", ".", "HasPrefix", "(", "chng", ".", "Key", ",", "keyPrefix", ")", "{", "sub", ".", "ChangeChan", "<-", "msg", ".", "NewChangeWatchResp", "(", "context", ".", "Background", "(", ")", ",", "chng", ",", "func", "(", "err2", "error", ")", "{", "err", "=", "stream", ".", "Send", "(", "&", "msg", ".", "DataChangeReply", "{", "Key", ":", "chng", ".", "Key", ",", "OperationType", ":", "chng", ".", "OperationType", ",", "Result", ":", "0", "/*TODO VPP Result*/", "}", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "DefaultLogger", "(", ")", ".", "Error", "(", "err", ")", "//Not able to propagate it somewhere else", "\n", "}", "\n", "}", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "DataChanges", "propagates", "the", "events", "in", "the", "stream", "to", "go", "channels", "of", "registered", "plugins", "." ]

[ "func", "(", "s", "*", "DataMsgServiceServer", ")", "DataResyncs", "(", "ctx", "context", ".", "Context", ",", "req", "*", "msg", ".", "DataResyncRequests", ")", "(", "*", "msg", ".", "DataResyncReplies", ",", "error", ")", "{", "resyncs", ":=", "req", ".", "GetDataResyncs", "(", ")", "\n", "if", "resyncs", "!=", "nil", "{", "//TODO propagate event like in Kafka transport", "/*localtxn := syncbase.NewLocalBytesTxn(s.adapter.localtransp.PropagateBytesResync)\n\t\tif len(resyncs) == 0 {\n\t\t\tlog.Debug(\"received empty resync => DELETE ALL\")\n\t\t}\n\t\tfor _, chReq := range resyncs {\n\t\t\t//TODO chReq.ContentType\n\t\t\tlocaltxn.Put(chReq.Key, chReq.Content)\n\t\t}\n\t\terr := localtxn.Commit()*/", "var", "err", "error", "\n", "if", "err", "!=", "nil", "{", "return", "&", "msg", ".", "DataResyncReplies", "{", "MsgId", ":", "replySeq", "(", ")", ",", "Error", ":", "&", "msg", ".", "Error", "{", "Message", ":", "err", ".", "Error", "(", ")", "}", "/*TODO all other fields*/", "}", ",", "err", "\n", "}", "\n\n", "return", "&", "msg", ".", "DataResyncReplies", "{", "MsgId", ":", "replySeq", "(", ")", "/*TODO all other fields*/", "}", ",", "nil", "\n", "}", "\n\n", "err", ":=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "return", "&", "msg", ".", "DataResyncReplies", "{", "MsgId", ":", "replySeq", "(", ")", ",", "Error", ":", "&", "msg", ".", "Error", "{", "Message", ":", "err", ".", "Error", "(", ")", "}", "/*TODO all other fields*/", "}", ",", "err", "\n", "}" ]

[ "DataResyncs", "propagates", "the", "events", "in", "the", "stream", "to", "go", "channels", "of", "registered", "plugins", "." ]

[ "func", "NewEntry", "(", "logger", "*", "Logger", ")", "*", "Entry", "{", "//todo", "lgEntry", ":=", "lg", ".", "NewEntry", "(", "logger", ".", "std", ")", "\n", "return", "&", "Entry", "{", "logger", ":", "logger", ",", "lgEntry", ":", "lgEntry", ",", "}", "\n", "}" ]

[ "NewEntry", "creates", "net", "entry", "object", "which", "stores", "provided", "logger", "and", "logrus", "entry" ]

[ "func", "(", "entry", "*", "Entry", ")", "Panic", "(", "args", "...", "interface", "{", "}", ")", "{", "if", "entry", ".", "lgEntry", ".", "Logger", ".", "Level", ">=", "lg", ".", "PanicLevel", "{", "entry", ".", "lgEntry", ".", "WithFields", "(", "entry", ".", "fields", ")", ".", "Panic", "(", "args", "...", ")", "\n", "}", "\n", "}" ]

[ "Panic", "logs", "a", "message", "at", "level", "Panic", "on", "the", "standard", "logger", "." ]

[ "func", "(", "entry", "*", "Entry", ")", "Fatalf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "if", "entry", ".", "lgEntry", ".", "Logger", ".", "Level", ">=", "lg", ".", "FatalLevel", "{", "entry", ".", "lgEntry", ".", "WithFields", "(", "entry", ".", "fields", ")", ".", "Fatalf", "(", "format", ",", "args", "...", ")", "\n", "}", "\n", "}" ]

[ "Fatalf", "logs", "a", "message", "at", "level", "Debug", "on", "the", "standard", "logger", "." ]

[ "func", "(", "entry", "*", "Entry", ")", "Debugln", "(", "args", "...", "interface", "{", "}", ")", "{", "if", "entry", ".", "lgEntry", ".", "Logger", ".", "Level", ">=", "lg", ".", "DebugLevel", "{", "entry", ".", "lgEntry", ".", "WithFields", "(", "entry", ".", "fields", ")", ".", "Debugln", "(", "entry", ".", "sprintlnn", "(", "args", "...", ")", ")", "\n", "}", "\n", "}" ]

[ "Debugln", "logs", "a", "message", "at", "level", "Debug", "on", "the", "standard", "logger", "." ]

[ "func", "(", "entry", "*", "Entry", ")", "Println", "(", "args", "...", "interface", "{", "}", ")", "{", "if", "entry", ".", "lgEntry", ".", "Logger", ".", "Level", ">=", "lg", ".", "InfoLevel", "{", "entry", ".", "lgEntry", ".", "WithFields", "(", "entry", ".", "fields", ")", ".", "Println", "(", "entry", ".", "sprintlnn", "(", "args", "...", ")", ")", "\n", "}", "\n", "}" ]

[ "Println", "logs", "a", "message", "at", "level", "Info", "on", "the", "standard", "logger", "." ]

[ "func", "(", "entry", "*", "Entry", ")", "Warnln", "(", "args", "...", "interface", "{", "}", ")", "{", "if", "entry", ".", "lgEntry", ".", "Logger", ".", "Level", ">=", "lg", ".", "WarnLevel", "{", "entry", ".", "lgEntry", ".", "WithFields", "(", "entry", ".", "fields", ")", ".", "Warnln", "(", "entry", ".", "sprintlnn", "(", "args", "...", ")", ")", "\n", "}", "\n", "}" ]

[ "Warnln", "logs", "a", "message", "at", "level", "Warn", "on", "the", "standard", "logger", "." ]

[ "func", "(", "entry", "*", "Entry", ")", "Errorln", "(", "args", "...", "interface", "{", "}", ")", "{", "if", "entry", ".", "lgEntry", ".", "Logger", ".", "Level", ">=", "lg", ".", "ErrorLevel", "{", "entry", ".", "lgEntry", ".", "WithFields", "(", "entry", ".", "fields", ")", ".", "Errorln", "(", "entry", ".", "sprintlnn", "(", "args", "...", ")", ")", "\n", "}", "\n", "}" ]

[ "Errorln", "logs", "a", "message", "at", "level", "Error", "on", "the", "standard", "logger", "." ]

[ "func", "(", "entry", "*", "Entry", ")", "Fatalln", "(", "args", "...", "interface", "{", "}", ")", "{", "if", "entry", ".", "lgEntry", ".", "Logger", ".", "Level", ">=", "lg", ".", "FatalLevel", "{", "entry", ".", "lgEntry", ".", "WithFields", "(", "entry", ".", "fields", ")", ".", "Fatalln", "(", "entry", ".", "sprintlnn", "(", "args", "...", ")", ")", "\n", "}", "\n", "}" ]

[ "Fatalln", "logs", "a", "message", "at", "level", "Fatal", "on", "the", "standard", "logger", "." ]

[ "func", "PutExpToString", "(", "whereCondition", "sql", ".", "Expression", ",", "entity", "interface", "{", "}", ")", "(", "sqlStr", "string", ",", "bindings", "[", "]", "interface", "{", "}", ",", "err", "error", ")", "{", "whereCondtionStr", ":=", "&", "toStringVisitor", "{", "entity", ":", "entity", "}", "\n", "whereCondition", ".", "Accept", "(", "whereCondtionStr", ")", "\n\n", "statement", ",", "_", ",", "err", ":=", "updateSetExpToString", "(", "sql", ".", "EntityTableName", "(", "entity", ")", ",", "/*TODO extract method / make customizable*/", "entity", "/*, TODO TTL*/", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "err", "\n", "}", "\n\n", "_", ",", "bindings", "=", "structs", ".", "ListExportedFieldsPtrs", "(", "entity", ",", "cqlExported", ",", "filterOutPK", ")", "\n", "whereBinding", ":=", "whereCondtionStr", ".", "Binding", "(", ")", "\n", "if", "whereBinding", "!=", "nil", "{", "bindings", "=", "append", "(", "bindings", ",", "whereBinding", "...", ")", "\n", "}", "\n\n", "return", "strings", ".", "Trim", "(", "statement", "+", "\"", "\"", "+", "whereCondtionStr", ".", "String", "(", ")", ",", "\"", "\"", ")", ",", "bindings", ",", "nil", "\n", "}" ]

[ "PutExpToString", "converts", "expression", "to", "string", "&", "slice", "of", "bindings" ]

[ "func", "SelectExpToString", "(", "fromWhere", "sql", ".", "Expression", ")", "(", "sqlStr", "string", ",", "bindings", "[", "]", "interface", "{", "}", ",", "err", "error", ")", "{", "findEntity", ":=", "&", "findEntityVisitor", "{", "}", "\n", "fromWhere", ".", "Accept", "(", "findEntity", ")", "\n\n", "fromWhereStr", ":=", "&", "toStringVisitor", "{", "entity", ":", "findEntity", ".", "entity", "}", "\n", "fromWhere", ".", "Accept", "(", "fromWhereStr", ")", "\n\n", "fieldsStr", ":=", "selectFields", "(", "findEntity", ".", "entity", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "err", "\n", "}", "\n", "fromWhereBindings", ":=", "fromWhereStr", ".", "Binding", "(", ")", "\n\n", "whereStr", ":=", "fromWhereStr", ".", "String", "(", ")", "\n", "if", "strings", ".", "Contains", "(", "whereStr", ",", "\"", "\"", ")", "{", "whereStr", "=", "whereStr", "+", "\"", "\"", "\n", "}", "\n", "return", "\"", "\"", "+", "fieldsStr", "+", "whereStr", ",", "fromWhereBindings", ",", "nil", "\n", "}" ]

[ "SelectExpToString", "converts", "expression", "to", "string", "&", "slice", "of", "bindings" ]

[ "func", "ExpToString", "(", "exp", "sql", ".", "Expression", ")", "(", "sql", "string", ",", "bindings", "[", "]", "interface", "{", "}", ",", "err", "error", ")", "{", "findEntity", ":=", "&", "findEntityVisitor", "{", "}", "\n", "exp", ".", "Accept", "(", "findEntity", ")", "\n\n", "stringer", ":=", "&", "toStringVisitor", "{", "entity", ":", "findEntity", ".", "entity", "}", "\n", "exp", ".", "Accept", "(", "stringer", ")", "\n\n", "return", "stringer", ".", "String", "(", ")", ",", "stringer", ".", "Binding", "(", ")", ",", "stringer", ".", "lastError", "\n", "}" ]

[ "ExpToString", "converts", "expression", "to", "string", "&", "slice", "of", "bindings" ]

[ "func", "cqlExported", "(", "field", "*", "r", ".", "StructField", ")", "(", "exported", "bool", ")", "{", "cql", ":=", "field", ".", "Tag", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "len", "(", "cql", ")", ">", "0", "{", "if", "cql", "==", "\"", "\"", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "cqlExported", "checks", "the", "cql", "tag", "in", "StructField", "and", "parses", "the", "field", "name" ]