Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "c", "*", "Config", ")", "IsSecurityEnabled", "(", ")", "bool", "{", "val", ",", "ok", ":=", "c", ".", "backend", ".", "Lookup", "(", "\"", "\"", ")", "\n", "if", "!", "ok", "{", "return", "defEnabled", "\n", "}", "\n", "return", "cast", ".", "ToBool", "(", "val", ")", "\n", "}" ]

[ "IsSecurityEnabled", "config", "used", "enable", "and", "disable", "security", "in", "cryptosuite" ]

[ "func", "(", "c", "*", "Config", ")", "SecurityAlgorithm", "(", ")", "string", "{", "val", ",", "ok", ":=", "c", ".", "backend", ".", "Lookup", "(", "\"", "\"", ")", "\n", "if", "!", "ok", "{", "return", "defHashAlgorithm", "\n", "}", "\n", "return", "cast", ".", "ToString", "(", "val", ")", "\n", "}" ]

[ "SecurityAlgorithm", "returns", "cryptoSuite", "config", "hash", "algorithm" ]

[ "func", "(", "c", "*", "Config", ")", "SecurityLevel", "(", ")", "int", "{", "val", ",", "ok", ":=", "c", ".", "backend", ".", "Lookup", "(", "\"", "\"", ")", "\n", "if", "!", "ok", "{", "return", "defLevel", "\n", "}", "\n", "return", "cast", ".", "ToInt", "(", "val", ")", "\n", "}" ]

[ "SecurityLevel", "returns", "cryptSuite", "config", "security", "level" ]

[ "func", "(", "c", "*", "Config", ")", "SecurityProvider", "(", ")", "string", "{", "val", ",", "ok", ":=", "c", ".", "backend", ".", "Lookup", "(", "\"", "\"", ")", "\n", "if", "!", "ok", "{", "return", "strings", ".", "ToLower", "(", "defProvider", ")", "\n", "}", "\n", "return", "strings", ".", "ToLower", "(", "cast", ".", "ToString", "(", "val", ")", ")", "\n", "}" ]

[ "SecurityProvider", "provider", "SW", "or", "PKCS11" ]

[ "func", "(", "c", "*", "Config", ")", "SecurityProviderLibPath", "(", ")", "string", "{", "configuredLibs", ":=", "c", ".", "backend", ".", "GetString", "(", "\"", "\"", ")", "\n", "libPaths", ":=", "strings", ".", "Split", "(", "configuredLibs", ",", "\"", "\"", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "libPaths", ")", "\n", "var", "lib", "string", "\n", "for", "_", ",", "path", ":=", "range", "libPaths", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "strings", ".", "TrimSpace", "(", "path", ")", ")", ";", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "lib", "=", "strings", ".", "TrimSpace", "(", "path", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "lib", "!=", "\"", "\"", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "lib", ")", "\n", "}", "else", "{", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "lib", "\n", "}" ]

[ "SecurityProviderLibPath", "will", "be", "set", "only", "if", "provider", "is", "PKCS11" ]

[ "func", "(", "c", "*", "Config", ")", "KeyStorePath", "(", ")", "string", "{", "keystorePath", ":=", "pathvar", ".", "Subst", "(", "c", ".", "backend", ".", "GetString", "(", "\"", "\"", ")", ")", "\n", "return", "filepath", ".", "Join", "(", "keystorePath", ",", "\"", "\"", ")", "\n", "}" ]

[ "KeyStorePath", "returns", "the", "keystore", "path", "used", "by", "BCCSP" ]

[ "func", "NewDiscoveryFilterService", "(", "discoveryService", "fab", ".", "DiscoveryService", ",", "targetFilter", "fab", ".", "TargetFilter", ")", "fab", ".", "DiscoveryService", "{", "return", "&", "filterService", "{", "discoveryService", ":", "discoveryService", ",", "targetFilter", ":", "targetFilter", "}", "\n", "}" ]

[ "NewDiscoveryFilterService", "return", "discovery", "service", "with", "filter" ]

[ "func", "(", "fs", "*", "filterService", ")", "GetPeers", "(", ")", "(", "[", "]", "fab", ".", "Peer", ",", "error", ")", "{", "peers", ",", "err", ":=", "fs", ".", "discoveryService", ".", "GetPeers", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "targets", ":=", "filterTargets", "(", "peers", ",", "fs", ".", "targetFilter", ")", "\n", "return", "targets", ",", "nil", "\n", "}" ]

[ "GetPeers", "is", "used", "to", "get", "peers" ]

[ "func", "filterTargets", "(", "peers", "[", "]", "fab", ".", "Peer", ",", "filter", "fab", ".", "TargetFilter", ")", "[", "]", "fab", ".", "Peer", "{", "if", "filter", "==", "nil", "{", "return", "peers", "\n", "}", "\n\n", "filteredPeers", ":=", "[", "]", "fab", ".", "Peer", "{", "}", "\n", "for", "_", ",", "peer", ":=", "range", "peers", "{", "if", "filter", ".", "Accept", "(", "peer", ")", "{", "filteredPeers", "=", "append", "(", "filteredPeers", ",", "peer", ")", "\n", "}", "\n", "}", "\n\n", "return", "filteredPeers", "\n", "}" ]

[ "filterTargets", "is", "helper", "method", "to", "filter", "peers" ]

[ "func", "NewMockChannelProvider", "(", "ctx", "core", ".", "Providers", ")", "(", "*", "MockChannelProvider", ",", "error", ")", "{", "// Create a mock client with the mock channel", "cp", ":=", "MockChannelProvider", "{", "ctx", ":", "ctx", ",", "}", "\n", "return", "&", "cp", ",", "nil", "\n", "}" ]

[ "NewMockChannelProvider", "returns", "a", "mock", "ChannelProvider" ]

[ "func", "(", "cp", "*", "MockChannelProvider", ")", "ChannelService", "(", "ctx", "fab", ".", "ClientContext", ",", "channelID", "string", ")", "(", "fab", ".", "ChannelService", ",", "error", ")", "{", "if", "cp", ".", "customChannelService", "!=", "nil", "{", "return", "cp", ".", "customChannelService", ",", "nil", "\n", "}", "\n\n", "cs", ":=", "MockChannelService", "{", "provider", ":", "cp", ",", "channelID", ":", "channelID", ",", "transactor", ":", "&", "MockTransactor", "{", "}", ",", "discovery", ":", "NewMockDiscoveryService", "(", "nil", ")", ",", "selection", ":", "NewMockSelectionService", "(", "nil", ")", ",", "}", "\n", "return", "&", "cs", ",", "nil", "\n", "}" ]

[ "ChannelService", "returns", "a", "mock", "ChannelService" ]

[ "func", "(", "cs", "*", "MockChannelService", ")", "EventService", "(", "opts", "...", "options", ".", "Opt", ")", "(", "fab", ".", "EventService", ",", "error", ")", "{", "return", "NewMockEventService", "(", ")", ",", "nil", "\n", "}" ]

[ "EventService", "returns", "a", "mock", "event", "service" ]

[ "func", "(", "cs", "*", "MockChannelService", ")", "Transactor", "(", "reqCtx", "reqContext", ".", "Context", ")", "(", "fab", ".", "Transactor", ",", "error", ")", "{", "if", "cs", ".", "transactor", "!=", "nil", "{", "return", "cs", ".", "transactor", ",", "nil", "\n", "}", "\n", "return", "&", "MockTransactor", "{", "ChannelID", ":", "cs", ".", "channelID", ",", "Ctx", ":", "reqCtx", "}", ",", "nil", "\n", "}" ]

[ "Transactor", "returns", "a", "mock", "transactor" ]

[ "func", "(", "cs", "*", "MockChannelService", ")", "Membership", "(", ")", "(", "fab", ".", "ChannelMembership", ",", "error", ")", "{", "if", "cs", ".", "membership", "!=", "nil", "{", "return", "cs", ".", "membership", ",", "nil", "\n", "}", "\n", "return", "NewMockMembership", "(", ")", ",", "nil", "\n", "}" ]

[ "Membership", "returns", "member", "identification" ]

[ "func", "(", "cs", "*", "MockChannelService", ")", "ChannelConfig", "(", ")", "(", "fab", ".", "ChannelCfg", ",", "error", ")", "{", "return", "&", "MockChannelCfg", "{", "MockID", ":", "cs", ".", "channelID", ",", "MockOrderers", ":", "cs", ".", "mockOrderers", "}", ",", "nil", "\n", "}" ]

[ "ChannelConfig", "returns", "channel", "config" ]

[ "func", "NewMockConnection", "(", "opts", "...", "Opt", ")", "*", "MockConnection", "{", "copts", ":=", "&", "Opts", "{", "}", "\n", "for", "_", ",", "opt", ":=", "range", "opts", "{", "opt", "(", "copts", ")", "\n", "}", "\n\n", "operations", ":=", "copts", ".", "Operations", "\n", "if", "operations", "==", "nil", "{", "operations", "=", "make", "(", "map", "[", "Operation", "]", "ResultDesc", ")", "\n", "}", "\n\n", "if", "copts", ".", "Ledger", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "sourceURL", ":=", "copts", ".", "SourceURL", "\n", "if", "sourceURL", "==", "\"", "\"", "{", "sourceURL", "=", "\"", "\"", "\n", "}", "\n\n", "producer", ":=", "servicemocks", ".", "NewMockProducer", "(", "copts", ".", "Ledger", ")", "\n\n", "c", ":=", "&", "MockConnection", "{", "producer", ":", "producer", ",", "producerch", ":", "producer", ".", "Register", "(", ")", ",", "rcvch", ":", "make", "(", "chan", "interface", "{", "}", ")", ",", "operations", ":", "operations", ",", "sourceURL", ":", "sourceURL", ",", "}", "\n", "return", "c", "\n", "}" ]

[ "NewMockConnection", "returns", "a", "new", "MockConnection", "using", "the", "given", "options" ]

[ "func", "(", "c", "*", "MockConnection", ")", "Close", "(", ")", "{", "if", "!", "atomic", ".", "CompareAndSwapInt32", "(", "&", "c", ".", "closed", ",", "0", ",", "1", ")", "{", "// Already closed", "return", "\n", "}", "\n\n", "c", ".", "producer", ".", "Close", "(", ")", "\n", "close", "(", "c", ".", "rcvch", ")", "\n", "}" ]

[ "Close", "implements", "the", "MockConnection", "interface" ]

[ "func", "(", "c", "*", "MockConnection", ")", "Result", "(", "operation", "Operation", ")", "(", "ResultDesc", ",", "bool", ")", "{", "op", ",", "ok", ":=", "c", ".", "operations", "[", "operation", "]", "\n", "return", "op", ",", "ok", "\n", "}" ]

[ "Result", "returns", "the", "result", "for", "the", "given", "operation" ]

[ "func", "(", "cp", "*", "ProviderFactory", ")", "Connection", "(", ")", "Connection", "{", "cp", ".", "mtx", ".", "RLock", "(", ")", "\n", "defer", "cp", ".", "mtx", ".", "RUnlock", "(", ")", "\n", "return", "cp", ".", "connection", "\n", "}" ]

[ "Connection", "returns", "the", "connection" ]

[ "func", "(", "cp", "*", "ProviderFactory", ")", "Provider", "(", "conn", "Connection", ")", "api", ".", "ConnectionProvider", "{", "return", "func", "(", "context", ".", "Client", ",", "fab", ".", "ChannelCfg", ",", "fab", ".", "Peer", ")", "(", "api", ".", "Connection", ",", "error", ")", "{", "return", "conn", ",", "nil", "\n", "}", "\n", "}" ]

[ "Provider", "returns", "a", "connection", "provider", "that", "always", "returns", "the", "given", "connection" ]

[ "func", "(", "cp", "*", "ProviderFactory", ")", "FlakeyProvider", "(", "connAttemptResults", "ConnectAttemptResults", ",", "opts", "...", "Opt", ")", "api", ".", "ConnectionProvider", "{", "var", "connectAttempt", "Attempt", "\n", "return", "func", "(", "ctx", "context", ".", "Client", ",", "cfg", "fab", ".", "ChannelCfg", ",", "peer", "fab", ".", "Peer", ")", "(", "api", ".", "Connection", ",", "error", ")", "{", "connectAttempt", "++", "\n\n", "result", ",", "ok", ":=", "connAttemptResults", "[", "connectAttempt", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "cp", ".", "mtx", ".", "Lock", "(", ")", "\n", "defer", "cp", ".", "mtx", ".", "Unlock", "(", ")", "\n\n", "cp", ".", "connection", "=", "result", ".", "ConnFactory", "(", "opts", "...", ")", "\n\n", "return", "cp", ".", "connection", ",", "nil", "\n", "}", "\n", "}" ]

[ "FlakeyProvider", "creates", "a", "connection", "provider", "that", "returns", "a", "connection", "according", "to", "the", "given", "connection", "attempt", "results", ".", "The", "results", "tell", "the", "connection", "provider", "whether", "or", "not", "to", "fail", "to", "return", "a", "connection", "what", "authorization", "to", "give", "the", "connection", "etc", "." ]

[ "func", "NewConnectResult", "(", "attempt", "Attempt", ",", "connFactory", "ConnectionFactory", ")", "ConnectResult", "{", "return", "ConnectResult", "{", "Attempt", ":", "attempt", ",", "ConnFactory", ":", "connFactory", "}", "\n", "}" ]

[ "NewConnectResult", "returns", "a", "new", "ConnectResult" ]

[ "func", "NewConnectResults", "(", "results", "...", "ConnectResult", ")", "ConnectAttemptResults", "{", "mapResults", ":=", "make", "(", "map", "[", "Attempt", "]", "ConnectResult", ")", "\n", "for", "_", ",", "r", ":=", "range", "results", "{", "mapResults", "[", "r", ".", "Attempt", "]", "=", "r", "\n", "}", "\n", "return", "mapResults", "\n", "}" ]

[ "NewConnectResults", "returns", "a", "new", "ConnectAttemptResults" ]

[ "func", "NewResult", "(", "operation", "Operation", ",", "result", "Result", ",", "errMsg", "...", "string", ")", "*", "OperationResult", "{", "msg", ":=", "\"", "\"", "\n", "if", "len", "(", "errMsg", ")", ">", "0", "{", "msg", "=", "errMsg", "[", "0", "]", "\n", "}", "\n", "return", "&", "OperationResult", "{", "Operation", ":", "operation", ",", "Result", ":", "result", ",", "ErrMessage", ":", "msg", ",", "}", "\n", "}" ]

[ "NewResult", "returns", "a", "new", "OperationResult" ]

[ "func", "WithLedger", "(", "ledger", "servicemocks", ".", "Ledger", ")", "Opt", "{", "return", "func", "(", "opts", "*", "Opts", ")", "{", "opts", ".", "Ledger", "=", "ledger", "\n", "}", "\n", "}" ]

[ "WithLedger", "provides", "the", "mock", "connection", "with", "a", "ledger" ]

[ "func", "WithResults", "(", "funcResults", "...", "*", "OperationResult", ")", "Opt", "{", "return", "func", "(", "opts", "*", "Opts", ")", "{", "opts", ".", "Operations", "=", "make", "(", "map", "[", "Operation", "]", "ResultDesc", ")", "\n", "for", "_", ",", "fr", ":=", "range", "funcResults", "{", "opts", ".", "Operations", "[", "fr", ".", "Operation", "]", "=", "ResultDesc", "{", "Result", ":", "fr", ".", "Result", ",", "ErrMsg", ":", "fr", ".", "ErrMessage", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "WithResults", "specifies", "the", "results", "for", "one", "or", "more", "operations" ]

[ "func", "LoadPKCS11ContextHandle", "(", "lib", ",", "label", ",", "pin", "string", ",", "opts", "...", "Options", ")", "(", "*", "ContextHandle", ",", "error", ")", "{", "return", "getInstance", "(", "&", "pkcs11CtxCacheKey", "{", "lib", ":", "lib", ",", "label", ":", "label", ",", "pin", ":", "pin", ",", "opts", ":", "getCtxOpts", "(", "opts", "...", ")", "}", ",", "false", ")", "\n", "}" ]

[ "LoadPKCS11ContextHandle", "loads", "PKCS11", "context", "handler", "instance", "from", "underlying", "cache" ]

[ "func", "ReloadPKCS11ContextHandle", "(", "lib", ",", "label", ",", "pin", "string", ",", "opts", "...", "Options", ")", "(", "*", "ContextHandle", ",", "error", ")", "{", "return", "getInstance", "(", "&", "pkcs11CtxCacheKey", "{", "lib", ":", "lib", ",", "label", ":", "label", ",", "pin", ":", "pin", ",", "opts", ":", "getCtxOpts", "(", "opts", "...", ")", "}", ",", "true", ")", "\n", "}" ]

[ "ReloadPKCS11ContextHandle", "deletes", "PKCS11", "instance", "from", "underlying", "cache", "and", "loads", "new", "PKCS11", "context", "handler", "in", "cache" ]

[ "func", "LoadContextAndLogin", "(", "lib", ",", "pin", ",", "label", "string", ")", "(", "*", "ContextHandle", ",", "error", ")", "{", "pkcs11Context", ",", "err", ":=", "LoadPKCS11ContextHandle", "(", "lib", ",", "label", ",", "pin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "session", ",", "err", ":=", "pkcs11Context", ".", "OpenSession", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "err", "=", "pkcs11Context", ".", "Login", "(", "session", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "pkcs11Context", ".", "ReturnSession", "(", "session", ")", "\n", "cachebridge", ".", "ClearAllSession", "(", ")", "\n\n", "return", "pkcs11Context", ",", "err", "\n", "}" ]

[ "LoadContextAndLogin", "loads", "Context", "handle", "and", "performs", "login" ]

[ "func", "(", "handle", "*", "ContextHandle", ")", "Login", "(", "session", "mPkcs11", ".", "SessionHandle", ")", "error", "{", "handle", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "handle", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "if", "handle", ".", "pin", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "err", ":=", "handle", ".", "ctx", ".", "Login", "(", "session", ",", "mPkcs11", ".", "CKU_USER", ",", "handle", ".", "pin", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_USER_ALREADY_LOGGED_IN", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Login", "logs", "a", "user", "into", "a", "token" ]

[ "func", "(", "handle", "*", "ContextHandle", ")", "ReturnSession", "(", "session", "mPkcs11", ".", "SessionHandle", ")", "{", "handle", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "handle", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "_", ",", "e", ":=", "handle", ".", "ctx", ".", "GetSessionInfo", "(", "session", ")", "\n", "if", "e", "!=", "nil", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "session", ",", "e", ")", "\n", "e", "=", "handle", ".", "ctx", ".", "CloseSession", "(", "session", ")", "\n", "if", "e", "!=", "nil", "{", "logger", ".", "Warn", "(", "\"", "\"", ",", "e", ")", "\n", "}", "\n", "return", "\n", "}", "\n\n", "select", "{", "case", "handle", ".", "sessions", "<-", "session", ":", "// returned session back to session cache", "default", ":", "// have plenty of sessions in cache, dropping", "e", "=", "handle", ".", "ctx", ".", "CloseSession", "(", "session", ")", "\n", "if", "e", "!=", "nil", "{", "logger", ".", "Warn", "(", "\"", "\"", ",", "e", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "ReturnSession", "returns", "session", "back", "into", "the", "session", "pool", "if", "pool", "is", "pull", "or", "session", "is", "invalid", "then", "discards", "session" ]

[ "func", "(", "handle", "*", "ContextHandle", ")", "GetSession", "(", ")", "(", "session", "mPkcs11", ".", "SessionHandle", ")", "{", "handle", ".", "lock", ".", "RLock", "(", ")", "\n", "select", "{", "case", "session", "=", "<-", "handle", ".", "sessions", ":", "logger", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "session", ",", "handle", ".", "slot", ")", "\n\n", "default", ":", "// cache is empty (or completely in use), create a new session", "s", ",", "err", ":=", "handle", ".", "OpenSession", "(", ")", "\n", "if", "err", "!=", "nil", "{", "handle", ".", "lock", ".", "RUnlock", "(", ")", "\n", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "s", ",", "handle", ".", "slot", ")", "\n", "session", "=", "s", "\n", "cachebridge", ".", "ClearSession", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "session", ")", ")", "\n", "}", "\n", "handle", ".", "lock", ".", "RUnlock", "(", ")", "\n", "return", "handle", ".", "validateSession", "(", "session", ")", "\n", "}" ]

[ "GetSession", "returns", "session", "from", "session", "pool", "if", "pool", "is", "empty", "or", "completely", "in", "use", "creates", "new", "session", "if", "new", "session", "is", "invalid", "recreates", "one", "after", "reloading", "ctx", "and", "re", "-", "login" ]

[ "func", "(", "handle", "*", "ContextHandle", ")", "FindObjects", "(", "session", "mPkcs11", ".", "SessionHandle", ",", "max", "int", ")", "(", "[", "]", "mPkcs11", ".", "ObjectHandle", ",", "bool", ",", "error", ")", "{", "handle", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "handle", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "return", "handle", ".", "ctx", ".", "FindObjects", "(", "session", ",", "max", ")", "\n", "}" ]

[ "FindObjects", "continues", "a", "search", "for", "token", "and", "session", "objects", "that", "match", "a", "template", "obtaining", "additional", "object", "handles", ".", "The", "returned", "boolean", "indicates", "if", "the", "list", "would", "have", "been", "larger", "than", "max", "." ]

[ "func", "(", "handle", "*", "ContextHandle", ")", "CopyObject", "(", "sh", "mPkcs11", ".", "SessionHandle", ",", "o", "mPkcs11", ".", "ObjectHandle", ",", "temp", "[", "]", "*", "mPkcs11", ".", "Attribute", ")", "(", "mPkcs11", ".", "ObjectHandle", ",", "error", ")", "{", "handle", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "handle", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "return", "handle", ".", "ctx", ".", "CopyObject", "(", "sh", ",", "o", ",", "temp", ")", "\n", "}" ]

[ "CopyObject", "creates", "a", "copy", "of", "an", "object", "." ]

[ "func", "(", "handle", "*", "ContextHandle", ")", "FindKeyPairFromSKI", "(", "session", "mPkcs11", ".", "SessionHandle", ",", "ski", "[", "]", "byte", ",", "keyType", "bool", ")", "(", "*", "mPkcs11", ".", "ObjectHandle", ",", "error", ")", "{", "handle", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "handle", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "return", "cachebridge", ".", "GetKeyPairFromSessionSKI", "(", "&", "cachebridge", ".", "KeyPairCacheKey", "{", "Mod", ":", "handle", ".", "ctx", ",", "Session", ":", "session", ",", "SKI", ":", "ski", ",", "KeyType", ":", "keyType", "}", ")", "\n", "}" ]

[ "FindKeyPairFromSKI", "finds", "key", "pair", "by", "SKI" ]

[ "func", "(", "handle", "*", "ContextHandle", ")", "validateSession", "(", "currentSession", "mPkcs11", ".", "SessionHandle", ")", "mPkcs11", ".", "SessionHandle", "{", "handle", ".", "lock", ".", "RLock", "(", ")", "\n\n", "e", ":=", "handle", ".", "detectErrorCondition", "(", "currentSession", ")", "\n\n", "switch", "e", "{", "case", "errSlotIDChanged", ",", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_OBJECT_HANDLE_INVALID", ")", ",", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_SESSION_HANDLE_INVALID", ")", ",", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_SESSION_CLOSED", ")", ",", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_TOKEN_NOT_PRESENT", ")", ",", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_DEVICE_ERROR", ")", ",", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_GENERAL_ERROR", ")", ",", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_USER_NOT_LOGGED_IN", ")", ":", "logger", ".", "Warnf", "(", "\"", "\"", ",", "e", ")", "\n\n", "handle", ".", "lock", ".", "RUnlock", "(", ")", "\n", "handle", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "handle", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "handle", ".", "disposePKCS11Ctx", "(", ")", "\n\n", "//create new context", "newCtx", ":=", "handle", ".", "createNewPKCS11Ctx", "(", ")", "\n", "if", "newCtx", "==", "nil", "{", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "0", "\n", "}", "\n\n", "//find slot", "slot", ",", "found", ":=", "handle", ".", "findSlot", "(", "newCtx", ")", "\n", "if", "!", "found", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "handle", ".", "label", ")", "\n", "return", "0", "\n", "}", "\n", "logger", ".", "Debug", "(", "\"", "\"", ",", "slot", ")", "\n\n", "//open new session for given slot", "newSession", ",", "err", ":=", "createNewSession", "(", "newCtx", ",", "slot", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Fatalf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "0", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "newSession", ",", "slot", ")", "\n\n", "//login with new session", "err", "=", "newCtx", ".", "Login", "(", "newSession", ",", "mPkcs11", ".", "CKU_USER", ",", "handle", ".", "pin", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_USER_ALREADY_LOGGED_IN", ")", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "newSession", ")", "\n", "return", "0", "\n", "}", "\n\n", "handle", ".", "sendNotification", "(", ")", "\n\n", "handle", ".", "ctx", "=", "newCtx", "\n", "handle", ".", "slot", "=", "slot", "\n", "handle", ".", "sessions", "=", "make", "(", "chan", "mPkcs11", ".", "SessionHandle", ",", "handle", ".", "opts", ".", "sessionCacheSize", ")", "\n\n", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "return", "newSession", "\n\n", "case", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_DEVICE_MEMORY", ")", ",", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_DEVICE_REMOVED", ")", ":", "handle", ".", "lock", ".", "RUnlock", "(", ")", "\n", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ")", ")", "\n\n", "default", ":", "handle", ".", "lock", ".", "RUnlock", "(", ")", "\n", "// default should be a valid session or valid error, return session as it is", "return", "currentSession", "\n", "}", "\n", "}" ]

[ "validateSession", "validates", "given", "session", "if", "session", "is", "invalid", "recreates", "one", "after", "reloading", "ctx", "and", "re", "-", "login", "care", "should", "be", "taken", "since", "handle", ".", "lock", "should", "be", "read", "locked", "before", "calling", "this", "function" ]

[ "func", "(", "handle", "*", "ContextHandle", ")", "detectErrorCondition", "(", "currentSession", "mPkcs11", ".", "SessionHandle", ")", "error", "{", "var", "e", "error", "\n", "slot", ",", "ok", ":=", "handle", ".", "findSlot", "(", "handle", ".", "ctx", ")", "\n", "if", "!", "ok", "||", "slot", "!=", "handle", ".", "slot", "{", "e", "=", "errSlotIDChanged", "\n", "}", "\n\n", "if", "e", "==", "nil", "{", "_", ",", "e", "=", "handle", ".", "ctx", ".", "GetSessionInfo", "(", "currentSession", ")", "\n", "if", "e", "==", "nil", "{", "_", ",", "e", "=", "handle", ".", "ctx", ".", "GetOperationState", "(", "currentSession", ")", "\n", "}", "\n", "}", "\n\n", "return", "e", "\n", "}" ]

[ "detectErrorCondition", "checks", "if", "given", "session", "handle", "has", "errors" ]

[ "func", "(", "handle", "*", "ContextHandle", ")", "sendNotification", "(", ")", "{", "if", "handle", ".", "reloadNotification", "!=", "nil", "{", "select", "{", "case", "handle", ".", "reloadNotification", "<-", "struct", "{", "}", "{", "}", ":", "logger", ".", "Info", "(", "\"", "\"", ")", "\n", "default", ":", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "sendNotification", "sends", "ctx", "reload", "notificatin", "if", "channel", "available" ]

[ "func", "(", "handle", "*", "ContextHandle", ")", "disposePKCS11Ctx", "(", ")", "{", "//ignore error on close all sessions", "err", ":=", "handle", ".", "ctx", ".", "CloseAllSessions", "(", "handle", ".", "slot", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "//clear cache", "cachebridge", ".", "ClearAllSession", "(", ")", "\n\n", "//Initialize context", "err", "=", "handle", ".", "ctx", ".", "Finalize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "handle", ".", "lib", ",", "handle", ".", "label", ",", "err", ")", "\n", "}", "\n\n", "//Destroy context", "handle", ".", "ctx", ".", "Destroy", "(", ")", "\n", "}" ]

[ "disposePKCS11Ctx", "disposes", "mPkcs11", ".", "Ctx", "object" ]

[ "func", "(", "handle", "*", "ContextHandle", ")", "createNewPKCS11Ctx", "(", ")", "*", "mPkcs11", ".", "Ctx", "{", "newCtx", ":=", "mPkcs11", ".", "New", "(", "handle", ".", "lib", ")", "\n", "if", "newCtx", "==", "nil", "{", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "//initialize new context", "err", ":=", "newCtx", ".", "Initialize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "!=", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_CRYPTOKI_ALREADY_INITIALIZED", ")", "{", "logger", ".", "Warn", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n\n", "return", "newCtx", "\n", "}" ]

[ "createNewPKCS11Ctx", "creates", "new", "mPkcs11", ".", "Ctx" ]

[ "func", "(", "handle", "*", "ContextHandle", ")", "findSlot", "(", "ctx", "*", "mPkcs11", ".", "Ctx", ")", "(", "uint", ",", "bool", ")", "{", "var", "found", "bool", "\n", "var", "slot", "uint", "\n\n", "//get all slots", "slots", ",", "err", ":=", "ctx", ".", "GetSlotList", "(", "true", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warn", "(", "\"", "\"", ",", "err", ")", "\n", "return", "slot", ",", "found", "\n", "}", "\n\n", "//find slot matching label", "for", "_", ",", "s", ":=", "range", "slots", "{", "info", ",", "err", ":=", "ctx", ".", "GetTokenInfo", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "handle", ".", "label", ",", "info", ".", "Label", ")", "\n", "if", "handle", ".", "label", "==", "info", ".", "Label", "{", "found", "=", "true", "\n", "slot", "=", "s", "\n", "break", "\n", "}", "\n", "}", "\n\n", "return", "slot", ",", "found", "\n", "}" ]

[ "findSlot", "finds", "slot", "for", "given", "pkcs11", "ctx", "and", "label" ]

[ "func", "(", "key", "*", "pkcs11CtxCacheKey", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "key", ".", "lib", ",", "key", ".", "label", ",", "key", ".", "opts", ".", "connectionName", ",", "key", ".", "opts", ".", "sessionCacheSize", ",", "key", ".", "opts", ".", "openSessionRetry", ")", "\n", "}" ]

[ "String", "return", "string", "value", "for", "pkcs11CtxCacheKey" ]

[ "func", "getInstance", "(", "key", "lazycache", ".", "Key", ",", "reload", "bool", ")", "(", "*", "ContextHandle", ",", "error", ")", "{", "once", ".", "Do", "(", "func", "(", ")", "{", "ctxCache", "=", "newCtxCache", "(", ")", "\n", "//anyway, loading first time, no need to reload", "reload", "=", "false", "\n", "}", ")", "\n\n", "if", "reload", "{", "ctxCache", ".", "Delete", "(", "key", ")", "\n", "}", "\n\n", "ref", ",", "err", ":=", "ctxCache", ".", "Get", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "ref", ".", "(", "*", "ContextHandle", ")", ",", "nil", "\n", "}" ]

[ "getInstance", "loads", "ContextHandle", "instance", "from", "cache", "key", "-", "cache", "key", "reload", "-", "if", "true", "then", "deletes", "the", "existing", "cache", "instance", "and", "recreates", "one" ]

[ "func", "finalizer", "(", ")", "lazyref", ".", "Finalizer", "{", "return", "func", "(", "v", "interface", "{", "}", ")", "{", "if", "handle", ",", "ok", ":=", "v", ".", "(", "*", "ContextHandle", ")", ";", "ok", "{", "err", ":=", "handle", ".", "ctx", ".", "CloseAllSessions", "(", "handle", ".", "slot", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "handle", ".", "lib", ",", "handle", ".", "label", ",", "err", ")", "\n", "}", "\n", "err", "=", "handle", ".", "ctx", ".", "Finalize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "handle", ".", "lib", ",", "handle", ".", "label", ",", "err", ")", "\n", "}", "\n", "handle", ".", "ctx", ".", "Destroy", "(", ")", "\n", "cachebridge", ".", "ClearAllSession", "(", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "finalizer", "finalizer", "for", "context", "handler", "cache" ]

[ "func", "loadLibInitializer", "(", ")", "lazycache", ".", "EntryInitializer", "{", "return", "func", "(", "key", "lazycache", ".", "Key", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "ctxKey", ":=", "key", ".", "(", "*", "pkcs11CtxCacheKey", ")", "\n", "var", "slot", "uint", "\n", "logger", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "ctxKey", ".", "lib", ")", "\n", "if", "ctxKey", ".", "lib", "==", "\"", "\"", "{", "return", "&", "ContextHandle", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "ctx", ":=", "mPkcs11", ".", "New", "(", "ctxKey", ".", "lib", ")", "\n", "if", "ctx", "==", "nil", "{", "return", "&", "ContextHandle", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "ctxKey", ".", "lib", ")", "\n", "}", "\n\n", "err", ":=", "ctx", ".", "Initialize", "(", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "mPkcs11", ".", "Error", "(", "mPkcs11", ".", "CKR_CRYPTOKI_ALREADY_INITIALIZED", ")", "{", "logger", ".", "Warn", "(", "\"", "\"", ",", "err", ")", "\n", "return", "&", "ContextHandle", "{", "}", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "slots", ",", "err", ":=", "ctx", ".", "GetSlotList", "(", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "&", "ContextHandle", "{", "}", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "found", ":=", "false", "\n", "for", "_", ",", "s", ":=", "range", "slots", "{", "info", ",", "errToken", ":=", "ctx", ".", "GetTokenInfo", "(", "s", ")", "\n", "if", "errToken", "!=", "nil", "{", "continue", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "ctxKey", ".", "label", ",", "info", ".", "Label", ")", "\n", "if", "ctxKey", ".", "label", "==", "info", ".", "Label", "{", "found", "=", "true", "\n", "slot", "=", "s", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "return", "&", "ContextHandle", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "ctxKey", ".", "label", ")", "\n", "}", "\n", "sessions", ":=", "make", "(", "chan", "mPkcs11", ".", "SessionHandle", ",", "ctxKey", ".", "opts", ".", "sessionCacheSize", ")", "\n", "return", "&", "ContextHandle", "{", "ctx", ":", "ctx", ",", "slot", ":", "slot", ",", "pin", ":", "ctxKey", ".", "pin", ",", "lib", ":", "ctxKey", ".", "lib", ",", "label", ":", "ctxKey", ".", "label", ",", "sessions", ":", "sessions", ",", "opts", ":", "ctxKey", ".", "opts", "}", ",", "nil", "\n", "}", "\n", "}" ]

[ "loadLibInitializer", "initializer", "for", "context", "handler", "cache" ]

[ "func", "New", "(", "channelID", "string", ",", "options", "...", "Option", ")", "(", "*", "ChannelConfig", ",", "error", ")", "{", "opts", ",", "err", ":=", "prepareOpts", "(", "options", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ChannelConfig", "{", "channelID", ":", "channelID", ",", "opts", ":", "opts", "}", ",", "nil", "\n", "}" ]

[ "New", "channel", "config", "implementation" ]

[ "func", "(", "c", "*", "ChannelConfig", ")", "Query", "(", "reqCtx", "reqContext", ".", "Context", ")", "(", "fab", ".", "ChannelCfg", ",", "error", ")", "{", "if", "c", ".", "opts", ".", "Orderer", "!=", "nil", "{", "return", "c", ".", "queryOrderer", "(", "reqCtx", ")", "\n", "}", "\n\n", "return", "c", ".", "queryPeers", "(", "reqCtx", ")", "\n", "}" ]

[ "Query", "returns", "channel", "configuration" ]

[ "func", "WithPeers", "(", "peers", "[", "]", "fab", ".", "Peer", ")", "Option", "{", "return", "func", "(", "opts", "*", "Opts", ")", "error", "{", "opts", ".", "Targets", "=", "peers", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithPeers", "encapsulates", "peers", "to", "Option" ]

[ "func", "WithMinResponses", "(", "min", "int", ")", "Option", "{", "return", "func", "(", "opts", "*", "Opts", ")", "error", "{", "opts", ".", "MinResponses", "=", "min", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithMinResponses", "encapsulates", "minimum", "responses", "to", "Option" ]

[ "func", "WithOrderer", "(", "orderer", "fab", ".", "Orderer", ")", "Option", "{", "return", "func", "(", "opts", "*", "Opts", ")", "error", "{", "opts", ".", "Orderer", "=", "orderer", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithOrderer", "encapsulates", "orderer", "to", "Option" ]

[ "func", "WithMaxTargets", "(", "maxTargets", "int", ")", "Option", "{", "return", "func", "(", "opts", "*", "Opts", ")", "error", "{", "opts", ".", "MaxTargets", "=", "maxTargets", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithMaxTargets", "encapsulates", "minTargets", "to", "Option" ]

[ "func", "WithRetryOpts", "(", "retryOpts", "retry", ".", "Opts", ")", "Option", "{", "return", "func", "(", "opts", "*", "Opts", ")", "error", "{", "opts", ".", "RetryOpts", "=", "retryOpts", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithRetryOpts", "encapsulates", "retry", "opts", "to", "Option" ]

[ "func", "prepareOpts", "(", "options", "...", "Option", ")", "(", "Opts", ",", "error", ")", "{", "opts", ":=", "Opts", "{", "}", "\n", "for", "_", ",", "option", ":=", "range", "options", "{", "err", ":=", "option", "(", "&", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "opts", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "return", "opts", ",", "nil", "\n", "}" ]

[ "prepareOpts", "Reads", "channel", "config", "options", "from", "Option", "array" ]

[ "func", "randomMaxTargets", "(", "targets", "[", "]", "fab", ".", "ProposalProcessor", ",", "max", "int", ")", "[", "]", "fab", ".", "ProposalProcessor", "{", "if", "len", "(", "targets", ")", "<=", "max", "{", "return", "targets", "\n", "}", "\n", "for", "i", ":=", "range", "targets", "{", "j", ":=", "rand", ".", "Intn", "(", "i", "+", "1", ")", "\n", "targets", "[", "i", "]", ",", "targets", "[", "j", "]", "=", "targets", "[", "j", "]", ",", "targets", "[", "i", "]", "\n", "}", "\n", "return", "targets", "[", ":", "max", "]", "\n", "}" ]

[ "randomMaxTargets", "returns", "random", "sub", "set", "of", "max", "length", "targets" ]

[ "func", "getOptsByConfig", "(", "c", "core", ".", "CryptoSuiteConfig", ")", "*", "pkcs11", ".", "PKCS11Opts", "{", "pkks", ":=", "pkcs11", ".", "FileKeystoreOpts", "{", "KeyStorePath", ":", "c", ".", "KeyStorePath", "(", ")", "}", "\n", "opts", ":=", "&", "pkcs11", ".", "PKCS11Opts", "{", "SecLevel", ":", "c", ".", "SecurityLevel", "(", ")", ",", "HashFamily", ":", "c", ".", "SecurityAlgorithm", "(", ")", ",", "FileKeystore", ":", "&", "pkks", ",", "Library", ":", "c", ".", "SecurityProviderLibPath", "(", ")", ",", "Pin", ":", "c", ".", "SecurityProviderPin", "(", ")", ",", "Label", ":", "c", ".", "SecurityProviderLabel", "(", ")", ",", "SoftVerify", ":", "c", ".", "SoftVerify", "(", ")", ",", "}", "\n", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "return", "opts", "\n", "}" ]

[ "getOptsByConfig", "Returns", "Factory", "opts", "for", "given", "SDK", "config" ]

[ "func", "NewSeekEvent", "(", "seekInfo", "*", "ab", ".", "SeekInfo", ",", "errch", "chan", "<-", "error", ")", "*", "SeekEvent", "{", "return", "&", "SeekEvent", "{", "SeekInfo", ":", "seekInfo", ",", "ErrCh", ":", "errch", ",", "}", "\n", "}" ]

[ "NewSeekEvent", "returns", "a", "new", "SeekRequestEvent" ]

[ "func", "NewRefCache", "(", "opts", "...", "options", ".", "Opt", ")", "*", "lazycache", ".", "Cache", "{", "initializer", ":=", "func", "(", "key", "lazycache", ".", "Key", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "ck", ",", "ok", ":=", "key", ".", "(", "CacheKey", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "NewRef", "(", "ck", ".", "Context", "(", ")", ",", "ck", ".", "Provider", "(", ")", ",", "ck", ".", "ChannelID", "(", ")", ",", "opts", "...", ")", ",", "nil", "\n", "}", "\n\n", "return", "lazycache", ".", "New", "(", "\"", "\"", ",", "initializer", ")", "\n", "}" ]

[ "NewRefCache", "a", "cache", "of", "channel", "config", "references", "that", "refreshed", "with", "the", "given", "interval" ]

[ "func", "(", "e", "*", "EventEndpoint", ")", "BlockHeight", "(", ")", "uint64", "{", "peerState", ",", "ok", ":=", "e", ".", "Peer", ".", "(", "fab", ".", "PeerState", ")", "\n", "if", "!", "ok", "{", "return", "0", "\n", "}", "\n", "return", "peerState", ".", "BlockHeight", "(", ")", "\n", "}" ]

[ "BlockHeight", "returns", "the", "block", "height", "of", "the", "peer", ".", "If", "the", "peer", "doesn", "t", "contain", "any", "state", "info", "then", "0", "is", "returned", "." ]

[ "func", "FromPeerConfig", "(", "config", "fab", ".", "EndpointConfig", ",", "peer", "fab", ".", "Peer", ",", "peerCfg", "*", "fab", ".", "PeerConfig", ")", "*", "EventEndpoint", "{", "opts", ":=", "comm", ".", "OptsFromPeerConfig", "(", "peerCfg", ")", "\n", "opts", "=", "append", "(", "opts", ",", "comm", ".", "WithConnectTimeout", "(", "config", ".", "Timeout", "(", "fab", ".", "PeerConnection", ")", ")", ")", "\n\n", "return", "&", "EventEndpoint", "{", "Peer", ":", "peer", ",", "opts", ":", "opts", ",", "}", "\n", "}" ]

[ "FromPeerConfig", "creates", "a", "new", "EventEndpoint", "from", "the", "given", "config" ]

[ "func", "NewSimpleMockBlock", "(", ")", "*", "common", ".", "Block", "{", "return", "&", "common", ".", "Block", "{", "Data", ":", "&", "common", ".", "BlockData", "{", "Data", ":", "[", "]", "[", "]", "byte", "{", "[", "]", "byte", "(", "\"", "\"", ")", "}", ",", "}", ",", "Header", ":", "&", "common", ".", "BlockHeader", "{", "DataHash", ":", "[", "]", "byte", "(", "\"", "\"", ")", ",", "PreviousHash", ":", "[", "]", "byte", "(", "\"", "\"", ")", ",", "Number", ":", "1", ",", "}", ",", "Metadata", ":", "&", "common", ".", "BlockMetadata", "{", "Metadata", ":", "[", "]", "[", "]", "byte", "{", "[", "]", "byte", "(", "\"", "\"", ")", "}", ",", "}", ",", "}", "\n", "}" ]

[ "NewSimpleMockBlock", "returns", "a", "simple", "mock", "block" ]

[ "func", "(", "b", "*", "MockConfigBlockBuilder", ")", "Build", "(", ")", "*", "common", ".", "Block", "{", "return", "&", "common", ".", "Block", "{", "Header", ":", "&", "common", ".", "BlockHeader", "{", "Number", ":", "b", ".", "Index", ",", "}", ",", "Metadata", ":", "b", ".", "buildBlockMetadata", "(", ")", ",", "Data", ":", "&", "common", ".", "BlockData", "{", "Data", ":", "b", ".", "buildBlockEnvelopeBytes", "(", ")", ",", "}", ",", "}", "\n", "}" ]

[ "Build", "creates", "a", "mock", "Chain", "configuration", "Block" ]

[ "func", "(", "b", "*", "MockConfigUpdateEnvelopeBuilder", ")", "Build", "(", ")", "*", "common", ".", "Envelope", "{", "return", "&", "common", ".", "Envelope", "{", "Payload", ":", "marshalOrPanic", "(", "b", ".", "buildPayload", "(", ")", ")", ",", "}", "\n", "}" ]

[ "Build", "builds", "an", "Envelope", "that", "contains", "a", "mock", "ConfigUpdateEnvelope" ]

[ "func", "CreateBlockWithCCEvent", "(", "events", "*", "pp", ".", "ChaincodeEvent", ",", "txID", "string", ",", "channelID", "string", ")", "(", "*", "common", ".", "Block", ",", "error", ")", "{", "return", "CreateBlockWithCCEventAndTxStatus", "(", "events", ",", "txID", ",", "channelID", ",", "pp", ".", "TxValidationCode_VALID", ")", "\n", "}" ]

[ "CreateBlockWithCCEvent", "creates", "a", "mock", "block" ]

[ "func", "CreateBlockWithCCEventAndTxStatus", "(", "events", "*", "pp", ".", "ChaincodeEvent", ",", "txID", "string", ",", "channelID", "string", ",", "txValidationCode", "pp", ".", "TxValidationCode", ")", "(", "*", "common", ".", "Block", ",", "error", ")", "{", "chdr", ":=", "&", "common", ".", "ChannelHeader", "{", "Type", ":", "int32", "(", "common", ".", "HeaderType_ENDORSER_TRANSACTION", ")", ",", "Version", ":", "1", ",", "Timestamp", ":", "&", "timestamp", ".", "Timestamp", "{", "Seconds", ":", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ",", "Nanos", ":", "0", ",", "}", ",", "ChannelId", ":", "channelID", ",", "TxId", ":", "txID", "}", "\n", "hdr", ":=", "&", "common", ".", "Header", "{", "ChannelHeader", ":", "protoutil", ".", "MarshalOrPanic", "(", "chdr", ")", "}", "\n", "payload", ":=", "&", "common", ".", "Payload", "{", "Header", ":", "hdr", "}", "\n", "cea", ":=", "&", "pp", ".", "ChaincodeEndorsedAction", "{", "}", "\n", "ccaPayload", ":=", "&", "pp", ".", "ChaincodeActionPayload", "{", "Action", ":", "cea", "}", "\n", "env", ":=", "&", "common", ".", "Envelope", "{", "}", "\n", "taa", ":=", "&", "pp", ".", "TransactionAction", "{", "}", "\n", "taas", ":=", "make", "(", "[", "]", "*", "pp", ".", "TransactionAction", ",", "1", ")", "\n", "taas", "[", "0", "]", "=", "taa", "\n", "tx", ":=", "&", "pp", ".", "Transaction", "{", "Actions", ":", "taas", "}", "\n\n", "pHashBytes", ":=", "[", "]", "byte", "(", "\"", "\"", ")", "\n", "pResponse", ":=", "&", "pp", ".", "Response", "{", "Status", ":", "200", "}", "\n", "results", ":=", "[", "]", "byte", "(", "\"", "\"", ")", "\n", "eventBytes", ",", "err", ":=", "protoutil", ".", "GetBytesChaincodeEvent", "(", "events", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "ccaPayload", ".", "Action", ".", "ProposalResponsePayload", ",", "err", "=", "protoutil", ".", "GetBytesProposalResponsePayload", "(", "pHashBytes", ",", "pResponse", ",", "results", ",", "eventBytes", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "tx", ".", "Actions", "[", "0", "]", ".", "Payload", ",", "err", "=", "protoutil", ".", "GetBytesChaincodeActionPayload", "(", "ccaPayload", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "payload", ".", "Data", ",", "err", "=", "protoutil", ".", "GetBytesTransaction", "(", "tx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "env", ".", "Payload", ",", "err", "=", "protoutil", ".", "GetBytesPayload", "(", "payload", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "ebytes", ",", "err", ":=", "protoutil", ".", "GetBytesEnvelope", "(", "env", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "block", ":=", "newBlock", "(", "1", ",", "[", "]", "byte", "{", "}", ")", "\n", "block", ".", "Data", ".", "Data", "=", "append", "(", "block", ".", "Data", ".", "Data", ",", "ebytes", ")", "\n\n", "blockbytes", ":=", "cutil", ".", "ConcatenateBytes", "(", "block", ".", "Data", ".", "Data", "...", ")", "\n", "block", ".", "Header", ".", "DataHash", "=", "computeSHA256", "(", "blockbytes", ")", "\n\n", "txsfltr", ":=", "ledger_util", ".", "NewTxValidationFlags", "(", "len", "(", "block", ".", "Data", ".", "Data", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "block", ".", "Data", ".", "Data", ")", ";", "i", "++", "{", "txsfltr", "[", "i", "]", "=", "uint8", "(", "txValidationCode", ")", "\n", "}", "\n\n", "block", ".", "Metadata", ".", "Metadata", "[", "common", ".", "BlockMetadataIndex_TRANSACTIONS_FILTER", "]", "=", "txsfltr", "\n\n", "return", "block", ",", "nil", "\n", "}" ]

[ "CreateBlockWithCCEventAndTxStatus", "creates", "a", "mock", "block", "with", "the", "given", "CC", "event", "and", "TX", "validation", "code" ]

[ "func", "newBlock", "(", "seqNum", "uint64", ",", "previousHash", "[", "]", "byte", ")", "*", "common", ".", "Block", "{", "block", ":=", "&", "common", ".", "Block", "{", "}", "\n", "block", ".", "Header", "=", "&", "common", ".", "BlockHeader", "{", "}", "\n", "block", ".", "Header", ".", "Number", "=", "seqNum", "\n", "block", ".", "Header", ".", "PreviousHash", "=", "previousHash", "\n", "block", ".", "Data", "=", "&", "common", ".", "BlockData", "{", "}", "\n\n", "var", "metadataContents", "[", "]", "[", "]", "byte", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "common", ".", "BlockMetadataIndex_name", ")", ";", "i", "++", "{", "metadataContents", "=", "append", "(", "metadataContents", ",", "[", "]", "byte", "{", "}", ")", "\n", "}", "\n", "block", ".", "Metadata", "=", "&", "common", ".", "BlockMetadata", "{", "Metadata", ":", "metadataContents", "}", "\n\n", "return", "block", "\n", "}" ]

[ "NewBlock", "construct", "a", "block", "with", "no", "data", "and", "no", "metadata", "." ]

[ "func", "NewService", "(", "discovery", "fab", ".", "DiscoveryService", ")", "(", "fab", ".", "SelectionService", ",", "error", ")", "{", "return", "&", "SelectionService", "{", "discoveryService", ":", "discovery", "}", ",", "nil", "\n", "}" ]

[ "NewService", "creates", "a", "static", "selection", "service" ]

[ "func", "(", "s", "*", "SelectionService", ")", "GetEndorsersForChaincode", "(", "chaincodes", "[", "]", "*", "fab", ".", "ChaincodeCall", ",", "opts", "...", "copts", ".", "Opt", ")", "(", "[", "]", "fab", ".", "Peer", ",", "error", ")", "{", "params", ":=", "options", ".", "NewParams", "(", "opts", ")", "\n\n", "channelPeers", ",", "err", ":=", "s", ".", "discoveryService", ".", "GetPeers", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// Apply peer filter if provided", "if", "params", ".", "PeerFilter", "!=", "nil", "{", "var", "peers", "[", "]", "fab", ".", "Peer", "\n", "for", "_", ",", "peer", ":=", "range", "channelPeers", "{", "if", "params", ".", "PeerFilter", "(", "peer", ")", "{", "peers", "=", "append", "(", "peers", ",", "peer", ")", "\n", "}", "\n", "}", "\n", "channelPeers", "=", "peers", "\n", "}", "\n\n", "if", "params", ".", "PeerSorter", "!=", "nil", "{", "peers", ":=", "make", "(", "[", "]", "fab", ".", "Peer", ",", "len", "(", "channelPeers", ")", ")", "\n", "copy", "(", "peers", ",", "channelPeers", ")", "\n", "channelPeers", "=", "params", ".", "PeerSorter", "(", "peers", ")", "\n", "}", "\n\n", "if", "logging", ".", "IsEnabledFor", "(", "loggerModule", ",", "logging", ".", "DEBUG", ")", "{", "str", ":=", "\"", "\"", "\n", "for", "i", ",", "peer", ":=", "range", "channelPeers", "{", "str", "+=", "peer", ".", "URL", "(", ")", "\n", "if", "i", "+", "1", "<", "len", "(", "channelPeers", ")", "{", "str", "+=", "\"", "\"", "\n", "}", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "str", ")", "\n", "}", "\n\n", "return", "channelPeers", ",", "nil", "\n", "}" ]

[ "GetEndorsersForChaincode", "returns", "a", "set", "of", "endorsing", "peers" ]

[ "func", "(", "s", "*", "MemoryUserStore", ")", "Store", "(", "user", "*", "msp", ".", "UserData", ")", "error", "{", "s", ".", "store", "[", "user", ".", "ID", "+", "\"", "\"", "+", "user", ".", "MSPID", "]", "=", "user", ".", "EnrollmentCertificate", "\n", "return", "nil", "\n", "}" ]

[ "Store", "stores", "a", "user", "into", "store" ]

[ "func", "(", "s", "*", "MemoryUserStore", ")", "Load", "(", "id", "msp", ".", "IdentityIdentifier", ")", "(", "*", "msp", ".", "UserData", ",", "error", ")", "{", "cert", ",", "ok", ":=", "s", ".", "store", "[", "id", ".", "ID", "+", "\"", "\"", "+", "id", ".", "MSPID", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "msp", ".", "ErrUserNotFound", "\n", "}", "\n", "userData", ":=", "msp", ".", "UserData", "{", "ID", ":", "id", ".", "ID", ",", "MSPID", ":", "id", ".", "MSPID", ",", "EnrollmentCertificate", ":", "cert", ",", "}", "\n", "return", "&", "userData", ",", "nil", "\n", "}" ]

[ "Load", "loads", "a", "user", "from", "store" ]

[ "func", "NewMemoryKeyStore", "(", "password", "[", "]", "byte", ")", "*", "MemoryKeyStore", "{", "store", ":=", "make", "(", "map", "[", "string", "]", "bccsp", ".", "Key", ")", "\n", "return", "&", "MemoryKeyStore", "{", "store", ":", "store", ",", "password", ":", "password", "}", "\n", "}" ]

[ "NewMemoryKeyStore", "creates", "a", "new", "MemoryKeyStore", "instance" ]

[ "func", "(", "s", "*", "MemoryKeyStore", ")", "GetKey", "(", "ski", "[", "]", "byte", ")", "(", "bccsp", ".", "Key", ",", "error", ")", "{", "key", ",", "ok", ":=", "s", ".", "store", "[", "hex", ".", "EncodeToString", "(", "ski", ")", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ski", ")", "\n", "}", "\n", "return", "key", ",", "nil", "\n", "}" ]

[ "GetKey", "returns", "a", "key", "for", "the", "provided", "SKI" ]

[ "func", "(", "s", "*", "MemoryKeyStore", ")", "StoreKey", "(", "key", "bccsp", ".", "Key", ")", "error", "{", "ski", ":=", "hex", ".", "EncodeToString", "(", "key", ".", "SKI", "(", ")", ")", "\n", "s", ".", "store", "[", "ski", "]", "=", "key", "\n", "return", "nil", "\n", "}" ]

[ "StoreKey", "stores", "a", "key" ]

[ "func", "NewRegisterBlockEvent", "(", "filter", "fab", ".", "BlockFilter", ",", "eventch", "chan", "<-", "*", "fab", ".", "BlockEvent", ",", "respch", "chan", "<-", "fab", ".", "Registration", ",", "errCh", "chan", "<-", "error", ")", "*", "RegisterBlockEvent", "{", "return", "&", "RegisterBlockEvent", "{", "Reg", ":", "&", "BlockReg", "{", "Filter", ":", "filter", ",", "Eventch", ":", "eventch", "}", ",", "RegisterEvent", ":", "NewRegisterEvent", "(", "respch", ",", "errCh", ")", ",", "}", "\n", "}" ]

[ "NewRegisterBlockEvent", "creates", "a", "new", "RegisterBlockEvent" ]

[ "func", "NewRegisterFilteredBlockEvent", "(", "eventch", "chan", "<-", "*", "fab", ".", "FilteredBlockEvent", ",", "respch", "chan", "<-", "fab", ".", "Registration", ",", "errCh", "chan", "<-", "error", ")", "*", "RegisterFilteredBlockEvent", "{", "return", "&", "RegisterFilteredBlockEvent", "{", "Reg", ":", "&", "FilteredBlockReg", "{", "Eventch", ":", "eventch", "}", ",", "RegisterEvent", ":", "NewRegisterEvent", "(", "respch", ",", "errCh", ")", ",", "}", "\n", "}" ]

[ "NewRegisterFilteredBlockEvent", "creates", "a", "new", "RegisterFilterBlockEvent" ]

[ "func", "NewRegisterChaincodeEvent", "(", "ccID", ",", "eventFilter", "string", ",", "eventch", "chan", "<-", "*", "fab", ".", "CCEvent", ",", "respch", "chan", "<-", "fab", ".", "Registration", ",", "errCh", "chan", "<-", "error", ")", "*", "RegisterChaincodeEvent", "{", "return", "&", "RegisterChaincodeEvent", "{", "Reg", ":", "&", "ChaincodeReg", "{", "ChaincodeID", ":", "ccID", ",", "EventFilter", ":", "eventFilter", ",", "Eventch", ":", "eventch", ",", "}", ",", "RegisterEvent", ":", "NewRegisterEvent", "(", "respch", ",", "errCh", ")", ",", "}", "\n", "}" ]

[ "NewRegisterChaincodeEvent", "creates", "a", "new", "RegisterChaincodeEvent" ]

[ "func", "NewRegisterTxStatusEvent", "(", "txID", "string", ",", "eventch", "chan", "<-", "*", "fab", ".", "TxStatusEvent", ",", "respch", "chan", "<-", "fab", ".", "Registration", ",", "errCh", "chan", "<-", "error", ")", "*", "RegisterTxStatusEvent", "{", "return", "&", "RegisterTxStatusEvent", "{", "Reg", ":", "&", "TxStatusReg", "{", "TxID", ":", "txID", ",", "Eventch", ":", "eventch", "}", ",", "RegisterEvent", ":", "NewRegisterEvent", "(", "respch", ",", "errCh", ")", ",", "}", "\n", "}" ]

[ "NewRegisterTxStatusEvent", "creates", "a", "new", "RegisterTxStatusEvent" ]

[ "func", "NewRegisterEvent", "(", "respch", "chan", "<-", "fab", ".", "Registration", ",", "errCh", "chan", "<-", "error", ")", "RegisterEvent", "{", "return", "RegisterEvent", "{", "RegCh", ":", "respch", ",", "ErrCh", ":", "errCh", ",", "}", "\n", "}" ]

[ "NewRegisterEvent", "creates", "a", "new", "RgisterEvent" ]

[ "func", "NewBlockEvent", "(", "block", "*", "cb", ".", "Block", ",", "sourceURL", "string", ")", "*", "fab", ".", "BlockEvent", "{", "return", "&", "fab", ".", "BlockEvent", "{", "Block", ":", "block", ",", "SourceURL", ":", "sourceURL", ",", "}", "\n", "}" ]

[ "NewBlockEvent", "creates", "a", "new", "BlockEvent" ]

[ "func", "NewFilteredBlockEvent", "(", "fblock", "*", "pb", ".", "FilteredBlock", ",", "sourceURL", "string", ")", "*", "fab", ".", "FilteredBlockEvent", "{", "return", "&", "fab", ".", "FilteredBlockEvent", "{", "FilteredBlock", ":", "fblock", ",", "SourceURL", ":", "sourceURL", ",", "}", "\n", "}" ]

[ "NewFilteredBlockEvent", "creates", "a", "new", "FilteredBlockEvent" ]

[ "func", "NewChaincodeEvent", "(", "chaincodeID", ",", "eventName", ",", "txID", "string", ",", "payload", "[", "]", "byte", ",", "blockNum", "uint64", ",", "sourceURL", "string", ")", "*", "fab", ".", "CCEvent", "{", "return", "&", "fab", ".", "CCEvent", "{", "ChaincodeID", ":", "chaincodeID", ",", "EventName", ":", "eventName", ",", "TxID", ":", "txID", ",", "Payload", ":", "payload", ",", "BlockNumber", ":", "blockNum", ",", "SourceURL", ":", "sourceURL", ",", "}", "\n", "}" ]

[ "NewChaincodeEvent", "creates", "a", "new", "ChaincodeEvent" ]

[ "func", "NewTxStatusEvent", "(", "txID", "string", ",", "txValidationCode", "pb", ".", "TxValidationCode", ",", "blockNum", "uint64", ",", "sourceURL", "string", ")", "*", "fab", ".", "TxStatusEvent", "{", "return", "&", "fab", ".", "TxStatusEvent", "{", "TxID", ":", "txID", ",", "TxValidationCode", ":", "txValidationCode", ",", "BlockNumber", ":", "blockNum", ",", "SourceURL", ":", "sourceURL", ",", "}", "\n", "}" ]

[ "NewTxStatusEvent", "creates", "a", "new", "TxStatusEvent" ]

[ "func", "NewTransferEvent", "(", "snapshotch", "chan", "<-", "fab", ".", "EventSnapshot", ",", "errch", "chan", "<-", "error", ")", "*", "TransferEvent", "{", "return", "&", "TransferEvent", "{", "ErrCh", ":", "errch", ",", "SnapshotCh", ":", "snapshotch", ",", "}", "\n", "}" ]

[ "NewTransferEvent", "creates", "a", "new", "TransferEvent" ]

[ "func", "NewStopAndTransferEvent", "(", "snapshotch", "chan", "<-", "fab", ".", "EventSnapshot", ",", "errch", "chan", "<-", "error", ")", "*", "StopAndTransferEvent", "{", "return", "&", "StopAndTransferEvent", "{", "ErrCh", ":", "errch", ",", "SnapshotCh", ":", "snapshotch", ",", "}", "\n", "}" ]

[ "NewStopAndTransferEvent", "creates", "a", "new", "StopAndTransferEvent" ]

[ "func", "(", "c", "*", "defConfigBackend", ")", "Lookup", "(", "key", "string", ")", "(", "interface", "{", "}", ",", "bool", ")", "{", "value", ":=", "c", ".", "configViper", ".", "Get", "(", "key", ")", "\n", "if", "value", "==", "nil", "{", "return", "nil", ",", "false", "\n", "}", "\n", "return", "value", ",", "true", "\n", "}" ]

[ "Lookup", "gets", "the", "config", "item", "value", "by", "Key" ]

[ "func", "(", "c", "*", "defConfigBackend", ")", "loadTemplateConfig", "(", ")", "error", "{", "// get Environment Default Config Path", "templatePath", ":=", "c", ".", "opts", ".", "templatePath", "\n", "if", "templatePath", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n\n", "// if set, use it to load default config", "c", ".", "configViper", ".", "AddConfigPath", "(", "pathvar", ".", "Subst", "(", "templatePath", ")", ")", "\n", "err", ":=", "c", ".", "configViper", ".", "ReadInConfig", "(", ")", "// Find and read the config file", "\n", "if", "err", "!=", "nil", "{", "// Handle errors reading the config file", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "templatePath", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "load", "Default", "config" ]

[ "func", "NewMockSelectionService", "(", "err", "error", ",", "peers", "...", "fab", ".", "Peer", ")", "*", "MockSelectionService", "{", "return", "&", "MockSelectionService", "{", "Error", ":", "err", ",", "Peers", ":", "peers", "}", "\n", "}" ]

[ "NewMockSelectionService", "returns", "mock", "selection", "service" ]

[ "func", "(", "m", "*", "MockEndorserServer", ")", "ProcessProposal", "(", "context", "context", ".", "Context", ",", "proposal", "*", "pb", ".", "SignedProposal", ")", "(", "*", "pb", ".", "ProposalResponse", ",", "error", ")", "{", "if", "m", ".", "ProposalError", "==", "nil", "{", "return", "&", "pb", ".", "ProposalResponse", "{", "Response", ":", "&", "pb", ".", "Response", "{", "Status", ":", "200", ",", "}", ",", "Endorsement", ":", "&", "pb", ".", "Endorsement", "{", "Endorser", ":", "[", "]", "byte", "(", "\"", "\"", ")", ",", "Signature", ":", "[", "]", "byte", "(", "\"", "\"", ")", "}", ",", "Payload", ":", "m", ".", "createProposalResponsePayload", "(", ")", "}", ",", "nil", "\n", "}", "\n", "return", "&", "pb", ".", "ProposalResponse", "{", "Response", ":", "&", "pb", ".", "Response", "{", "Status", ":", "500", ",", "Message", ":", "m", ".", "ProposalError", ".", "Error", "(", ")", ",", "}", "}", ",", "m", ".", "ProposalError", "\n", "}" ]

[ "ProcessProposal", "mock", "implementation", "that", "returns", "success", "if", "error", "is", "not", "set", "error", "if", "it", "is" ]

[ "func", "anyNil", "(", "objs", "...", "interface", "{", "}", ")", "bool", "{", "for", "_", ",", "p", ":=", "range", "objs", "{", "if", "p", "==", "nil", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "will", "verify", "if", "any", "of", "objs", "element", "is", "nil", "also", "needed", "to", "avoid", "meta", "-", "linter", "errors" ]

[ "func", "Initialize", "(", "l", "api", ".", "LoggerProvider", ")", "{", "loggerProviderOnce", ".", "Do", "(", "func", "(", ")", "{", "loggerProviderInstance", "=", "l", "\n", "logger", ":=", "loggerProviderInstance", ".", "GetLogger", "(", "loggerModule", ")", "\n", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// TODO", "// use custom leveler implementation (otherwise fallback to default)", "//\t\tlevelerProvider, ok := loggingProvider.(apilogging.Leveler)", "//\t\tif !ok {", "//\t\t}", "}", ")", "\n", "}" ]

[ "Initialize", "sets", "new", "logger", "which", "takes", "over", "logging", "operations", ".", "It", "is", "required", "to", "call", "this", "function", "before", "making", "any", "loggings", "." ]

[ "func", "(", "l", "*", "Logger", ")", "Fatalf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "l", ".", "logger", "(", ")", ".", "Fatalf", "(", "format", ",", "args", "...", ")", "\n", "}" ]

[ "Fatalf", "calls", "Fatalf", "function", "of", "underlying", "logger" ]

[ "func", "(", "l", "*", "Logger", ")", "Panicf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "l", ".", "logger", "(", ")", ".", "Panicf", "(", "format", ",", "args", "...", ")", "\n", "}" ]

[ "Panicf", "calls", "Panicf", "function", "of", "underlying", "logger" ]

[ "func", "(", "l", "*", "Logger", ")", "Printf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "l", ".", "logger", "(", ")", ".", "Printf", "(", "format", ",", "args", "...", ")", "\n", "}" ]

[ "Printf", "calls", "Printf", "function", "of", "underlying", "logger" ]

[ "func", "(", "l", "*", "Logger", ")", "Debugf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "l", ".", "logger", "(", ")", ".", "Debugf", "(", "format", ",", "args", "...", ")", "\n", "}" ]

[ "Debugf", "calls", "Debugf", "function", "of", "underlying", "logger" ]

[ "func", "(", "l", "*", "Logger", ")", "Infof", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "l", ".", "logger", "(", ")", ".", "Infof", "(", "format", ",", "args", "...", ")", "\n", "}" ]

[ "Infof", "calls", "Infof", "function", "of", "underlying", "logger" ]

[ "func", "(", "l", "*", "Logger", ")", "Warnf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "l", ".", "logger", "(", ")", ".", "Warnf", "(", "format", ",", "args", "...", ")", "\n", "}" ]

[ "Warnf", "calls", "Warnf", "function", "of", "underlying", "logger" ]

[ "func", "(", "l", "*", "Logger", ")", "Errorf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "l", ".", "logger", "(", ")", ".", "Errorf", "(", "format", ",", "args", "...", ")", "\n", "}" ]

[ "Errorf", "calls", "Errorf", "function", "of", "underlying", "logger" ]

[ "func", "ParseLevel", "(", "level", "string", ")", "(", "api", ".", "Level", ",", "error", ")", "{", "for", "i", ",", "name", ":=", "range", "levelNames", "{", "if", "strings", ".", "EqualFold", "(", "name", ",", "level", ")", "{", "return", "api", ".", "Level", "(", "i", ")", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "api", ".", "ERROR", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "ParseLevel", "returns", "the", "log", "level", "from", "a", "string", "representation", "." ]

[ "func", "Random", "(", ")", "Balancer", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "func", "(", "peers", "[", "]", "fab", ".", "Peer", ")", "[", "]", "fab", ".", "Peer", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "len", "(", "peers", ")", ")", "\n\n", "balancedPeers", ":=", "make", "(", "[", "]", "fab", ".", "Peer", ",", "len", "(", "peers", ")", ")", "\n", "for", "i", ",", "index", ":=", "range", "rand", ".", "Perm", "(", "len", "(", "peers", ")", ")", "{", "balancedPeers", "[", "i", "]", "=", "peers", "[", "index", "]", "\n", "}", "\n", "return", "balancedPeers", "\n", "}", "\n", "}" ]

[ "Random", "balances", "peers", "randomly" ]

[ "func", "RoundRobin", "(", ")", "Balancer", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "counter", ":=", "rollingcounter", ".", "New", "(", ")", "\n", "return", "func", "(", "peers", "[", "]", "fab", ".", "Peer", ")", "[", "]", "fab", ".", "Peer", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "len", "(", "peers", ")", ")", "\n\n", "index", ":=", "counter", ".", "Next", "(", "len", "(", "peers", ")", ")", "\n", "balancedPeers", ":=", "make", "(", "[", "]", "fab", ".", "Peer", ",", "len", "(", "peers", ")", ")", "\n", "j", ":=", "0", "\n", "for", "i", ":=", "index", ";", "i", "<", "len", "(", "peers", ")", ";", "i", "++", "{", "peer", ":=", "peers", "[", "i", "]", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "peer", ".", "URL", "(", ")", ",", "i", ")", "\n", "balancedPeers", "[", "j", "]", "=", "peer", "\n", "j", "++", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "index", ";", "i", "++", "{", "peer", ":=", "peers", "[", "i", "]", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "peer", ".", "URL", "(", ")", ",", "i", ")", "\n", "balancedPeers", "[", "j", "]", "=", "peers", "[", "i", "]", "\n", "j", "++", "\n", "}", "\n\n", "return", "balancedPeers", "\n", "}", "\n", "}" ]

[ "RoundRobin", "balances", "peers", "in", "a", "round", "-", "robin", "fashion" ]

[ "func", "WithUser", "(", "username", "string", ")", "ContextOption", "{", "return", "func", "(", "o", "*", "identityOptions", ")", "error", "{", "o", ".", "username", "=", "username", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithUser", "uses", "the", "named", "user", "to", "load", "the", "identity" ]