Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "ed", "*", "Dispatcher", ")", "ConnectedPeer", "(", ")", "fab", ".", "Peer", "{", "ed", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "ed", ".", "lock", ".", "RUnlock", "(", ")", "\n", "return", "ed", ".", "peer", "\n", "}" ]

[ "ConnectedPeer", "returns", "the", "connected", "peer" ]

[ "func", "(", "m", "*", "MockDiscoveryClient", ")", "Send", "(", "ctx", "reqcontext", ".", "Context", ",", "req", "*", "discclient", ".", "Request", ",", "targets", "...", "fab", ".", "PeerConfig", ")", "(", "[", "]", "fabdiscovery", ".", "Response", ",", "error", ")", "{", "return", "m", ".", "responses", "(", ")", ",", "nil", "\n", "}" ]

[ "Send", "sends", "a", "Discovery", "request" ]

[ "func", "(", "m", "*", "MockDiscoveryClient", ")", "SetResponses", "(", "responses", "...", "MockResponseBuilder", ")", "{", "m", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "m", ".", "resp", "=", "nil", "\n\n", "for", "_", ",", "resp", ":=", "range", "responses", "{", "m", ".", "resp", "=", "append", "(", "m", ".", "resp", ",", "resp", ".", "Build", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "SetResponses", "sets", "the", "responses", "that", "the", "mock", "client", "should", "return", "from", "the", "Send", "function" ]

[ "func", "(", "cr", "*", "channelResponse", ")", "Endorsers", "(", "invocationChain", "discclient", ".", "InvocationChain", ",", "f", "discclient", ".", "Filter", ")", "(", "discclient", ".", "Endorsers", ",", "error", ")", "{", "if", "cr", ".", "err", "!=", "nil", "{", "return", "nil", ",", "cr", ".", "err", "\n", "}", "\n", "return", "f", ".", "Filter", "(", "cr", ".", "peers", ")", ",", "nil", "\n", "}" ]

[ "Endorsers", "returns", "the", "response", "for", "an", "endorser", "query" ]

[ "func", "(", "b", "*", "MockDiscoverEndpointResponse", ")", "Build", "(", ")", "fabdiscovery", ".", "Response", "{", "var", "peers", "discclient", ".", "Endorsers", "\n", "for", "_", ",", "endpoint", ":=", "range", "b", ".", "PeerEndpoints", "{", "peer", ":=", "&", "discclient", ".", "Peer", "{", "MSPID", ":", "endpoint", ".", "MSPID", ",", "AliveMessage", ":", "newAliveMessage", "(", "endpoint", ")", ",", "StateInfoMessage", ":", "newStateInfoMessage", "(", "endpoint", ")", ",", "}", "\n", "peers", "=", "append", "(", "peers", ",", "peer", ")", "\n", "}", "\n", "return", "&", "mockDiscoverResponse", "{", "Response", ":", "&", "response", "{", "peers", ":", "peers", ",", "err", ":", "b", ".", "Error", ",", "}", ",", "target", ":", "b", ".", "Target", ",", "}", "\n", "}" ]

[ "Build", "builds", "a", "mock", "discovery", "response" ]

[ "func", "NewConnection", "(", "opts", "...", "clientmocks", ".", "Opt", ")", "*", "MockConnection", "{", "return", "&", "MockConnection", "{", "MockConnection", ":", "*", "clientmocks", ".", "NewMockConnection", "(", "opts", "...", ")", ",", "}", "\n", "}" ]

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

[ "func", "(", "c", "*", "MockConnection", ")", "Send", "(", "sinfo", "*", "ab", ".", "SeekInfo", ")", "error", "{", "if", "c", ".", "Closed", "(", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "switch", "seek", ":=", "sinfo", ".", "Start", ".", "Type", ".", "(", "type", ")", "{", "case", "*", "ab", ".", "SeekPosition_Specified", ":", "// Deliver all blocks from the given block number", "fromBlock", ":=", "seek", ".", "Specified", ".", "Number", "\n", "c", ".", "Ledger", "(", ")", ".", "SendFrom", "(", "fromBlock", ")", "\n", "case", "*", "ab", ".", "SeekPosition_Oldest", ":", "// Deliver all blocks from the beginning", "c", ".", "Ledger", "(", ")", ".", "SendFrom", "(", "0", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Send", "mockcore", "sending", "seek", "info", "to", "the", "deliver", "server" ]

[ "func", "(", "p11w", "*", "Pkcs11Wrapper", ")", "InitContext", "(", ")", "(", "err", "error", ")", "{", "// check if lib file exists", "if", "_", ",", "err", "=", "os", ".", "Stat", "(", "p11w", ".", "Library", ".", "Path", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "\n", "}", "\n\n", "// try to initialize", "p11w", ".", "Context", "=", "pkcs11", ".", "New", "(", "p11w", ".", "Library", ".", "Path", ")", "\n", "err", "=", "p11w", ".", "Context", ".", "Initialize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "// get library info", "p11w", ".", "Library", ".", "Info", ",", "err", "=", "p11w", ".", "Context", ".", "GetInfo", "(", ")", "\n\n", "return", "\n\n", "}" ]

[ "Initialize", "pkcs11", "context" ]

[ "func", "(", "p11w", "*", "Pkcs11Wrapper", ")", "InitSession", "(", ")", "(", "err", "error", ")", "{", "// Look for provided slot", "slot", ",", "_", ",", "err", ":=", "FindSlotByLabel", "(", "p11w", ".", "Context", ",", "p11w", ".", "SlotLabel", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "// Create session for matching slot", "p11w", ".", "Session", ",", "err", "=", "p11w", ".", "Context", ".", "OpenSession", "(", "slot", ",", "pkcs11", ".", "CKF_SERIAL_SESSION", "|", "pkcs11", ".", "CKF_RW_SESSION", ")", "\n\n", "return", "\n\n", "}" ]

[ "Initialize", "Session", "to", "slot" ]

[ "func", "(", "p11w", "*", "Pkcs11Wrapper", ")", "Login", "(", ")", "(", "err", "error", ")", "{", "err", "=", "p11w", ".", "Context", ".", "Login", "(", "p11w", ".", "Session", ",", "pkcs11", ".", "CKU_USER", ",", "p11w", ".", "SlotPin", ")", "\n\n", "return", "\n", "}" ]

[ "This", "will", "perform", "a", "login" ]

[ "func", "(", "p11w", "*", "Pkcs11Wrapper", ")", "CloseContext", "(", ")", "{", "p11w", ".", "Context", ".", "Logout", "(", "p11w", ".", "Session", ")", "\n", "p11w", ".", "Context", ".", "CloseSession", "(", "p11w", ".", "Session", ")", "\n", "p11w", ".", "Context", ".", "Finalize", "(", ")", "\n", "p11w", ".", "Context", ".", "Destroy", "(", ")", "\n\n", "return", "\n", "}" ]

[ "Perform", "all", "actions", "needed", "to", "close", "Context" ]

[ "func", "(", "p11w", "*", "Pkcs11Wrapper", ")", "FindObjects", "(", "template", "[", "]", "*", "pkcs11", ".", "Attribute", ",", "max", "int", ")", "(", "p11ObjHandlers", "[", "]", "pkcs11", ".", "ObjectHandle", ",", "moreThanMax", "bool", ",", "err", "error", ")", "{", "// start the search for object", "err", "=", "p11w", ".", "Context", ".", "FindObjectsInit", "(", "p11w", ".", "Session", ",", "template", ",", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "// continue the search, get object handlers", "p11ObjHandlers", ",", "moreThanMax", ",", "err", "=", "p11w", ".", "Context", ".", "FindObjects", "(", "p11w", ".", "Session", ",", "max", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "// finishes the search", "err", "=", "p11w", ".", "Context", ".", "FindObjectsFinal", "(", "p11w", ".", "Session", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "This", "should", "return", "a", "list", "of", "object", "handlers", "and", "true", "if", "more", "than", "max" ]

[ "func", "(", "p11w", "*", "Pkcs11Wrapper", ")", "ListObjects", "(", "template", "[", "]", "*", "pkcs11", ".", "Attribute", ",", "max", "int", ")", "{", "// do an object search", "objects", ",", "_", ",", "err", ":=", "p11w", ".", "FindObjects", "(", "template", ",", "max", ")", "\n\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Println", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "// prepare table headers", "table", ":=", "tablewriter", ".", "NewWriter", "(", "os", ".", "Stdout", ")", "\n", "table", ".", "SetHeader", "(", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", ")", "\n", "table", ".", "SetCaption", "(", "true", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "max", ",", "len", "(", "objects", ")", ")", ")", "\n\n", "// populate table data", "for", "i", ",", "k", ":=", "range", "objects", "{", "al", ",", "err", ":=", "p11w", ".", "Context", ".", "GetAttributeValue", "(", "p11w", ".", "Session", ",", "k", ",", "[", "]", "*", "pkcs11", ".", "Attribute", "{", "pkcs11", ".", "NewAttribute", "(", "pkcs11", ".", "CKA_LABEL", ",", "nil", ")", ",", "pkcs11", ".", "NewAttribute", "(", "pkcs11", ".", "CKA_ID", ",", "nil", ")", ",", "pkcs11", ".", "NewAttribute", "(", "pkcs11", ".", "CKA_CLASS", ",", "nil", ")", ",", "}", ",", ")", "\n\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "table", ".", "Append", "(", "[", "]", "string", "{", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "i", "+", "1", ")", ",", "DecodeCKACLASS", "(", "al", "[", "2", "]", ".", "Value", "[", "0", "]", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "al", "[", "0", "]", ".", "Value", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "al", "[", "1", "]", ".", "Value", ")", ",", "}", ",", ")", "\n", "}", "\n\n", "// render table", "table", ".", "Render", "(", ")", "\n\n", "}", "\n", "}" ]

[ "List", "content", "of", "slot" ]

[ "func", "(", "f", "*", "mspFilter", ")", "Accept", "(", "peer", "fab", ".", "Peer", ")", "bool", "{", "return", "peer", ".", "MSPID", "(", ")", "==", "f", ".", "mspID", "\n", "}" ]

[ "Accept", "returns", "true", "if", "this", "peer", "is", "to", "be", "included", "in", "the", "target", "list" ]

[ "func", "New", "(", "ctxProvider", "context", ".", "ClientProvider", ",", "opts", "...", "ClientOption", ")", "(", "*", "Client", ",", "error", ")", "{", "ctx", ",", "err", ":=", "ctxProvider", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "ctx", ".", "Identifier", "(", ")", ".", "MSPID", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "resourceClient", ":=", "&", "Client", "{", "ctx", ":", "ctx", ",", "}", "\n\n", "for", "_", ",", "opt", ":=", "range", "opts", "{", "err1", ":=", "opt", "(", "resourceClient", ")", "\n", "if", "err1", "!=", "nil", "{", "return", "nil", ",", "err1", "\n", "}", "\n", "}", "\n\n", "if", "resourceClient", ".", "localCtxProvider", "==", "nil", "{", "resourceClient", ".", "localCtxProvider", "=", "func", "(", ")", "(", "context", ".", "Local", ",", "error", ")", "{", "return", "contextImpl", ".", "NewLocal", "(", "func", "(", ")", "(", "context", ".", "Client", ",", "error", ")", "{", "return", "resourceClient", ".", "ctx", ",", "nil", "\n", "}", ",", ")", "\n", "}", "\n", "}", "\n\n", "return", "resourceClient", ",", "nil", "\n", "}" ]

[ "New", "returns", "a", "resource", "management", "client", "instance", "." ]

[ "func", "(", "rc", "*", "Client", ")", "getDefaultTargets", "(", "discovery", "fab", ".", "DiscoveryService", ")", "(", "[", "]", "fab", ".", "Peer", ",", "error", ")", "{", "// Default targets are discovery peers", "peers", ",", "err", ":=", "discovery", ".", "GetPeers", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Apply default filter to discovery peers", "targets", ":=", "filterTargets", "(", "peers", ",", "rc", ".", "filter", ")", "\n\n", "return", "targets", ",", "nil", "\n\n", "}" ]

[ "helper", "method", "for", "calculating", "default", "targets" ]

[ "func", "(", "rc", "*", "Client", ")", "isChaincodeInstalled", "(", "reqCtx", "reqContext", ".", "Context", ",", "req", "InstallCCRequest", ",", "peer", "fab", ".", "ProposalProcessor", ",", "retryOpts", "retry", ".", "Opts", ")", "(", "bool", ",", "error", ")", "{", "chaincodeQueryResponse", ",", "err", ":=", "resource", ".", "QueryInstalledChaincodes", "(", "reqCtx", ",", "peer", ",", "resource", ".", "WithRetry", "(", "retryOpts", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "chaincodeQueryResponse", ")", "\n\n", "for", "_", ",", "chaincode", ":=", "range", "chaincodeQueryResponse", ".", "Chaincodes", "{", "if", "chaincode", ".", "Name", "==", "req", ".", "Name", "&&", "chaincode", ".", "Version", "==", "req", ".", "Version", "&&", "chaincode", ".", "Path", "==", "req", ".", "Path", "{", "return", "true", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]

[ "isChaincodeInstalled", "verify", "if", "chaincode", "is", "installed", "on", "peer" ]

[ "func", "(", "rc", "*", "Client", ")", "sendCCProposal", "(", "reqCtx", "reqContext", ".", "Context", ",", "ccProposalType", "chaincodeProposalType", ",", "channelID", "string", ",", "req", "InstantiateCCRequest", ",", "opts", "requestOptions", ")", "(", "fab", ".", "TransactionID", ",", "error", ")", "{", "if", "err", ":=", "checkRequiredCCProposalParams", "(", "channelID", ",", "req", ")", ";", "err", "!=", "nil", "{", "return", "fab", ".", "EmptyTransactionID", ",", "err", "\n", "}", "\n\n", "targets", ",", "err", ":=", "rc", ".", "getCCProposalTargets", "(", "channelID", ",", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fab", ".", "EmptyTransactionID", ",", "err", "\n", "}", "\n", "// Get transactor on the channel to create and send the deploy proposal", "channelService", ",", "err", ":=", "rc", ".", "ctx", ".", "ChannelProvider", "(", ")", ".", "ChannelService", "(", "rc", ".", "ctx", ",", "channelID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fab", ".", "EmptyTransactionID", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "transactor", ",", "err", ":=", "channelService", ".", "Transactor", "(", "reqCtx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fab", ".", "EmptyTransactionID", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// create a transaction proposal for chaincode deployment", "tp", ",", "txnID", ",", "err", ":=", "rc", ".", "createTP", "(", "req", ",", "channelID", ",", "ccProposalType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "txnID", ",", "err", "\n", "}", "\n\n", "// Process and send transaction proposal", "txProposalResponse", ",", "err", ":=", "transactor", ".", "SendTransactionProposal", "(", "tp", ",", "peersToTxnProcessors", "(", "targets", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tp", ".", "TxnID", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Verify signature(s)", "err", "=", "rc", ".", "verifyTPSignature", "(", "channelService", ",", "txProposalResponse", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tp", ".", "TxnID", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "eventService", ",", "err", ":=", "channelService", ".", "EventService", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tp", ".", "TxnID", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// send transaction and check event", "return", "rc", ".", "sendTransactionAndCheckEvent", "(", "eventService", ",", "tp", ",", "txProposalResponse", ",", "transactor", ",", "reqCtx", ")", "\n\n", "}" ]

[ "sendCCProposal", "sends", "proposal", "for", "type", "Instantiate", "Upgrade" ]

[ "func", "(", "rc", "*", "Client", ")", "prepareRequestOpts", "(", "options", "...", "RequestOption", ")", "(", "requestOptions", ",", "error", ")", "{", "opts", ":=", "requestOptions", "{", "}", "\n", "for", "_", ",", "option", ":=", "range", "options", "{", "err", ":=", "option", "(", "rc", ".", "ctx", ",", "&", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "opts", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "opts", ".", "Targets", ")", ">", "0", "&&", "opts", ".", "TargetFilter", "!=", "nil", "{", "return", "opts", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "opts", ",", "nil", "\n", "}" ]

[ "prepareRequestOpts", "prepares", "request", "options" ]

[ "func", "(", "rc", "*", "Client", ")", "resolveTimeouts", "(", "opts", "*", "requestOptions", ")", "{", "if", "opts", ".", "Timeouts", "==", "nil", "{", "opts", ".", "Timeouts", "=", "make", "(", "map", "[", "fab", ".", "TimeoutType", "]", "time", ".", "Duration", ")", "\n", "}", "\n\n", "if", "opts", ".", "Timeouts", "[", "fab", ".", "ResMgmt", "]", "==", "0", "{", "opts", ".", "Timeouts", "[", "fab", ".", "ResMgmt", "]", "=", "rc", ".", "ctx", ".", "EndpointConfig", "(", ")", ".", "Timeout", "(", "fab", ".", "ResMgmt", ")", "\n", "}", "\n\n", "if", "opts", ".", "Timeouts", "[", "fab", ".", "OrdererResponse", "]", "==", "0", "{", "opts", ".", "Timeouts", "[", "fab", ".", "OrdererResponse", "]", "=", "rc", ".", "ctx", ".", "EndpointConfig", "(", ")", ".", "Timeout", "(", "fab", ".", "OrdererResponse", ")", "\n", "}", "\n\n", "if", "opts", ".", "Timeouts", "[", "fab", ".", "PeerResponse", "]", "==", "0", "{", "opts", ".", "Timeouts", "[", "fab", ".", "PeerResponse", "]", "=", "rc", ".", "ctx", ".", "EndpointConfig", "(", ")", ".", "Timeout", "(", "fab", ".", "PeerResponse", ")", "\n", "}", "\n", "}" ]

[ "resolveTimeouts", "sets", "default", "for", "timeouts", "from", "config", "if", "not", "provided", "through", "opts" ]

[ "func", "New", "(", "dispatcher", "Dispatcher", ",", "opts", "...", "options", ".", "Opt", ")", "*", "Service", "{", "params", ":=", "defaultParams", "(", ")", "\n", "options", ".", "Apply", "(", "params", ",", "opts", ")", "\n\n", "return", "&", "Service", "{", "params", ":", "*", "params", ",", "dispatcher", ":", "dispatcher", ",", "}", "\n", "}" ]

[ "New", "returns", "a", "new", "event", "service", "initialized", "with", "the", "given", "Dispatcher" ]

[ "func", "(", "s", "*", "Service", ")", "Stop", "(", ")", "{", "eventch", ",", "err", ":=", "s", ".", "dispatcher", ".", "EventCh", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "errch", ":=", "make", "(", "chan", "error", ")", "\n", "eventch", "<-", "dispatcher", ".", "NewStopEvent", "(", "errch", ")", "\n\n", "select", "{", "case", "err", ":=", "<-", "errch", ":", "if", "err", "!=", "nil", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "case", "<-", "time", ".", "After", "(", "stopTimeout", ")", ":", "logger", ".", "Infof", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "Stop", "stops", "the", "event", "service" ]

[ "func", "(", "s", "*", "Service", ")", "StopAndTransfer", "(", ")", "(", "fab", ".", "EventSnapshot", ",", "error", ")", "{", "eventch", ",", "err", ":=", "s", ".", "dispatcher", ".", "EventCh", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "snapshotch", ":=", "make", "(", "chan", "fab", ".", "EventSnapshot", ")", "\n", "errch", ":=", "make", "(", "chan", "error", ")", "\n", "eventch", "<-", "dispatcher", ".", "NewStopAndTransferEvent", "(", "snapshotch", ",", "errch", ")", "\n\n", "select", "{", "case", "snapshot", ":=", "<-", "snapshotch", ":", "return", "snapshot", ",", "nil", "\n", "case", "err", ":=", "<-", "errch", ":", "logger", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "case", "<-", "time", ".", "After", "(", "stopTimeout", ")", ":", "logger", ".", "Warnf", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "StopAndTransfer", "stops", "the", "event", "service", "and", "transfers", "all", "event", "registrations", "into", "a", "snapshot", "." ]

[ "func", "(", "s", "*", "Service", ")", "Submit", "(", "event", "interface", "{", "}", ")", "error", "{", "defer", "func", "(", ")", "{", "// During shutdown, events may still be produced and we may", "// get a 'send on closed channel' panic. Just log and ignore the error.", "if", "p", ":=", "recover", "(", ")", ";", "p", "!=", "nil", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "p", ")", "\n", "debug", ".", "PrintStack", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "eventch", ",", "err", ":=", "s", ".", "dispatcher", ".", "EventCh", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "eventch", "<-", "event", "\n\n", "return", "nil", "\n", "}" ]

[ "Submit", "submits", "an", "event", "for", "processing" ]

[ "func", "(", "s", "*", "Service", ")", "RegisterFilteredBlockEvent", "(", ")", "(", "fab", ".", "Registration", ",", "<-", "chan", "*", "fab", ".", "FilteredBlockEvent", ",", "error", ")", "{", "eventch", ":=", "make", "(", "chan", "*", "fab", ".", "FilteredBlockEvent", ",", "s", ".", "eventConsumerBufferSize", ")", "\n", "regch", ":=", "make", "(", "chan", "fab", ".", "Registration", ")", "\n", "errch", ":=", "make", "(", "chan", "error", ")", "\n\n", "if", "err", ":=", "s", ".", "Submit", "(", "dispatcher", ".", "NewRegisterFilteredBlockEvent", "(", "eventch", ",", "regch", ",", "errch", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "select", "{", "case", "response", ":=", "<-", "regch", ":", "return", "response", ",", "eventch", ",", "nil", "\n", "case", "err", ":=", "<-", "errch", ":", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "}" ]

[ "RegisterFilteredBlockEvent", "registers", "for", "filtered", "block", "events", ".", "If", "the", "client", "is", "not", "authorized", "to", "receive", "filtered", "block", "events", "then", "an", "error", "is", "returned", "." ]

[ "func", "(", "s", "*", "Service", ")", "RegisterChaincodeEvent", "(", "ccID", ",", "eventFilter", "string", ")", "(", "fab", ".", "Registration", ",", "<-", "chan", "*", "fab", ".", "CCEvent", ",", "error", ")", "{", "if", "ccID", "==", "\"", "\"", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "eventFilter", "==", "\"", "\"", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "eventch", ":=", "make", "(", "chan", "*", "fab", ".", "CCEvent", ",", "s", ".", "eventConsumerBufferSize", ")", "\n", "regch", ":=", "make", "(", "chan", "fab", ".", "Registration", ")", "\n", "errch", ":=", "make", "(", "chan", "error", ")", "\n\n", "if", "err", ":=", "s", ".", "Submit", "(", "dispatcher", ".", "NewRegisterChaincodeEvent", "(", "ccID", ",", "eventFilter", ",", "eventch", ",", "regch", ",", "errch", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "select", "{", "case", "response", ":=", "<-", "regch", ":", "return", "response", ",", "eventch", ",", "nil", "\n", "case", "err", ":=", "<-", "errch", ":", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "}" ]

[ "RegisterChaincodeEvent", "registers", "for", "chaincode", "events", ".", "If", "the", "client", "is", "not", "authorized", "to", "receive", "chaincode", "events", "then", "an", "error", "is", "returned", ".", "-", "ccID", "is", "the", "chaincode", "ID", "for", "which", "events", "are", "to", "be", "received", "-", "eventFilter", "is", "the", "chaincode", "event", "name", "for", "which", "events", "are", "to", "be", "received" ]

[ "func", "(", "s", "*", "Service", ")", "RegisterTxStatusEvent", "(", "txID", "string", ")", "(", "fab", ".", "Registration", ",", "<-", "chan", "*", "fab", ".", "TxStatusEvent", ",", "error", ")", "{", "if", "txID", "==", "\"", "\"", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "eventch", ":=", "make", "(", "chan", "*", "fab", ".", "TxStatusEvent", ",", "s", ".", "eventConsumerBufferSize", ")", "\n", "regch", ":=", "make", "(", "chan", "fab", ".", "Registration", ")", "\n", "errch", ":=", "make", "(", "chan", "error", ")", "\n\n", "if", "err", ":=", "s", ".", "Submit", "(", "dispatcher", ".", "NewRegisterTxStatusEvent", "(", "txID", ",", "eventch", ",", "regch", ",", "errch", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "select", "{", "case", "response", ":=", "<-", "regch", ":", "return", "response", ",", "eventch", ",", "nil", "\n", "case", "err", ":=", "<-", "errch", ":", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "}" ]

[ "RegisterTxStatusEvent", "registers", "for", "transaction", "status", "events", ".", "If", "the", "client", "is", "not", "authorized", "to", "receive", "transaction", "status", "events", "then", "an", "error", "is", "returned", ".", "-", "txID", "is", "the", "transaction", "ID", "for", "which", "events", "are", "to", "be", "received" ]

[ "func", "(", "s", "*", "Service", ")", "Unregister", "(", "reg", "fab", ".", "Registration", ")", "{", "if", "err", ":=", "s", ".", "Submit", "(", "dispatcher", ".", "NewUnregisterEvent", "(", "reg", ")", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "Unregister", "unregisters", "the", "given", "registration", ".", "-", "reg", "is", "the", "registration", "handle", "that", "was", "returned", "from", "one", "of", "the", "RegisterXXX", "functions" ]

[ "func", "(", "p", "*", "BlockProducer", ")", "NewBlock", "(", "channelID", "string", ",", "transactions", "...", "*", "TxInfo", ")", "*", "cb", ".", "Block", "{", "block", ":=", "NewBlock", "(", "channelID", ",", "transactions", "...", ")", "\n", "block", ".", "Header", ".", "Number", "=", "p", ".", "blockNum", "\n", "atomic", ".", "AddUint64", "(", "&", "p", ".", "blockNum", ",", "1", ")", "\n", "return", "block", "\n", "}" ]

[ "NewBlock", "returns", "a", "new", "block" ]

[ "func", "(", "p", "*", "BlockProducer", ")", "NewFilteredBlock", "(", "channelID", "string", ",", "filteredTx", "...", "*", "pb", ".", "FilteredTransaction", ")", "*", "pb", ".", "FilteredBlock", "{", "block", ":=", "NewFilteredBlock", "(", "channelID", ",", "filteredTx", "...", ")", "\n", "block", ".", "Number", "=", "p", ".", "blockNum", "\n", "atomic", ".", "AddUint64", "(", "&", "p", ".", "blockNum", ",", "1", ")", "\n", "return", "block", "\n", "}" ]

[ "NewFilteredBlock", "returns", "a", "new", "filtered", "block" ]

[ "func", "New", "(", "ctx", "Context", ",", "cfg", "fab", ".", "ChannelCfg", ")", "(", "fab", ".", "ChannelMembership", ",", "error", ")", "{", "mspManager", ",", "mspNames", ",", "err", ":=", "createMSPManager", "(", "ctx", ",", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "identityImpl", "{", "mspManager", ":", "mspManager", ",", "msps", ":", "mspNames", "}", ",", "nil", "\n", "}" ]

[ "New", "member", "identity" ]

[ "func", "addCertsToConfig", "(", "config", "fab", ".", "EndpointConfig", ",", "pemCertsList", "[", "]", "[", "]", "byte", ")", "{", "if", "len", "(", "pemCertsList", ")", "==", "0", "{", "return", "\n", "}", "\n\n", "var", "certs", "[", "]", "*", "x509", ".", "Certificate", "\n", "for", "_", ",", "pemCerts", ":=", "range", "pemCertsList", "{", "for", "len", "(", "pemCerts", ")", ">", "0", "{", "var", "block", "*", "pem", ".", "Block", "\n", "block", ",", "pemCerts", "=", "pem", ".", "Decode", "(", "pemCerts", ")", "\n", "if", "block", "==", "nil", "{", "break", "\n", "}", "\n", "if", "block", ".", "Type", "!=", "\"", "\"", "||", "len", "(", "block", ".", "Headers", ")", "!=", "0", "{", "continue", "\n", "}", "\n\n", "cert", ",", "err", ":=", "x509", ".", "ParseCertificate", "(", "block", ".", "Bytes", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "err", "=", "verifier", ".", "ValidateCertificateDates", "(", "cert", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Warn", "(", "\"", "\"", ",", "err", ")", "\n", "continue", "\n", "}", "\n\n", "certs", "=", "append", "(", "certs", ",", "cert", ")", "\n", "}", "\n", "}", "\n\n", "config", ".", "TLSCACertPool", "(", ")", ".", "Add", "(", "certs", "...", ")", "\n", "}" ]

[ "addCertsToConfig", "adds", "cert", "bytes", "to", "config", "TLSCACertPool" ]

[ "func", "(", "m", "*", "MockCommManager", ")", "DialContext", "(", "ctx", "context", ".", "Context", ",", "target", "string", ",", "opts", "...", "grpc", ".", "DialOption", ")", "(", "*", "grpc", ".", "ClientConn", ",", "error", ")", "{", "return", "grpc", ".", "DialContext", "(", "ctx", ",", "target", ",", "opts", "...", ")", "\n", "}" ]

[ "DialContext", "creates", "a", "connection" ]

[ "func", "(", "m", "*", "MockCommManager", ")", "ReleaseConn", "(", "conn", "*", "grpc", ".", "ClientConn", ")", "{", "if", "err", ":=", "conn", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "ReleaseConn", "closes", "the", "connection" ]

[ "func", "NewCCPackage", "(", "chaincodePath", "string", ",", "goPath", "string", ")", "(", "*", "resource", ".", "CCPackage", ",", "error", ")", "{", "if", "chaincodePath", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "projDir", "string", "\n", "gp", ":=", "goPath", "\n", "if", "gp", "==", "\"", "\"", "{", "gp", "=", "defaultGoPath", "(", ")", "\n", "if", "gp", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "gp", ")", "\n", "}", "\n\n", "projDir", "=", "filepath", ".", "Join", "(", "gp", ",", "\"", "\"", ",", "chaincodePath", ")", "\n\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "projDir", ")", "\n\n", "// We generate the tar in two phases: First grab a list of descriptors,", "// and then pack them into an archive. While the two phases aren't", "// strictly necessary yet, they pave the way for the future where we", "// will need to assemble sources from multiple packages", "descriptors", ",", "err", ":=", "findSource", "(", "gp", ",", "projDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "tarBytes", ",", "err", ":=", "generateTarGz", "(", "descriptors", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "ccPkg", ":=", "&", "resource", ".", "CCPackage", "{", "Type", ":", "pb", ".", "ChaincodeSpec_GOLANG", ",", "Code", ":", "tarBytes", "}", "\n\n", "return", "ccPkg", ",", "nil", "\n", "}" ]

[ "NewCCPackage", "creates", "new", "go", "lang", "chaincode", "package" ]

[ "func", "defaultGoPath", "(", ")", "string", "{", "gpDefault", ":=", "build", ".", "Default", ".", "GOPATH", "\n", "gps", ":=", "filepath", ".", "SplitList", "(", "gpDefault", ")", "\n\n", "return", "gps", "[", "0", "]", "\n", "}" ]

[ "defaultGoPath", "returns", "the", "system", "s", "default", "GOPATH", ".", "If", "the", "system", "has", "multiple", "GOPATHs", "then", "the", "first", "is", "used", "." ]

[ "func", "NewMockProducer", "(", "ledger", "Ledger", ")", "*", "MockProducer", "{", "c", ":=", "&", "MockProducer", "{", "rcvch", ":", "make", "(", "chan", "interface", "{", "}", ",", "100", ")", ",", "ledger", ":", "ledger", ",", "}", "\n", "go", "c", ".", "listen", "(", ")", "\n", "ledger", ".", "Register", "(", "c", ".", "rcvch", ")", "\n", "return", "c", "\n", "}" ]

[ "NewMockProducer", "returns", "a", "new", "MockProducer" ]

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

[ "Close", "closes", "the", "event", "producer" ]

[ "func", "(", "c", "*", "MockProducer", ")", "Register", "(", ")", "<-", "chan", "interface", "{", "}", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n\n", "eventch", ":=", "make", "(", "chan", "interface", "{", "}", ")", "\n", "c", ".", "eventChannels", "=", "append", "(", "c", ".", "eventChannels", ",", "eventch", ")", "\n", "return", "eventch", "\n", "}" ]

[ "Register", "registers", "an", "event", "channel" ]

[ "func", "(", "c", "*", "MockProducer", ")", "Unregister", "(", "eventch", "chan", "<-", "interface", "{", "}", ")", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n\n", "for", "i", ",", "e", ":=", "range", "c", ".", "eventChannels", "{", "if", "e", "==", "eventch", "{", "if", "i", "!=", "0", "{", "c", ".", "eventChannels", "=", "c", ".", "eventChannels", "[", "1", ":", "]", "\n", "}", "\n", "c", ".", "eventChannels", "=", "c", ".", "eventChannels", "[", "1", ":", "]", "\n", "close", "(", "eventch", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "Unregister", "unregisters", "an", "event", "channel" ]

[ "func", "New", "(", "config", "fab", ".", "EndpointConfig", ",", "opts", "...", "options", ".", "Opt", ")", "(", "*", "ChannelProvider", ",", "error", ")", "{", "return", "&", "ChannelProvider", "{", "ctxtCaches", ":", "lazycache", ".", "New", "(", "\"", "\"", ",", "func", "(", "key", "lazycache", ".", "Key", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "ck", ":=", "key", ".", "(", "*", "ctxtCacheKey", ")", "\n", "return", "newContextCache", "(", "ck", ".", "context", ",", "opts", ")", ",", "nil", "\n", "}", ",", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "New", "creates", "a", "ChannelProvider", "based", "on", "a", "context" ]

[ "func", "(", "cp", "*", "ChannelProvider", ")", "ChannelService", "(", "ctx", "fab", ".", "ClientContext", ",", "channelID", "string", ")", "(", "fab", ".", "ChannelService", ",", "error", ")", "{", "key", ",", "err", ":=", "newCtxtCacheKey", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "ctxtCache", ",", "err", ":=", "cp", ".", "ctxtCaches", ".", "Get", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "// This should never happen since the creation of a cache never returns an error", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ChannelService", "{", "provider", ":", "cp", ",", "context", ":", "ctx", ",", "channelID", ":", "channelID", ",", "ctxtCache", ":", "ctxtCache", ".", "(", "*", "contextCache", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "ChannelService", "creates", "a", "ChannelService", "for", "an", "identity" ]

[ "func", "(", "cs", "*", "ChannelService", ")", "Config", "(", ")", "(", "fab", ".", "ChannelConfig", ",", "error", ")", "{", "return", "chconfig", ".", "New", "(", "cs", ".", "channelID", ")", "\n", "}" ]

[ "Config", "returns", "the", "Config", "for", "the", "named", "channel" ]

[ "func", "(", "cs", "*", "ChannelService", ")", "EventService", "(", "opts", "...", "options", ".", "Opt", ")", "(", "fab", ".", "EventService", ",", "error", ")", "{", "return", "cs", ".", "ctxtCache", ".", "GetEventService", "(", "cs", ".", "channelID", ",", "opts", "...", ")", "\n", "}" ]

[ "EventService", "returns", "the", "EventService", "." ]

[ "func", "(", "cs", "*", "ChannelService", ")", "Membership", "(", ")", "(", "fab", ".", "ChannelMembership", ",", "error", ")", "{", "return", "cs", ".", "ctxtCache", ".", "GetMembership", "(", "cs", ".", "channelID", ")", "\n", "}" ]

[ "Membership", "returns", "and", "caches", "a", "channel", "member", "identifier", "A", "membership", "reference", "is", "returned", "that", "refreshes", "with", "the", "configured", "interval" ]

[ "func", "(", "cs", "*", "ChannelService", ")", "ChannelConfig", "(", ")", "(", "fab", ".", "ChannelCfg", ",", "error", ")", "{", "return", "cs", ".", "ctxtCache", ".", "GetChannelConfig", "(", "cs", ".", "channelID", ")", "\n", "}" ]

[ "ChannelConfig", "returns", "the", "channel", "config", "for", "this", "channel" ]

[ "func", "(", "cs", "*", "ChannelService", ")", "Transactor", "(", "reqCtx", "reqContext", ".", "Context", ")", "(", "fab", ".", "Transactor", ",", "error", ")", "{", "cfg", ",", "err", ":=", "cs", ".", "ChannelConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "channelImpl", ".", "NewTransactor", "(", "reqCtx", ",", "cfg", ")", "\n", "}" ]

[ "Transactor", "returns", "the", "transactor" ]

[ "func", "(", "cs", "*", "ChannelService", ")", "Discovery", "(", ")", "(", "fab", ".", "DiscoveryService", ",", "error", ")", "{", "return", "cs", ".", "ctxtCache", ".", "GetDiscoveryService", "(", "cs", ".", "channelID", ")", "\n", "}" ]

[ "Discovery", "returns", "a", "DiscoveryService", "for", "the", "given", "channel" ]

[ "func", "(", "cs", "*", "ChannelService", ")", "Selection", "(", ")", "(", "fab", ".", "SelectionService", ",", "error", ")", "{", "return", "cs", ".", "ctxtCache", ".", "GetSelectionService", "(", "cs", ".", "channelID", ")", "\n", "}" ]

[ "Selection", "returns", "a", "SelectionService", "for", "the", "given", "channel" ]

[ "func", "GetPrivateKeyFromCert", "(", "cert", "[", "]", "byte", ",", "cs", "core", ".", "CryptoSuite", ")", "(", "core", ".", "Key", ",", "error", ")", "{", "// get the public key in the right format", "certPubK", ",", "err", ":=", "GetPublicKeyFromCert", "(", "cert", ",", "cs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "certPubK", "==", "nil", "||", "certPubK", ".", "SKI", "(", ")", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Get the key given the SKI value", "key", ",", "err", ":=", "cs", ".", "GetKey", "(", "certPubK", ".", "SKI", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "key", "!=", "nil", "&&", "!", "key", ".", "Private", "(", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "certPubK", ".", "SKI", "(", ")", ")", "\n", "}", "\n\n", "return", "key", ",", "nil", "\n", "}" ]

[ "GetPrivateKeyFromCert", "will", "return", "private", "key", "represented", "by", "SKI", "in", "cert", "s", "public", "key" ]

[ "func", "GetPublicKeyFromCert", "(", "cert", "[", "]", "byte", ",", "cs", "core", ".", "CryptoSuite", ")", "(", "core", ".", "Key", ",", "error", ")", "{", "dcert", ",", "_", ":=", "pem", ".", "Decode", "(", "cert", ")", "\n", "if", "dcert", "==", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "cert", ")", "\n", "}", "\n\n", "x509Cert", ",", "err", ":=", "x509", ".", "ParseCertificate", "(", "dcert", ".", "Bytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// get the public key in the right format", "key", ",", "err", ":=", "cs", ".", "KeyImport", "(", "x509Cert", ",", "factory", ".", "GetX509PublicKeyImportOpts", "(", "true", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "key", ",", "nil", "\n", "}" ]

[ "GetPublicKeyFromCert", "will", "return", "public", "key", "the", "from", "cert" ]

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

[ "NewMockDiscoveryProvider", "returns", "mock", "discovery", "provider" ]

[ "func", "(", "dp", "*", "MockStaticDiscoveryProvider", ")", "CreateLocalDiscoveryService", "(", "mspID", "string", ")", "(", "fab", ".", "DiscoveryService", ",", "error", ")", "{", "return", "&", "MockStaticDiscoveryService", "{", "Error", ":", "dp", ".", "Error", ",", "Peers", ":", "dp", ".", "Peers", "}", ",", "nil", "\n", "}" ]

[ "CreateLocalDiscoveryService", "return", "discovery", "service", "for", "specific", "channel" ]

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

[ "NewMockDiscoveryService", "returns", "mock", "discovery", "service" ]

[ "func", "New", "(", "name", "string", ",", "initializer", "EntryInitializer", ",", "opts", "...", "options", ".", "Opt", ")", "*", "Cache", "{", "return", "NewWithData", "(", "name", ",", "func", "(", "key", "Key", ",", "data", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "initializer", "(", "key", ")", "\n", "}", ",", "opts", "...", ",", ")", "\n", "}" ]

[ "New", "creates", "a", "new", "lazy", "cache", ".", "-", "name", "is", "the", "name", "of", "the", "cache", "and", "is", "only", "used", "for", "debugging", "purpose", "-", "initializer", "is", "invoked", "the", "first", "time", "an", "entry", "is", "being", "cached", "-", "opts", "are", "options", "for", "the", "cache", ".", "If", "any", "lazyref", "option", "is", "passed", "then", "a", "lazy", "reference", "is", "created", "for", "each", "of", "the", "cache", "entries", "to", "hold", "the", "actual", "value", ".", "This", "makes", "it", "possible", "to", "have", "expiring", "values", "and", "values", "that", "proactively", "refresh", "." ]

[ "func", "(", "c", "*", "Cache", ")", "Get", "(", "key", "Key", ",", "data", "...", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "keyStr", ":=", "key", ".", "String", "(", ")", "\n\n", "f", ",", "ok", ":=", "c", ".", "m", ".", "Load", "(", "keyStr", ")", "\n", "if", "ok", "{", "v", ",", "err", ":=", "f", ".", "(", "future", ")", ".", "Get", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "c", ".", "value", "(", "v", ",", "first", "(", "data", ")", ")", "\n", "}", "\n\n", "// The key wasn't found. Attempt to add one.", "newFuture", ":=", "futurevalue", ".", "New", "(", "func", "(", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "closed", ":=", "atomic", ".", "LoadInt32", "(", "&", "c", ".", "closed", ")", ";", "closed", "==", "1", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "name", ")", "\n", "}", "\n", "return", "c", ".", "initializer", "(", "key", ",", "first", "(", "data", ")", ")", "\n", "}", ",", ")", "\n\n", "f", ",", "loaded", ":=", "c", ".", "m", ".", "LoadOrStore", "(", "keyStr", ",", "newFuture", ")", "\n", "if", "loaded", "{", "// Another thread has added the key before us. Return the value.", "v", ",", "err", ":=", "f", ".", "(", "future", ")", ".", "Get", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "c", ".", "value", "(", "v", ",", "first", "(", "data", ")", ")", "\n", "}", "\n\n", "// We added the key. It must be initialized.", "value", ",", "err", ":=", "newFuture", ".", "Initialize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "// Failed. Delete the key.", "logger", ".", "Debugf", "(", "\"", "\"", ",", "c", ".", "name", ",", "keyStr", ",", "err", ")", "\n", "c", ".", "m", ".", "Delete", "(", "keyStr", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "c", ".", "value", "(", "value", ",", "first", "(", "data", ")", ")", "\n", "}" ]

[ "Get", "returns", "the", "value", "for", "the", "given", "key", ".", "If", "the", "key", "doesn", "t", "exist", "then", "the", "initializer", "is", "invoked", "to", "create", "the", "value", "and", "the", "key", "is", "inserted", ".", "If", "the", "initializer", "returns", "an", "error", "then", "the", "key", "is", "removed", "from", "the", "cache", "." ]

[ "func", "(", "c", "*", "Cache", ")", "MustGet", "(", "key", "Key", ")", "interface", "{", "}", "{", "value", ",", "err", ":=", "c", ".", "Get", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n", "return", "value", "\n", "}" ]

[ "MustGet", "returns", "the", "value", "for", "the", "given", "key", ".", "If", "the", "key", "doesn", "t", "exist", "then", "the", "initializer", "is", "invoked", "to", "create", "the", "value", "and", "the", "key", "is", "inserted", ".", "If", "an", "error", "is", "returned", "during", "initialization", "of", "the", "value", "then", "this", "function", "will", "panic", "." ]

[ "func", "useLazyRef", "(", "opts", "...", "options", ".", "Opt", ")", "bool", "{", "chk", ":=", "&", "refOptCheck", "{", "}", "\n", "options", ".", "Apply", "(", "chk", ",", "opts", ")", "\n", "return", "chk", ".", "useRef", "\n", "}" ]

[ "useLazyRef", "returns", "true", "if", "the", "cache", "should", "used", "lazy", "references", "to", "hold", "the", "actual", "value" ]

[ "func", "New", "(", "opts", "Opts", ")", "Handler", "{", "if", "len", "(", "opts", ".", "RetryableCodes", ")", "==", "0", "{", "opts", ".", "RetryableCodes", "=", "DefaultRetryableCodes", "\n", "}", "\n", "return", "&", "impl", "{", "opts", ":", "opts", "}", "\n", "}" ]

[ "New", "retry", "Handler", "with", "the", "given", "opts" ]

[ "func", "WithAttempts", "(", "attempts", "int", ")", "Handler", "{", "opts", ":=", "DefaultOpts", "\n", "opts", ".", "Attempts", "=", "attempts", "\n", "return", "&", "impl", "{", "opts", ":", "opts", "}", "\n", "}" ]

[ "WithAttempts", "new", "retry", "Handler", "with", "given", "attempts", ".", "Other", "opts", "are", "set", "to", "default", "." ]

[ "func", "(", "i", "*", "impl", ")", "backoffPeriod", "(", ")", "time", ".", "Duration", "{", "backoff", ",", "max", ":=", "float64", "(", "i", ".", "opts", ".", "InitialBackoff", ")", ",", "float64", "(", "i", ".", "opts", ".", "MaxBackoff", ")", "\n", "for", "j", ":=", "0", ";", "j", "<", "i", ".", "retries", "&&", "backoff", "<", "max", ";", "j", "++", "{", "backoff", "*=", "i", ".", "opts", ".", "BackoffFactor", "\n", "}", "\n", "if", "backoff", ">", "max", "{", "backoff", "=", "max", "\n", "}", "\n\n", "return", "time", ".", "Duration", "(", "backoff", ")", "\n", "}" ]

[ "backoffPeriod", "calculates", "the", "backoff", "duration", "based", "on", "the", "provided", "opts" ]

[ "func", "(", "i", "*", "impl", ")", "isRetryable", "(", "g", "status", ".", "Group", ",", "c", "int32", ")", "bool", "{", "for", "group", ",", "codes", ":=", "range", "i", ".", "opts", ".", "RetryableCodes", "{", "if", "g", "!=", "group", "{", "continue", "\n", "}", "\n", "for", "_", ",", "code", ":=", "range", "codes", "{", "if", "status", ".", "Code", "(", "c", ")", "==", "code", "{", "return", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isRetryable", "determines", "if", "the", "given", "status", "is", "configured", "to", "be", "retryable" ]

[ "func", "NewConnection", "(", "ctx", "fabcontext", ".", "Client", ",", "url", "string", ",", "opts", "...", "options", ".", "Opt", ")", "(", "*", "GRPCConnection", ",", "error", ")", "{", "if", "url", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "params", ":=", "defaultParams", "(", ")", "\n", "options", ".", "Apply", "(", "params", ",", "opts", ")", "\n\n", "dialOpts", ",", "err", ":=", "newDialOpts", "(", "ctx", ".", "EndpointConfig", "(", ")", ",", "url", ",", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "reqCtx", ",", "cancel", ":=", "context", ".", "NewRequest", "(", "ctx", ",", "context", ".", "WithTimeout", "(", "params", ".", "connectTimeout", ")", ")", "\n", "defer", "cancel", "(", ")", "\n\n", "commManager", ",", "ok", ":=", "context", ".", "RequestCommManager", "(", "reqCtx", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "grpcconn", ",", "err", ":=", "commManager", ".", "DialContext", "(", "reqCtx", ",", "endpoint", ".", "ToAddress", "(", "url", ")", ",", "dialOpts", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "url", ")", "\n", "}", "\n\n", "hash", ",", "err", ":=", "comm", ".", "TLSCertHash", "(", "ctx", ".", "EndpointConfig", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "&", "GRPCConnection", "{", "context", ":", "ctx", ",", "commManager", ":", "commManager", ",", "conn", ":", "grpcconn", ",", "tlsCertHash", ":", "hash", ",", "}", ",", "nil", "\n", "}" ]

[ "NewConnection", "creates", "a", "new", "connection" ]

[ "func", "NewMockLocalContext", "(", "client", "*", "MockContext", ",", "discoveryProvider", "fab", ".", "LocalDiscoveryProvider", ")", "*", "LocalContext", "{", "var", "localDiscovery", "fab", ".", "DiscoveryService", "\n", "if", "discoveryProvider", "!=", "nil", "{", "var", "err", "error", "\n", "localDiscovery", ",", "err", "=", "discoveryProvider", ".", "CreateLocalDiscoveryService", "(", "client", ".", "Identifier", "(", ")", ".", "MSPID", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n\n", "}", "\n\n", "return", "&", "LocalContext", "{", "MockContext", ":", "client", ",", "localDiscovery", ":", "localDiscovery", ",", "}", "\n", "}" ]

[ "NewMockLocalContext", "creates", "new", "mock", "local", "context" ]

[ "func", "(", "lbp", "*", "Random", ")", "Choose", "(", "peers", "[", "]", "fab", ".", "Peer", ")", "(", "fab", ".", "Peer", ",", "error", ")", "{", "if", "len", "(", "peers", ")", "==", "0", "{", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n\n", "index", ":=", "rand", ".", "Intn", "(", "len", "(", "peers", ")", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "index", ")", "\n", "return", "peers", "[", "index", "]", ",", "nil", "\n", "}" ]

[ "Choose", "randomly", "chooses", "a", "peer", "from", "the", "list", "of", "peers" ]

[ "func", "WithIdleExpiration", "(", "value", "time", ".", "Duration", ")", "options", ".", "Opt", "{", "return", "func", "(", "p", "options", ".", "Params", ")", "{", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "setter", ",", "ok", ":=", "p", ".", "(", "idleExpirationSetter", ")", ";", "ok", "{", "setter", ".", "SetIdleExpiration", "(", "value", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "WithIdleExpiration", "sets", "the", "idle", "-", "time", "expiration", "for", "the", "reference", ".", "The", "reference", "is", "expired", "after", "not", "being", "accessed", "for", "the", "given", "duration", "." ]

[ "func", "WithAbsoluteExpiration", "(", "value", "time", ".", "Duration", ")", "options", ".", "Opt", "{", "return", "func", "(", "p", "options", ".", "Params", ")", "{", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "setter", ",", "ok", ":=", "p", ".", "(", "absoluteExpirationSetter", ")", ";", "ok", "{", "setter", ".", "SetAbsoluteExpiration", "(", "value", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "WithAbsoluteExpiration", "sets", "the", "expiration", "time", "for", "the", "reference", ".", "It", "will", "expire", "after", "this", "time", "period", "regardless", "of", "whether", "or", "not", "it", "has", "been", "recently", "accessed", "." ]

[ "func", "WithExpirationProvider", "(", "expirationProvider", "ExpirationProvider", ",", "expiryType", "ExpirationType", ")", "options", ".", "Opt", "{", "return", "func", "(", "p", "options", ".", "Params", ")", "{", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "setter", ",", "ok", ":=", "p", ".", "(", "expirationProviderSetter", ")", ";", "ok", "{", "setter", ".", "SetExpirationProvider", "(", "expirationProvider", ",", "expiryType", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "WithExpirationProvider", "sets", "the", "expiration", "provider", "which", "determines", "the", "expiration", "time", "of", "the", "reference" ]

[ "func", "WithFinalizer", "(", "finalizer", "Finalizer", ")", "options", ".", "Opt", "{", "return", "func", "(", "p", "options", ".", "Params", ")", "{", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "setter", ",", "ok", ":=", "p", ".", "(", "finalizerSetter", ")", ";", "ok", "{", "setter", ".", "SetFinalizer", "(", "finalizer", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "WithFinalizer", "sets", "a", "finalizer", "function", "that", "is", "called", "when", "the", "reference", "is", "closed", "or", "if", "it", "expires" ]

[ "func", "WithRefreshInterval", "(", "initialInit", ",", "refreshPeriod", "time", ".", "Duration", ")", "options", ".", "Opt", "{", "return", "func", "(", "p", "options", ".", "Params", ")", "{", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "setter", ",", "ok", ":=", "p", ".", "(", "refreshIntervalSetter", ")", ";", "ok", "{", "setter", ".", "SetRefreshInterval", "(", "initialInit", ",", "refreshPeriod", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "WithRefreshInterval", "specifies", "that", "the", "reference", "should", "be", "proactively", "refreshed", ".", "Argument", "initialInit", "if", "greater", "than", "or", "equal", "to", "0", "indicates", "that", "the", "reference", "should", "be", "initialized", "after", "this", "duration", ".", "If", "less", "than", "0", "the", "reference", "will", "be", "initialized", "on", "first", "access", ".", "Argument", "refreshPeriod", "is", "the", "period", "at", "which", "the", "reference", "will", "be", "refreshed", ".", "Note", "that", "the", "Finalizer", "will", "not", "be", "invoked", "each", "time", "the", "value", "is", "refreshed", "." ]

[ "func", "SearchPeerConfigFromURL", "(", "cfg", "fab", ".", "EndpointConfig", ",", "url", "string", ")", "(", "*", "fab", ".", "PeerConfig", ",", "error", ")", "{", "peerCfg", ",", "ok", ":=", "cfg", ".", "PeerConfig", "(", "url", ")", "\n\n", "if", "ok", "{", "return", "peerCfg", ",", "nil", "\n", "}", "\n\n", "//If the given url is already parsed URL through entity matcher, then 'cfg.PeerConfig()'", "//may return NoMatchingPeerEntity error. So retry with network peer URLs", "networkPeers", ":=", "cfg", ".", "NetworkPeers", "(", ")", "\n", "for", "_", ",", "peer", ":=", "range", "networkPeers", "{", "if", "peer", ".", "URL", "==", "url", "{", "return", "&", "peer", ".", "PeerConfig", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "url", ")", "\n", "}" ]

[ "SearchPeerConfigFromURL", "searches", "for", "the", "peer", "configuration", "based", "on", "a", "URL", "." ]

[ "func", "MSPID", "(", "cfg", "fab", ".", "EndpointConfig", ",", "org", "string", ")", "(", "string", ",", "bool", ")", "{", "networkConfig", ":=", "cfg", ".", "NetworkConfig", "(", ")", "\n", "//check for nil since any endpointconfig implementation can be passed here", "if", "networkConfig", "==", "nil", "{", "return", "\"", "\"", ",", "false", "\n", "}", "\n", "// viper lowercases all key maps, org is lower case", "mspID", ":=", "networkConfig", ".", "Organizations", "[", "strings", ".", "ToLower", "(", "org", ")", "]", ".", "MSPID", "\n", "if", "mspID", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "false", "\n", "}", "\n\n", "return", "mspID", ",", "true", "\n", "}" ]

[ "MSPID", "returns", "the", "MSP", "ID", "for", "the", "requested", "organization" ]

[ "func", "NewLocalProvider", "(", "config", "fab", ".", "EndpointConfig", ",", "opts", "...", "coptions", ".", "Opt", ")", "*", "LocalProvider", "{", "return", "&", "LocalProvider", "{", "cache", ":", "lazycache", ".", "New", "(", "\"", "\"", ",", "func", "(", "key", "lazycache", ".", "Key", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "newLocalService", "(", "config", ",", "key", ".", "String", "(", ")", ",", "opts", "...", ")", ",", "nil", "\n", "}", ")", ",", "}", "\n", "}" ]

[ "NewLocalProvider", "creates", "a", "new", "local", "dynamic", "discovery", "provider" ]

[ "func", "(", "p", "*", "LocalProvider", ")", "CreateLocalDiscoveryService", "(", "mspID", "string", ")", "(", "fab", ".", "DiscoveryService", ",", "error", ")", "{", "ref", ",", "err", ":=", "p", ".", "cache", ".", "Get", "(", "lazycache", ".", "NewStringKey", "(", "mspID", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "ref", ".", "(", "fab", ".", "DiscoveryService", ")", ",", "nil", "\n", "}" ]

[ "CreateLocalDiscoveryService", "returns", "a", "local", "discovery", "service" ]

[ "func", "FromError", "(", "err", "error", ")", "(", "s", "*", "Status", ",", "ok", "bool", ")", "{", "if", "err", "==", "nil", "{", "return", "&", "Status", "{", "Code", ":", "int32", "(", "OK", ")", "}", ",", "true", "\n", "}", "\n", "if", "s", ",", "ok", ":=", "err", ".", "(", "*", "Status", ")", ";", "ok", "{", "return", "s", ",", "true", "\n", "}", "\n", "unwrappedErr", ":=", "errors", ".", "Cause", "(", "err", ")", "\n", "if", "s", ",", "ok", ":=", "unwrappedErr", ".", "(", "*", "Status", ")", ";", "ok", "{", "return", "s", ",", "true", "\n", "}", "\n", "if", "m", ",", "ok", ":=", "unwrappedErr", ".", "(", "multi", ".", "Errors", ")", ";", "ok", "{", "// Return all of the errors in the details", "var", "errors", "[", "]", "interface", "{", "}", "\n", "for", "_", ",", "err", ":=", "range", "m", "{", "errors", "=", "append", "(", "errors", ",", "err", ")", "\n", "}", "\n", "return", "New", "(", "ClientStatus", ",", "MultipleErrors", ".", "ToInt32", "(", ")", ",", "m", ".", "Error", "(", ")", ",", "errors", ")", ",", "true", "\n", "}", "\n\n", "return", "nil", ",", "false", "\n", "}" ]

[ "FromError", "returns", "a", "Status", "representing", "err", "if", "available", "otherwise", "it", "returns", "nil", "false", "." ]

[ "func", "New", "(", "group", "Group", ",", "code", "int32", ",", "msg", "string", ",", "details", "[", "]", "interface", "{", "}", ")", "*", "Status", "{", "return", "&", "Status", "{", "Group", ":", "group", ",", "Code", ":", "code", ",", "Message", ":", "msg", ",", "Details", ":", "details", "}", "\n", "}" ]

[ "New", "returns", "a", "Status", "with", "the", "given", "parameters" ]

[ "func", "NewFromProposalResponse", "(", "res", "*", "pb", ".", "ProposalResponse", ",", "endorser", "string", ")", "*", "Status", "{", "if", "res", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "details", ":=", "[", "]", "interface", "{", "}", "{", "endorser", ",", "res", ".", "Response", ".", "Payload", "}", "\n\n", "return", "New", "(", "EndorserServerStatus", ",", "res", ".", "Response", ".", "Status", ",", "res", ".", "Response", ".", "Message", ",", "details", ")", "\n", "}" ]

[ "NewFromProposalResponse", "creates", "a", "status", "created", "from", "the", "given", "ProposalResponse" ]

[ "func", "NewFromGRPCStatus", "(", "s", "*", "grpcstatus", ".", "Status", ")", "*", "Status", "{", "if", "s", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "details", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "len", "(", "s", ".", "Proto", "(", ")", ".", "Details", ")", ")", "\n", "for", "i", ",", "detail", ":=", "range", "s", ".", "Proto", "(", ")", ".", "Details", "{", "details", "[", "i", "]", "=", "detail", "\n", "}", "\n\n", "return", "&", "Status", "{", "Group", ":", "GRPCTransportStatus", ",", "Code", ":", "s", ".", "Proto", "(", ")", ".", "Code", ",", "Message", ":", "s", ".", "Message", "(", ")", ",", "Details", ":", "details", "}", "\n", "}" ]

[ "NewFromGRPCStatus", "new", "Status", "from", "gRPC", "status", "response" ]

[ "func", "NewFromExtractedChaincodeError", "(", "code", "int", ",", "message", "string", ")", "*", "Status", "{", "return", "&", "Status", "{", "Group", ":", "ChaincodeStatus", ",", "Code", ":", "int32", "(", "code", ")", ",", "Message", ":", "message", ",", "Details", ":", "nil", "}", "\n", "}" ]

[ "NewFromExtractedChaincodeError", "returns", "Status", "when", "a", "chaincode", "error", "occurs" ]

[ "func", "New", "(", "config", "fab", ".", "EndpointConfig", ")", "*", "InfraProvider", "{", "idleTime", ":=", "config", ".", "Timeout", "(", "fab", ".", "ConnectionIdle", ")", "\n", "sweepTime", ":=", "config", ".", "Timeout", "(", "fab", ".", "CacheSweepInterval", ")", "\n\n", "return", "&", "InfraProvider", "{", "commManager", ":", "comm", ".", "NewCachingConnector", "(", "sweepTime", ",", "idleTime", ")", ",", "}", "\n", "}" ]

[ "New", "creates", "a", "InfraProvider", "enabling", "access", "to", "core", "Fabric", "objects", "and", "functionality", "." ]

[ "func", "NewGroupOfGroups", "(", "groups", "[", "]", "Group", ")", "GroupOfGroups", "{", "items", ":=", "make", "(", "[", "]", "Item", ",", "len", "(", "groups", ")", ")", "\n", "for", "i", ",", "g", ":=", "range", "groups", "{", "items", "[", "i", "]", "=", "g", "\n", "}", "\n", "return", "&", "groupsImpl", "{", "groupImpl", ":", "groupImpl", "{", "Itms", ":", "items", "}", "}", "\n", "}" ]

[ "NewGroupOfGroups", "returns", "a", "new", "group", "of", "groups" ]

[ "func", "NewMSPPeerGroup", "(", "mspID", "string", ",", "peerRetriever", "MSPPeerRetriever", ")", "PeerGroup", "{", "return", "&", "mspPeerGroup", "{", "mspID", ":", "mspID", ",", "peerRetriever", ":", "peerRetriever", ",", "}", "\n", "}" ]

[ "NewMSPPeerGroup", "returns", "a", "new", "MSP", "PeerGroup" ]

[ "func", "asGroupsOrPanic", "(", "items", "[", "]", "Item", ")", "[", "]", "Group", "{", "groups", ":=", "make", "(", "[", "]", "Group", ",", "len", "(", "items", ")", ")", "\n", "for", "i", ",", "item", ":=", "range", "items", "{", "if", "grp", ",", "ok", ":=", "item", ".", "(", "Group", ")", ";", "ok", "{", "groups", "[", "i", "]", "=", "grp", "\n", "}", "else", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "item", ")", ")", ")", "\n", "}", "\n", "}", "\n", "return", "groups", "\n", "}" ]

[ "asGroupsOrPanic", "converts", "the", "given", "array", "of", "Item", "into", "an", "array", "of", "Group", ".", "Each", "of", "the", "given", "items", "in", "the", "array", "must", "also", "be", "a", "Group", "or", "else", "a", "panic", "results", "." ]

[ "func", "(", "c", "*", "CryptoSuite", ")", "KeyGen", "(", "opts", "core", ".", "KeyGenOpts", ")", "(", "k", "core", ".", "Key", ",", "err", "error", ")", "{", "key", ",", "err", ":=", "c", ".", "BCCSP", ".", "KeyGen", "(", "opts", ")", "\n", "return", "GetKey", "(", "key", ")", ",", "err", "\n", "}" ]

[ "KeyGen", "is", "a", "wrapper", "of", "BCCSP", ".", "KeyGen" ]

[ "func", "(", "c", "*", "CryptoSuite", ")", "KeyImport", "(", "raw", "interface", "{", "}", ",", "opts", "core", ".", "KeyImportOpts", ")", "(", "k", "core", ".", "Key", ",", "err", "error", ")", "{", "key", ",", "err", ":=", "c", ".", "BCCSP", ".", "KeyImport", "(", "raw", ",", "opts", ")", "\n", "return", "GetKey", "(", "key", ")", ",", "err", "\n", "}" ]

[ "KeyImport", "is", "a", "wrapper", "of", "BCCSP", ".", "KeyImport" ]

[ "func", "(", "c", "*", "CryptoSuite", ")", "GetKey", "(", "ski", "[", "]", "byte", ")", "(", "k", "core", ".", "Key", ",", "err", "error", ")", "{", "key", ",", "err", ":=", "c", ".", "BCCSP", ".", "GetKey", "(", "ski", ")", "\n", "return", "GetKey", "(", "key", ")", ",", "err", "\n", "}" ]

[ "GetKey", "is", "a", "wrapper", "of", "BCCSP", ".", "GetKey" ]

[ "func", "(", "c", "*", "CryptoSuite", ")", "Hash", "(", "msg", "[", "]", "byte", ",", "opts", "core", ".", "HashOpts", ")", "(", "hash", "[", "]", "byte", ",", "err", "error", ")", "{", "return", "c", ".", "BCCSP", ".", "Hash", "(", "msg", ",", "opts", ")", "\n", "}" ]

[ "Hash", "is", "a", "wrapper", "of", "BCCSP", ".", "Hash" ]

[ "func", "(", "c", "*", "CryptoSuite", ")", "GetHash", "(", "opts", "core", ".", "HashOpts", ")", "(", "h", "hash", ".", "Hash", ",", "err", "error", ")", "{", "return", "c", ".", "BCCSP", ".", "GetHash", "(", "opts", ")", "\n", "}" ]

[ "GetHash", "is", "a", "wrapper", "of", "BCCSP", ".", "GetHash" ]

[ "func", "(", "c", "*", "CryptoSuite", ")", "Sign", "(", "k", "core", ".", "Key", ",", "digest", "[", "]", "byte", ",", "opts", "core", ".", "SignerOpts", ")", "(", "signature", "[", "]", "byte", ",", "err", "error", ")", "{", "return", "c", ".", "BCCSP", ".", "Sign", "(", "k", ".", "(", "*", "key", ")", ".", "key", ",", "digest", ",", "opts", ")", "\n", "}" ]

[ "Sign", "is", "a", "wrapper", "of", "BCCSP", ".", "Sign" ]

[ "func", "(", "c", "*", "CryptoSuite", ")", "Verify", "(", "k", "core", ".", "Key", ",", "signature", ",", "digest", "[", "]", "byte", ",", "opts", "core", ".", "SignerOpts", ")", "(", "valid", "bool", ",", "err", "error", ")", "{", "return", "c", ".", "BCCSP", ".", "Verify", "(", "k", ".", "(", "*", "key", ")", ".", "key", ",", "signature", ",", "digest", ",", "opts", ")", "\n", "}" ]

[ "Verify", "is", "a", "wrapper", "of", "BCCSP", ".", "Verify" ]

[ "func", "NewBlockEvent", "(", "block", "*", "cb", ".", "Block", ",", "sourceURL", "string", ")", "*", "connection", ".", "Event", "{", "return", "connection", ".", "NewEvent", "(", "&", "pb", ".", "DeliverResponse", "{", "Type", ":", "&", "pb", ".", "DeliverResponse_Block", "{", "Block", ":", "block", ",", "}", ",", "}", ",", "sourceURL", ",", ")", "\n", "}" ]

[ "NewBlockEvent", "returns", "a", "new", "mock", "block", "event", "initialized", "with", "the", "given", "block" ]

[ "func", "NewFilteredBlockEvent", "(", "fblock", "*", "pb", ".", "FilteredBlock", ",", "sourceURL", "string", ")", "*", "connection", ".", "Event", "{", "return", "connection", ".", "NewEvent", "(", "&", "pb", ".", "DeliverResponse", "{", "Type", ":", "&", "pb", ".", "DeliverResponse_FilteredBlock", "{", "FilteredBlock", ":", "fblock", ",", "}", ",", "}", ",", "sourceURL", ",", ")", "\n", "}" ]

[ "NewFilteredBlockEvent", "returns", "a", "new", "mock", "filtered", "block", "event", "initialized", "with", "the", "given", "filtered", "block" ]

[ "func", "WithTargetFilter", "(", "filter", "fab", ".", "TargetFilter", ")", "Opt", "{", "return", "func", "(", "p", "*", "DiscoveryWrapper", ")", "{", "p", ".", "filter", "=", "filter", "\n", "}", "\n", "}" ]

[ "WithTargetFilter", "applies", "the", "target", "filter", "to", "the", "discovery", "provider" ]

[ "func", "NewEndpointDiscoveryWrapper", "(", "ctx", "context", ".", "Client", ",", "channelID", "string", ",", "target", "fab", ".", "DiscoveryService", ",", "opts", "...", "Opt", ")", "(", "*", "DiscoveryWrapper", ",", "error", ")", "{", "chpeers", ":=", "ctx", ".", "EndpointConfig", "(", ")", ".", "ChannelPeers", "(", "channelID", ")", "\n", "if", "len", "(", "chpeers", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "channelID", ")", "\n", "}", "\n\n", "s", ":=", "&", "DiscoveryWrapper", "{", "DiscoveryService", ":", "target", ",", "chPeers", ":", "chpeers", ",", "ctx", ":", "ctx", ",", "}", "\n\n", "for", "_", ",", "opt", ":=", "range", "opts", "{", "opt", "(", "s", ")", "\n", "}", "\n\n", "if", "s", ".", "filter", "!=", "nil", "{", "s", ".", "DiscoveryService", "=", "discovery", ".", "NewDiscoveryFilterService", "(", "target", ",", "s", ".", "filter", ")", "\n", "}", "\n\n", "return", "s", ",", "nil", "\n", "}" ]

[ "NewEndpointDiscoveryWrapper", "returns", "a", "new", "event", "endpoint", "discovery", "service", "that", "wraps", "a", "given", "target", "discovery", "service", "and", "adds", "endpoint", "data", "to", "each", "of", "the", "discovered", "peers", "." ]

[ "func", "(", "s", "*", "DiscoveryWrapper", ")", "GetPeers", "(", ")", "(", "[", "]", "fab", ".", "Peer", ",", "error", ")", "{", "var", "eventEndpoints", "[", "]", "fab", ".", "Peer", "\n\n", "peers", ",", "err", ":=", "s", ".", "DiscoveryService", ".", "GetPeers", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "peer", ":=", "range", "peers", "{", "var", "peerConfig", "*", "fab", ".", "PeerConfig", "\n", "var", "found", "bool", "\n\n", "chPeer", ":=", "s", ".", "getChannelPeer", "(", "peer", ".", "URL", "(", ")", ")", "\n", "if", "chPeer", "!=", "nil", "{", "peerConfig", "=", "&", "chPeer", ".", "PeerConfig", "\n", "}", "else", "{", "peerConfig", ",", "found", "=", "s", ".", "ctx", ".", "EndpointConfig", "(", ")", ".", "PeerConfig", "(", "peer", ".", "URL", "(", ")", ")", "\n", "if", "!", "found", "{", "continue", "\n", "}", "\n", "chPeer", "=", "s", ".", "getChannelPeer", "(", "peerConfig", ".", "URL", ")", "\n", "}", "\n\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "peer", ".", "URL", "(", ")", ",", "chPeer", ")", "\n\n", "if", "chPeer", "!=", "nil", "&&", "!", "chPeer", ".", "EventSource", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "peer", ".", "URL", "(", ")", ")", "\n", "continue", "\n", "}", "\n\n", "eventEndpoint", ":=", "FromPeerConfig", "(", "s", ".", "ctx", ".", "EndpointConfig", "(", ")", ",", "peer", ",", "peerConfig", ")", "\n", "eventEndpoints", "=", "append", "(", "eventEndpoints", ",", "eventEndpoint", ")", "\n", "}", "\n\n", "return", "eventEndpoints", ",", "nil", "\n", "}" ]

[ "GetPeers", "returns", "the", "discovered", "peers" ]

[ "func", "NewMockCAClient", "(", "orgName", "string", ",", "cryptoProvider", "core", ".", "CryptoSuite", ")", "(", "api", ".", "CAClient", ",", "error", ")", "{", "mcm", ":=", "MockCAClient", "{", "}", "\n", "return", "&", "mcm", ",", "nil", "\n", "}" ]

[ "NewMockCAClient", "Constructor", "for", "a", "CA", "client", "." ]

[ "func", "(", "mgr", "*", "MockCAClient", ")", "Register", "(", "request", "*", "api", ".", "RegistrationRequest", ")", "(", "string", ",", "error", ")", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Register", "registers", "a", "user", "with", "a", "Fabric", "network" ]

[ "func", "(", "mgr", "*", "MockCAClient", ")", "Revoke", "(", "request", "*", "api", ".", "RevocationRequest", ")", "(", "*", "api", ".", "RevocationResponse", ",", "error", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Revoke", "revokes", "a", "user" ]

[ "func", "(", "mgr", "*", "MockCAClient", ")", "CreateIdentity", "(", "request", "*", "api", ".", "IdentityRequest", ")", "(", "*", "api", ".", "IdentityResponse", ",", "error", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "CreateIdentity", "creates", "an", "identity" ]

[ "func", "(", "mgr", "*", "MockCAClient", ")", "GetIdentity", "(", "id", ",", "caname", "string", ")", "(", "*", "api", ".", "IdentityResponse", ",", "error", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "GetIdentity", "returns", "an", "identity", "by", "id" ]