Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "WithPeerResolver", "(", "value", "peerresolver", ".", "Provider", ")", "options", ".", "Opt", "{", "return", "func", "(", "p", "options", ".", "Params", ")", "{", "if", "setter", ",", "ok", ":=", "p", ".", "(", "peerResolverSetter", ")", ";", "ok", "{", "setter", ".", "SetPeerResolver", "(", "value", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "WithPeerResolver", "sets", "the", "peer", "resolver", "that", "chooses", "the", "peer", "from", "a", "discovered", "list", "of", "peers", "." ]

[ "func", "NewPrincipal", "(", "name", "string", ",", "classification", "mb", ".", "MSPPrincipal_Classification", ")", "(", "*", "mb", ".", "MSPPrincipal", ",", "error", ")", "{", "member1Role", ",", "err", ":=", "proto", ".", "Marshal", "(", "&", "mb", ".", "MSPRole", "{", "Role", ":", "mb", ".", "MSPRole_MEMBER", ",", "MspIdentifier", ":", "name", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "mb", ".", "MSPPrincipal", "{", "PrincipalClassification", ":", "classification", ",", "Principal", ":", "member1Role", "}", ",", "nil", "\n", "}" ]

[ "NewPrincipal", "creates", "a", "new", "MSPPrincipal" ]

[ "func", "NewSignedByPolicy", "(", "index", "int32", ")", "*", "common", ".", "SignaturePolicy", "{", "return", "&", "common", ".", "SignaturePolicy", "{", "Type", ":", "&", "common", ".", "SignaturePolicy_SignedBy", "{", "SignedBy", ":", "index", ",", "}", "}", "\n", "}" ]

[ "NewSignedByPolicy", "creates", "a", "SignaturePolicy", "at", "the", "given", "index" ]

[ "func", "NewNOutOfPolicy", "(", "n", "int32", ",", "signedBy", "...", "*", "common", ".", "SignaturePolicy", ")", "*", "common", ".", "SignaturePolicy", "{", "return", "&", "common", ".", "SignaturePolicy", "{", "Type", ":", "&", "common", ".", "SignaturePolicy_NOutOf_", "{", "NOutOf", ":", "&", "common", ".", "SignaturePolicy_NOutOf", "{", "N", ":", "n", ",", "Rules", ":", "signedBy", ",", "}", "}", "}", "\n", "}" ]

[ "NewNOutOfPolicy", "creates", "an", "NOutOf", "signature", "policy" ]

[ "func", "GetPolicies", "(", "mspIDs", "...", "string", ")", "(", "signedBy", "[", "]", "*", "common", ".", "SignaturePolicy", ",", "identities", "[", "]", "*", "mb", ".", "MSPPrincipal", ",", "err", "error", ")", "{", "for", "i", ",", "mspID", ":=", "range", "mspIDs", "{", "signedBy", "=", "append", "(", "signedBy", ",", "NewSignedByPolicy", "(", "int32", "(", "i", ")", ")", ")", "\n", "principal", ",", "err", ":=", "NewPrincipal", "(", "mspID", ",", "mb", ".", "MSPPrincipal_ROLE", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "identities", "=", "append", "(", "identities", ",", "principal", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "GetPolicies", "creates", "a", "set", "of", "signed", "by", "signature", "policies", "and", "corresponding", "identities", "for", "the", "given", "set", "of", "MSP", "IDs" ]

[ "func", "NewIdentityManager", "(", "orgName", "string", ",", "userStore", "msp", ".", "UserStore", ",", "cryptoSuite", "core", ".", "CryptoSuite", ",", "endpointConfig", "fab", ".", "EndpointConfig", ")", "(", "*", "IdentityManager", ",", "error", ")", "{", "netConfig", ":=", "endpointConfig", ".", "NetworkConfig", "(", ")", "\n", "// viper keys are case insensitive", "orgConfig", ",", "ok", ":=", "netConfig", ".", "Organizations", "[", "strings", ".", "ToLower", "(", "orgName", ")", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "orgConfig", ".", "CryptoPath", "==", "\"", "\"", "&&", "len", "(", "orgConfig", ".", "Users", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "mspPrivKeyStore", "core", ".", "KVStore", "\n", "var", "mspCertStore", "core", ".", "KVStore", "\n\n", "orgCryptoPathTemplate", ":=", "orgConfig", ".", "CryptoPath", "\n", "if", "orgCryptoPathTemplate", "!=", "\"", "\"", "{", "var", "err", "error", "\n", "if", "!", "filepath", ".", "IsAbs", "(", "orgCryptoPathTemplate", ")", "{", "orgCryptoPathTemplate", "=", "filepath", ".", "Join", "(", "endpointConfig", ".", "CryptoConfigPath", "(", ")", ",", "orgCryptoPathTemplate", ")", "\n", "}", "\n", "mspPrivKeyStore", ",", "err", "=", "NewFileKeyStore", "(", "orgCryptoPathTemplate", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "mspCertStore", ",", "err", "=", "NewFileCertStore", "(", "orgCryptoPathTemplate", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "else", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "orgName", ")", "\n", "}", "\n\n", "mgr", ":=", "&", "IdentityManager", "{", "orgName", ":", "orgName", ",", "orgMSPID", ":", "orgConfig", ".", "MSPID", ",", "config", ":", "endpointConfig", ",", "cryptoSuite", ":", "cryptoSuite", ",", "mspPrivKeyStore", ":", "mspPrivKeyStore", ",", "mspCertStore", ":", "mspCertStore", ",", "embeddedUsers", ":", "orgConfig", ".", "Users", ",", "userStore", ":", "userStore", ",", "// CA Client state is created lazily, when (if) needed", "}", "\n", "return", "mgr", ",", "nil", "\n", "}" ]

[ "NewIdentityManager", "creates", "a", "new", "instance", "of", "IdentityManager" ]

[ "func", "NewMockMSPManagerWithError", "(", "msps", "map", "[", "string", "]", "msp", ".", "MSP", ",", "err", "error", ")", "*", "MockMSPManager", "{", "return", "&", "MockMSPManager", "{", "MSPs", ":", "msps", ",", "Err", ":", "err", "}", "\n", "}" ]

[ "NewMockMSPManagerWithError", "mockcore", "msp", "manager" ]

[ "func", "(", "mgr", "*", "MockMSPManager", ")", "GetMSPs", "(", ")", "(", "map", "[", "string", "]", "msp", ".", "MSP", ",", "error", ")", "{", "if", "mgr", ".", "Err", "!=", "nil", "&&", "mgr", ".", "Err", ".", "Error", "(", ")", "==", "\"", "\"", "{", "return", "nil", ",", "mgr", ".", "Err", "\n", "}", "\n\n", "return", "mgr", ".", "MSPs", ",", "nil", "\n", "}" ]

[ "GetMSPs", "Provides", "a", "list", "of", "Membership", "Service", "providers" ]

[ "func", "NewMockIdentityManager", "(", "opts", "...", "UsersOption", ")", "msp", ".", "IdentityManager", "{", "manager", ":=", "MockIdentityManager", "{", "}", "\n\n", "usersOptions", ":=", "UsersOptions", "{", "}", "\n\n", "for", "_", ",", "param", ":=", "range", "opts", "{", "err", ":=", "param", "(", "&", "usersOptions", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n", "}", "\n", "if", "usersOptions", ".", "users", "!=", "nil", "{", "manager", ".", "users", "=", "usersOptions", ".", "users", "\n", "}", "else", "{", "manager", ".", "users", "=", "make", "(", "map", "[", "string", "]", "msp", ".", "SigningIdentity", ")", "\n", "}", "\n\n", "return", "&", "manager", "\n", "}" ]

[ "NewMockIdentityManager", "Constructor", "for", "a", "identity", "manager", "." ]

[ "func", "(", "mgr", "*", "MockIdentityManager", ")", "GetSigningIdentity", "(", "id", "string", ")", "(", "msp", ".", "SigningIdentity", ",", "error", ")", "{", "si", ",", "ok", ":=", "mgr", ".", "users", "[", "id", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "msp", ".", "ErrUserNotFound", "\n", "}", "\n", "return", "si", ",", "nil", "\n", "}" ]

[ "GetSigningIdentity", "will", "return", "an", "identity", "that", "can", "be", "used", "to", "cryptographically", "sign", "an", "object" ]

[ "func", "(", "o", "*", "MockOrderer", ")", "SendBroadcast", "(", "ctx", "reqContext", ".", "Context", ",", "envelope", "*", "fab", ".", "SignedEnvelope", ")", "(", "*", "common", ".", "Status", ",", "error", ")", "{", "// Report this call to the listener", "if", "o", ".", "BroadcastListener", "!=", "nil", "{", "o", ".", "BroadcastQueue", "<-", "envelope", "\n", "}", "\n", "select", "{", "case", "err", ":=", "<-", "o", ".", "BroadcastErrors", ":", "return", "nil", ",", "err", "\n", "default", ":", "return", "nil", ",", "nil", "\n", "}", "\n", "}" ]

[ "SendBroadcast", "accepts", "client", "broadcast", "calls", "and", "reports", "them", "to", "the", "listener", "channel", "Returns", "the", "first", "enqueued", "error", "or", "nil", "if", "there", "are", "no", "enqueued", "errors" ]

[ "func", "NewBlock", "(", "channelID", "string", ",", "transactions", "...", "*", "TxInfo", ")", "*", "cb", ".", "Block", "{", "var", "data", "[", "]", "[", "]", "byte", "\n", "txValidationFlags", ":=", "make", "(", "[", "]", "uint8", ",", "len", "(", "transactions", ")", ")", "\n", "for", "i", ",", "txInfo", ":=", "range", "transactions", "{", "envBytes", ",", "err", ":=", "proto", ".", "Marshal", "(", "newEnvelope", "(", "channelID", ",", "txInfo", ")", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "data", "=", "append", "(", "data", ",", "envBytes", ")", "\n", "txValidationFlags", "[", "i", "]", "=", "uint8", "(", "txInfo", ".", "TxValidationCode", ")", "\n", "}", "\n\n", "blockMetaData", ":=", "make", "(", "[", "]", "[", "]", "byte", ",", "4", ")", "\n", "blockMetaData", "[", "cb", ".", "BlockMetadataIndex_TRANSACTIONS_FILTER", "]", "=", "txValidationFlags", "\n\n", "return", "&", "cb", ".", "Block", "{", "Header", ":", "&", "cb", ".", "BlockHeader", "{", "}", ",", "Metadata", ":", "&", "cb", ".", "BlockMetadata", "{", "Metadata", ":", "blockMetaData", "}", ",", "Data", ":", "&", "cb", ".", "BlockData", "{", "Data", ":", "data", "}", ",", "}", "\n", "}" ]

[ "NewBlock", "returns", "a", "new", "mock", "block", "initialized", "with", "the", "given", "channel" ]

[ "func", "NewTransaction", "(", "txID", "string", ",", "txValidationCode", "pb", ".", "TxValidationCode", ",", "headerType", "cb", ".", "HeaderType", ")", "*", "TxInfo", "{", "return", "&", "TxInfo", "{", "TxID", ":", "txID", ",", "TxValidationCode", ":", "txValidationCode", ",", "HeaderType", ":", "headerType", ",", "}", "\n", "}" ]

[ "NewTransaction", "creates", "a", "new", "transaction" ]

[ "func", "NewTransactionWithCCEvent", "(", "txID", "string", ",", "txValidationCode", "pb", ".", "TxValidationCode", ",", "ccID", "string", ",", "eventName", "string", ",", "payload", "[", "]", "byte", ")", "*", "TxInfo", "{", "return", "&", "TxInfo", "{", "TxID", ":", "txID", ",", "TxValidationCode", ":", "txValidationCode", ",", "ChaincodeID", ":", "ccID", ",", "EventName", ":", "eventName", ",", "Payload", ":", "payload", ",", "HeaderType", ":", "cb", ".", "HeaderType_ENDORSER_TRANSACTION", ",", "}", "\n", "}" ]

[ "NewTransactionWithCCEvent", "creates", "a", "new", "transaction", "with", "the", "given", "chaincode", "event" ]

[ "func", "NewFilteredBlock", "(", "channelID", "string", ",", "filteredTx", "...", "*", "pb", ".", "FilteredTransaction", ")", "*", "pb", ".", "FilteredBlock", "{", "return", "&", "pb", ".", "FilteredBlock", "{", "ChannelId", ":", "channelID", ",", "FilteredTransactions", ":", "filteredTx", ",", "}", "\n", "}" ]

[ "NewFilteredBlock", "returns", "a", "new", "mock", "filtered", "block", "initialized", "with", "the", "given", "channel", "and", "filtered", "transactions" ]

[ "func", "NewFilteredTx", "(", "txID", "string", ",", "txValidationCode", "pb", ".", "TxValidationCode", ")", "*", "pb", ".", "FilteredTransaction", "{", "return", "&", "pb", ".", "FilteredTransaction", "{", "Txid", ":", "txID", ",", "TxValidationCode", ":", "txValidationCode", ",", "}", "\n", "}" ]

[ "NewFilteredTx", "returns", "a", "new", "mock", "filtered", "transaction" ]

[ "func", "NewFilteredTxWithCCEvent", "(", "txID", ",", "ccID", ",", "event", "string", ")", "*", "pb", ".", "FilteredTransaction", "{", "return", "&", "pb", ".", "FilteredTransaction", "{", "Txid", ":", "txID", ",", "Data", ":", "&", "pb", ".", "FilteredTransaction_TransactionActions", "{", "TransactionActions", ":", "&", "pb", ".", "FilteredTransactionActions", "{", "ChaincodeActions", ":", "[", "]", "*", "pb", ".", "FilteredChaincodeAction", "{", "{", "ChaincodeEvent", ":", "&", "pb", ".", "ChaincodeEvent", "{", "ChaincodeId", ":", "ccID", ",", "EventName", ":", "event", ",", "TxId", ":", "txID", ",", "}", ",", "}", ",", "}", ",", "}", ",", "}", ",", "}", "\n", "}" ]

[ "NewFilteredTxWithCCEvent", "returns", "a", "new", "mock", "filtered", "transaction", "with", "the", "given", "chaincode", "event" ]

[ "func", "New", "(", "config", "fab", ".", "EndpointConfig", ",", "opts", "...", "Option", ")", "(", "*", "Orderer", ",", "error", ")", "{", "orderer", ":=", "&", "Orderer", "{", "config", ":", "config", ",", "commManager", ":", "&", "defCommManager", "{", "}", ",", "}", "\n\n", "for", "_", ",", "opt", ":=", "range", "opts", "{", "err", ":=", "opt", "(", "orderer", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "var", "grpcOpts", "[", "]", "grpc", ".", "DialOption", "\n", "if", "orderer", ".", "kap", ".", "Time", ">", "0", "{", "grpcOpts", "=", "append", "(", "grpcOpts", ",", "grpc", ".", "WithKeepaliveParams", "(", "orderer", ".", "kap", ")", ")", "\n", "}", "\n", "grpcOpts", "=", "append", "(", "grpcOpts", ",", "grpc", ".", "WithDefaultCallOptions", "(", "grpc", ".", "WaitForReady", "(", "!", "orderer", ".", "failFast", ")", ")", ")", "\n", "if", "endpoint", ".", "AttemptSecured", "(", "orderer", ".", "url", ",", "orderer", ".", "allowInsecure", ")", "{", "//tls config", "tlsConfig", ",", "err", ":=", "comm", ".", "TLSConfig", "(", "orderer", ".", "tlsCACert", ",", "orderer", ".", "serverName", ",", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "tlsConfig", ".", "VerifyPeerCertificate", "=", "func", "(", "rawCerts", "[", "]", "[", "]", "byte", ",", "verifiedChains", "[", "]", "[", "]", "*", "x509", ".", "Certificate", ")", "error", "{", "return", "verifier", ".", "VerifyPeerCertificate", "(", "rawCerts", ",", "verifiedChains", ")", "\n", "}", "\n\n", "grpcOpts", "=", "append", "(", "grpcOpts", ",", "grpc", ".", "WithTransportCredentials", "(", "credentials", ".", "NewTLS", "(", "tlsConfig", ")", ")", ")", "\n", "}", "else", "{", "grpcOpts", "=", "append", "(", "grpcOpts", ",", "grpc", ".", "WithInsecure", "(", ")", ")", "\n", "}", "\n\n", "grpcOpts", "=", "append", "(", "grpcOpts", ",", "grpc", ".", "WithDefaultCallOptions", "(", "grpc", ".", "MaxCallRecvMsgSize", "(", "maxCallRecvMsgSize", ")", ",", "grpc", ".", "MaxCallSendMsgSize", "(", "maxCallSendMsgSize", ")", ")", ")", "\n\n", "orderer", ".", "dialTimeout", "=", "config", ".", "Timeout", "(", "fab", ".", "OrdererConnection", ")", "\n", "orderer", ".", "url", "=", "endpoint", ".", "ToAddress", "(", "orderer", ".", "url", ")", "\n", "orderer", ".", "grpcDialOption", "=", "grpcOpts", "\n\n", "return", "orderer", ",", "nil", "\n", "}" ]

[ "New", "Returns", "a", "Orderer", "instance" ]

[ "func", "WithURL", "(", "url", "string", ")", "Option", "{", "return", "func", "(", "o", "*", "Orderer", ")", "error", "{", "o", ".", "url", "=", "url", "\n\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithURL", "is", "a", "functional", "option", "for", "the", "orderer", ".", "New", "constructor", "that", "configures", "the", "orderer", "s", "URL", "." ]

[ "func", "WithTLSCert", "(", "tlsCACert", "*", "x509", ".", "Certificate", ")", "Option", "{", "return", "func", "(", "o", "*", "Orderer", ")", "error", "{", "o", ".", "tlsCACert", "=", "tlsCACert", "\n\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithTLSCert", "is", "a", "functional", "option", "for", "the", "orderer", ".", "New", "constructor", "that", "configures", "the", "orderer", "s", "TLS", "certificate" ]

[ "func", "WithServerName", "(", "serverName", "string", ")", "Option", "{", "return", "func", "(", "o", "*", "Orderer", ")", "error", "{", "o", ".", "serverName", "=", "serverName", "\n\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithServerName", "is", "a", "functional", "option", "for", "the", "orderer", ".", "New", "constructor", "that", "configures", "the", "orderer", "s", "server", "name" ]

[ "func", "FromOrdererConfig", "(", "ordererCfg", "*", "fab", ".", "OrdererConfig", ")", "Option", "{", "return", "func", "(", "o", "*", "Orderer", ")", "error", "{", "o", ".", "url", "=", "ordererCfg", ".", "URL", "\n", "o", ".", "tlsCACert", "=", "ordererCfg", ".", "TLSCACert", "\n\n", "if", "ordererCfg", ".", "GRPCOptions", "[", "\"", "\"", "]", "==", "false", "{", "//verify if certificate was expired or not yet valid", "err", ":=", "verifier", ".", "ValidateCertificateDates", "(", "o", ".", "tlsCACert", ")", "\n", "if", "err", "!=", "nil", "{", "//log this error", "logger", ".", "Warn", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "o", ".", "serverName", "=", "getServerNameOverride", "(", "ordererCfg", ")", "\n", "o", ".", "kap", "=", "getKeepAliveOptions", "(", "ordererCfg", ")", "\n", "o", ".", "failFast", "=", "getFailFast", "(", "ordererCfg", ")", "\n", "o", ".", "allowInsecure", "=", "isInsecureConnectionAllowed", "(", "ordererCfg", ")", "\n\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "FromOrdererConfig", "is", "a", "functional", "option", "for", "the", "orderer", ".", "New", "constructor", "that", "configures", "a", "new", "orderer", "from", "a", "apiconfig", ".", "OrdererConfig", "struct" ]

[ "func", "FromOrdererName", "(", "name", "string", ")", "Option", "{", "return", "func", "(", "o", "*", "Orderer", ")", "error", "{", "ordererCfg", ",", "found", ":=", "o", ".", "config", ".", "OrdererConfig", "(", "name", ")", "\n", "if", "!", "found", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n\n", "return", "FromOrdererConfig", "(", "ordererCfg", ")", "(", "o", ")", "\n", "}", "\n", "}" ]

[ "FromOrdererName", "is", "a", "functional", "option", "for", "the", "orderer", ".", "New", "constructor", "that", "obtains", "an", "apiconfig", ".", "OrdererConfig", "by", "name", "from", "the", "apiconfig", ".", "Config", "supplied", "to", "the", "constructor", "and", "then", "constructs", "a", "new", "orderer", "from", "it" ]

[ "func", "(", "o", "*", "Orderer", ")", "SendBroadcast", "(", "ctx", "reqContext", ".", "Context", ",", "envelope", "*", "fab", ".", "SignedEnvelope", ")", "(", "*", "common", ".", "Status", ",", "error", ")", "{", "conn", ",", "err", ":=", "o", ".", "conn", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "rpcStatus", ",", "ok", ":=", "grpcstatus", ".", "FromError", "(", "err", ")", "\n", "if", "ok", "{", "return", "nil", ",", "errors", ".", "WithMessage", "(", "status", ".", "NewFromGRPCStatus", "(", "rpcStatus", ")", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", ",", "status", ".", "New", "(", "status", ".", "OrdererClientStatus", ",", "status", ".", "ConnectionFailed", ".", "ToInt32", "(", ")", ",", "err", ".", "Error", "(", ")", ",", "nil", ")", "\n", "}", "\n", "defer", "o", ".", "releaseConn", "(", "ctx", ",", "conn", ")", "\n\n", "broadcastClient", ",", "err", ":=", "ab", ".", "NewAtomicBroadcastClient", "(", "conn", ")", ".", "Broadcast", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "rpcStatus", ",", "ok", ":=", "grpcstatus", ".", "FromError", "(", "err", ")", "\n", "if", "ok", "{", "err", "=", "status", ".", "NewFromGRPCStatus", "(", "rpcStatus", ")", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "responses", ":=", "make", "(", "chan", "common", ".", "Status", ")", "\n", "errs", ":=", "make", "(", "chan", "error", ",", "1", ")", "\n\n", "go", "broadcastStream", "(", "broadcastClient", ",", "responses", ",", "errs", ")", "\n\n", "err", "=", "broadcastClient", ".", "Send", "(", "&", "common", ".", "Envelope", "{", "Payload", ":", "envelope", ".", "Payload", ",", "Signature", ":", "envelope", ".", "Signature", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", "=", "broadcastClient", ".", "CloseSend", "(", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "wrapStreamStatusRPC", "(", "responses", ",", "errs", ")", "\n", "}" ]

[ "SendBroadcast", "Send", "the", "created", "transaction", "to", "Orderer", "." ]

[ "func", "wrapStreamStatusRPC", "(", "responses", "chan", "common", ".", "Status", ",", "errs", "chan", "error", ")", "(", "*", "common", ".", "Status", ",", "error", ")", "{", "var", "status", "common", ".", "Status", "\n", "var", "err", "multi", ".", "Errors", "\n\n", "read", ":", "for", "{", "select", "{", "case", "s", ",", "ok", ":=", "<-", "responses", ":", "if", "!", "ok", "{", "break", "read", "\n", "}", "\n", "status", "=", "s", "\n", "case", "e", ":=", "<-", "errs", ":", "err", "=", "append", "(", "err", ",", "e", ")", "\n", "}", "\n", "}", "\n\n", "// drain remaining errors.", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "errs", ")", ";", "i", "++", "{", "e", ":=", "<-", "errs", "\n", "err", "=", "append", "(", "err", ",", "e", ")", "\n", "}", "\n\n", "return", "&", "status", ",", "err", ".", "ToError", "(", ")", "\n", "}" ]

[ "wrapStreamStatusRPC", "returns", "the", "last", "response", "and", "err", "and", "blocks", "until", "the", "chan", "is", "closed", "." ]

[ "func", "NewReceived", "(", "numBlock", "NumBlock", ",", "numChaincode", "NumChaincode", ")", "Received", "{", "return", "Received", "{", "NumBlock", ":", "numBlock", ",", "NumChaincode", ":", "numChaincode", "}", "\n", "}" ]

[ "NewReceived", "returns", "a", "new", "Received", "struct" ]

[ "func", "NewLedger", "(", "chName", "string", ")", "(", "*", "Ledger", ",", "error", ")", "{", "l", ":=", "Ledger", "{", "chName", ":", "chName", ",", "}", "\n", "return", "&", "l", ",", "nil", "\n", "}" ]

[ "NewLedger", "constructs", "a", "Ledger", "client", "for", "the", "current", "context", "and", "named", "channel", "." ]

[ "func", "(", "c", "*", "Ledger", ")", "QueryBlockByHash", "(", "reqCtx", "reqContext", ".", "Context", ",", "blockHash", "[", "]", "byte", ",", "targets", "[", "]", "fab", ".", "ProposalProcessor", ",", "verifier", "ResponseVerifier", ")", "(", "[", "]", "*", "common", ".", "Block", ",", "error", ")", "{", "if", "len", "(", "blockHash", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "cir", ":=", "createBlockByHashInvokeRequest", "(", "c", ".", "chName", ",", "blockHash", ")", "\n", "tprs", ",", "errs", ":=", "queryChaincode", "(", "reqCtx", ",", "c", ".", "chName", ",", "cir", ",", "targets", ",", "verifier", ")", "\n\n", "responses", ",", "errors", ":=", "getConfigBlocks", "(", "tprs", ")", "\n", "errs", "=", "multi", ".", "Append", "(", "errs", ",", "errors", ")", "\n\n", "return", "responses", ",", "errs", "\n", "}" ]

[ "QueryBlockByHash", "queries", "the", "ledger", "for", "Block", "by", "block", "hash", ".", "This", "query", "will", "be", "made", "to", "specified", "targets", ".", "Returns", "the", "block", "." ]

[ "func", "(", "c", "*", "Ledger", ")", "QueryBlockByTxID", "(", "reqCtx", "reqContext", ".", "Context", ",", "txID", "fab", ".", "TransactionID", ",", "targets", "[", "]", "fab", ".", "ProposalProcessor", ",", "verifier", "ResponseVerifier", ")", "(", "[", "]", "*", "common", ".", "Block", ",", "error", ")", "{", "if", "txID", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "cir", ":=", "createBlockByTxIDInvokeRequest", "(", "c", ".", "chName", ",", "txID", ")", "\n", "tprs", ",", "errs", ":=", "queryChaincode", "(", "reqCtx", ",", "c", ".", "chName", ",", "cir", ",", "targets", ",", "verifier", ")", "\n\n", "responses", ",", "errors", ":=", "getConfigBlocks", "(", "tprs", ")", "\n", "errs", "=", "multi", ".", "Append", "(", "errs", ",", "errors", ")", "\n\n", "return", "responses", ",", "errs", "\n", "}" ]

[ "QueryBlockByTxID", "returns", "a", "block", "which", "contains", "a", "transaction", "This", "query", "will", "be", "made", "to", "specified", "targets", ".", "Returns", "the", "block", "." ]

[ "func", "(", "c", "*", "Ledger", ")", "QueryTransaction", "(", "reqCtx", "reqContext", ".", "Context", ",", "transactionID", "fab", ".", "TransactionID", ",", "targets", "[", "]", "fab", ".", "ProposalProcessor", ",", "verifier", "ResponseVerifier", ")", "(", "[", "]", "*", "pb", ".", "ProcessedTransaction", ",", "error", ")", "{", "cir", ":=", "createTransactionByIDInvokeRequest", "(", "c", ".", "chName", ",", "transactionID", ")", "\n", "tprs", ",", "errs", ":=", "queryChaincode", "(", "reqCtx", ",", "c", ".", "chName", ",", "cir", ",", "targets", ",", "verifier", ")", "\n\n", "responses", ":=", "[", "]", "*", "pb", ".", "ProcessedTransaction", "{", "}", "\n", "for", "_", ",", "tpr", ":=", "range", "tprs", "{", "r", ",", "err", ":=", "createProcessedTransaction", "(", "tpr", ")", "\n", "if", "err", "!=", "nil", "{", "errs", "=", "multi", ".", "Append", "(", "errs", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", "+", "tpr", ".", "Endorser", ")", ")", "\n", "}", "else", "{", "responses", "=", "append", "(", "responses", ",", "r", ")", "\n", "}", "\n", "}", "\n\n", "return", "responses", ",", "errs", "\n", "}" ]

[ "QueryTransaction", "queries", "the", "ledger", "for", "Transaction", "by", "number", ".", "This", "query", "will", "be", "made", "to", "specified", "targets", ".", "Returns", "the", "ProcessedTransaction", "information", "containing", "the", "transaction", "." ]

[ "func", "(", "c", "*", "Ledger", ")", "QueryInstantiatedChaincodes", "(", "reqCtx", "reqContext", ".", "Context", ",", "targets", "[", "]", "fab", ".", "ProposalProcessor", ",", "verifier", "ResponseVerifier", ")", "(", "[", "]", "*", "pb", ".", "ChaincodeQueryResponse", ",", "error", ")", "{", "cir", ":=", "createChaincodeInvokeRequest", "(", ")", "\n", "tprs", ",", "errs", ":=", "queryChaincode", "(", "reqCtx", ",", "c", ".", "chName", ",", "cir", ",", "targets", ",", "verifier", ")", "\n\n", "responses", ":=", "[", "]", "*", "pb", ".", "ChaincodeQueryResponse", "{", "}", "\n", "for", "_", ",", "tpr", ":=", "range", "tprs", "{", "r", ",", "err", ":=", "createChaincodeQueryResponse", "(", "tpr", ")", "\n", "if", "err", "!=", "nil", "{", "errs", "=", "multi", ".", "Append", "(", "errs", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", "+", "tpr", ".", "Endorser", ")", ")", "\n", "}", "else", "{", "responses", "=", "append", "(", "responses", ",", "r", ")", "\n", "}", "\n", "}", "\n", "return", "responses", ",", "errs", "\n", "}" ]

[ "QueryInstantiatedChaincodes", "queries", "the", "instantiated", "chaincodes", "on", "this", "channel", ".", "This", "query", "will", "be", "made", "to", "specified", "targets", "." ]

[ "func", "(", "c", "*", "Ledger", ")", "QueryCollectionsConfig", "(", "reqCtx", "reqContext", ".", "Context", ",", "chaincodeName", "string", ",", "targets", "[", "]", "fab", ".", "ProposalProcessor", ",", "verifier", "ResponseVerifier", ")", "(", "[", "]", "*", "common", ".", "CollectionConfigPackage", ",", "error", ")", "{", "cir", ":=", "createCollectionsConfigInvokeRequest", "(", "chaincodeName", ")", "\n", "tprs", ",", "errs", ":=", "queryChaincode", "(", "reqCtx", ",", "c", ".", "chName", ",", "cir", ",", "targets", ",", "verifier", ")", "\n\n", "responses", ":=", "[", "]", "*", "common", ".", "CollectionConfigPackage", "{", "}", "\n", "for", "_", ",", "tpr", ":=", "range", "tprs", "{", "r", ",", "err", ":=", "createCollectionsConfigQueryResponse", "(", "tpr", ")", "\n", "if", "err", "!=", "nil", "{", "errs", "=", "multi", ".", "Append", "(", "errs", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", "+", "tpr", ".", "Endorser", ")", ")", "\n", "}", "else", "{", "responses", "=", "append", "(", "responses", ",", "r", ")", "\n", "}", "\n", "}", "\n", "return", "responses", ",", "errs", "\n", "}" ]

[ "QueryCollectionsConfig", "queries", "the", "collections", "config", "for", "a", "chaincode", "on", "this", "channel", "." ]

[ "func", "(", "c", "*", "Ledger", ")", "QueryConfigBlock", "(", "reqCtx", "reqContext", ".", "Context", ",", "targets", "[", "]", "fab", ".", "ProposalProcessor", ",", "verifier", "ResponseVerifier", ")", "(", "*", "common", ".", "Block", ",", "error", ")", "{", "if", "len", "(", "targets", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "cir", ":=", "createConfigBlockInvokeRequest", "(", "c", ".", "chName", ")", "\n", "tprs", ",", "err", ":=", "queryChaincode", "(", "reqCtx", ",", "c", ".", "chName", ",", "cir", ",", "targets", ",", "verifier", ")", "\n", "if", "err", "!=", "nil", "&&", "len", "(", "tprs", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "matchErr", ":=", "verifier", ".", "Match", "(", "tprs", ")", "\n", "if", "matchErr", "!=", "nil", "{", "return", "nil", ",", "matchErr", "\n", "}", "\n\n", "return", "createCommonBlock", "(", "tprs", "[", "0", "]", ")", "\n", "}" ]

[ "QueryConfigBlock", "returns", "the", "current", "configuration", "block", "for", "the", "specified", "channel", ".", "If", "the", "peer", "doesn", "t", "belong", "to", "the", "channel", "return", "error" ]

[ "func", "WithBlockNum", "(", "from", "uint64", ")", "ClientOption", "{", "return", "func", "(", "c", "*", "Client", ")", "error", "{", "c", ".", "fromBlock", "=", "from", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithBlockNum", "indicates", "the", "block", "number", "from", "which", "events", "are", "to", "be", "received", ".", "Only", "deliverclient", "supports", "this" ]

[ "func", "WithSeekType", "(", "seek", "seek", ".", "Type", ")", "ClientOption", "{", "return", "func", "(", "c", "*", "Client", ")", "error", "{", "c", ".", "seekType", "=", "seek", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "WithSeekType", "indicates", "the", "type", "of", "seek", "desired", "-", "newest", "oldest", "or", "from", "given", "block", "Only", "deliverclient", "supports", "this" ]

[ "func", "NewMockStatefulPeer", "(", "name", ",", "url", "string", ",", "opts", "...", "MockPeerOpt", ")", "*", "MockPeer", "{", "p", ":=", "&", "MockPeer", "{", "MockPeer", ":", "fabmocks", ".", "NewMockPeer", "(", "name", ",", "url", ")", ",", "}", "\n", "for", "_", ",", "opt", ":=", "range", "opts", "{", "opt", "(", "p", ")", "\n", "}", "\n", "return", "p", "\n", "}" ]

[ "NewMockStatefulPeer", "returns", "a", "new", "MockPeer", "with", "the", "given", "options" ]

[ "func", "(", "p", "*", "MockPeer", ")", "BlockHeight", "(", ")", "uint64", "{", "p", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "p", ".", "lock", ".", "RUnlock", "(", ")", "\n", "return", "p", ".", "blockHeight", "\n", "}" ]

[ "BlockHeight", "returns", "the", "block", "height" ]

[ "func", "(", "p", "*", "MockPeer", ")", "SetBlockHeight", "(", "blockHeight", "uint64", ")", "{", "p", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "lock", ".", "Unlock", "(", ")", "\n", "p", ".", "blockHeight", "=", "blockHeight", "\n", "}" ]

[ "SetBlockHeight", "sets", "the", "block", "height" ]

[ "func", "New", "(", "channelProvider", "context", ".", "ChannelProvider", ",", "opts", "...", "ClientOption", ")", "(", "*", "Client", ",", "error", ")", "{", "channelContext", ",", "err", ":=", "channelProvider", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "channelContext", ".", "ChannelService", "(", ")", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "membership", ",", "err", ":=", "channelContext", ".", "ChannelService", "(", ")", ".", "Membership", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "ledger", ",", "err", ":=", "channel", ".", "NewLedger", "(", "channelContext", ".", "ChannelID", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "ledgerFilter", ":=", "filter", ".", "NewEndpointFilter", "(", "channelContext", ",", "filter", ".", "LedgerQuery", ")", "\n\n", "discoveryService", ",", "err", ":=", "channelContext", ".", "ChannelService", "(", ")", ".", "Discovery", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Apply filter to discovery service", "discovery", ":=", "discovery", ".", "NewDiscoveryFilterService", "(", "discoveryService", ",", "ledgerFilter", ")", "\n\n", "ledgerClient", ":=", "Client", "{", "ctx", ":", "channelContext", ",", "ledger", ":", "ledger", ",", "verifier", ":", "&", "verifier", ".", "Signature", "{", "Membership", ":", "membership", "}", ",", "discovery", ":", "discovery", ",", "}", "\n\n", "for", "_", ",", "opt", ":=", "range", "opts", "{", "err", ":=", "opt", "(", "&", "ledgerClient", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "// check if target filter was set - if not set the default", "if", "ledgerClient", ".", "filter", "==", "nil", "{", "// Default target filter is based on user msp", "if", "channelContext", ".", "Identifier", "(", ")", ".", "MSPID", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "filter", ":=", "&", "mspFilter", "{", "mspID", ":", "channelContext", ".", "Identifier", "(", ")", ".", "MSPID", "}", "\n", "ledgerClient", ".", "filter", "=", "filter", "\n", "}", "\n\n", "return", "&", "ledgerClient", ",", "nil", "\n", "}" ]

[ "New", "returns", "a", "ledger", "client", "instance", ".", "A", "ledger", "client", "instance", "provides", "a", "handler", "to", "query", "various", "info", "on", "specified", "channel", ".", "An", "application", "that", "requires", "interaction", "with", "multiple", "channels", "should", "create", "a", "separate", "instance", "of", "the", "ledger", "client", "for", "each", "channel", ".", "Ledger", "client", "supports", "specific", "queries", "only", "." ]

[ "func", "(", "c", "*", "Client", ")", "prepareRequestOpts", "(", "options", "...", "RequestOption", ")", "(", "requestOptions", ",", "error", ")", "{", "opts", ":=", "requestOptions", "{", "}", "\n", "for", "_", ",", "option", ":=", "range", "options", "{", "err", ":=", "option", "(", "c", ".", "ctx", ",", "&", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "opts", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "// Set defaults for max targets", "if", "opts", ".", "MaxTargets", "==", "0", "{", "opts", ".", "MaxTargets", "=", "maxTargets", "\n", "}", "\n\n", "// Set defaults for min targets/matches", "if", "opts", ".", "MinTargets", "==", "0", "{", "opts", ".", "MinTargets", "=", "minTargets", "\n", "}", "\n\n", "if", "opts", ".", "MinTargets", ">", "opts", ".", "MaxTargets", "{", "opts", ".", "MaxTargets", "=", "opts", ".", "MinTargets", "\n", "}", "\n\n", "return", "opts", ",", "nil", "\n", "}" ]

[ "prepareRequestOpts", "Reads", "Opts", "from", "Option", "array" ]

[ "func", "newCtxtCacheKey", "(", "ctx", "fab", ".", "ClientContext", ")", "(", "*", "ctxtCacheKey", ",", "error", ")", "{", "identity", ",", "err", ":=", "ctx", ".", "Serialize", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "h", ":=", "sha256", ".", "New", "(", ")", "\n", "if", "_", ",", "err", ":=", "h", ".", "Write", "(", "identity", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "hash", ":=", "h", ".", "Sum", "(", "nil", ")", "\n\n", "return", "&", "ctxtCacheKey", "{", "key", ":", "string", "(", "hash", ")", ",", "context", ":", "ctx", ",", "}", ",", "nil", "\n", "}" ]

[ "newCtxtCacheKey", "returns", "a", "new", "cacheKey" ]

[ "func", "newEventCacheKey", "(", "chConfig", "fab", ".", "ChannelCfg", ",", "opts", "...", "options", ".", "Opt", ")", "(", "*", "eventCacheKey", ",", "error", ")", "{", "params", ":=", "defaultParams", "(", ")", "\n", "options", ".", "Apply", "(", "params", ",", "opts", ")", "\n\n", "h", ":=", "sha256", ".", "New", "(", ")", "\n", "if", "_", ",", "err", ":=", "h", ".", "Write", "(", "[", "]", "byte", "(", "params", ".", "getOptKey", "(", ")", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "hash", ":=", "h", ".", "Sum", "(", "[", "]", "byte", "(", "chConfig", ".", "ID", "(", ")", ")", ")", "\n\n", "return", "&", "eventCacheKey", "{", "channelConfig", ":", "chConfig", ",", "key", ":", "string", "(", "hash", ")", ",", "opts", ":", "opts", ",", "}", ",", "nil", "\n", "}" ]

[ "newEventCacheKey", "returns", "a", "new", "eventCacheKey" ]

[ "func", "(", "c", "*", "MockConfig", ")", "CAConfig", "(", "org", "string", ")", "(", "*", "msp", ".", "CAConfig", ",", "bool", ")", "{", "caConfig", ":=", "msp", ".", "CAConfig", "{", "CAName", ":", "\"", "\"", ",", "}", "\n\n", "return", "&", "caConfig", ",", "true", "\n", "}" ]

[ "CAConfig", "not", "implemented" ]

[ "func", "(", "c", "*", "MockConfig", ")", "Timeout", "(", "arg", "fab", ".", "TimeoutType", ")", "time", ".", "Duration", "{", "return", "time", ".", "Second", "*", "10", "\n", "}" ]

[ "Timeout", "not", "implemented" ]

[ "func", "(", "c", "*", "MockConfig", ")", "PeersConfig", "(", "org", "string", ")", "(", "[", "]", "fab", ".", "PeerConfig", ",", "bool", ")", "{", "return", "nil", ",", "false", "\n", "}" ]

[ "PeersConfig", "Retrieves", "the", "fabric", "peers", "from", "the", "config", "file", "provided" ]

[ "func", "(", "c", "*", "MockConfig", ")", "PeerConfig", "(", "nameOrURL", "string", ")", "(", "*", "fab", ".", "PeerConfig", ",", "bool", ")", "{", "if", "nameOrURL", "==", "\"", "\"", "{", "return", "nil", ",", "false", "\n", "}", "\n", "if", "c", ".", "customPeerCfg", "!=", "nil", "{", "return", "c", ".", "customPeerCfg", ",", "true", "\n", "}", "\n", "cfg", ":=", "fab", ".", "PeerConfig", "{", "URL", ":", "\"", "\"", ",", "}", "\n", "return", "&", "cfg", ",", "true", "\n", "}" ]

[ "PeerConfig", "Retrieves", "a", "specific", "peer", "from", "the", "configuration", "by", "org", "and", "name" ]

[ "func", "(", "c", "*", "MockConfig", ")", "OrderersConfig", "(", ")", "[", "]", "fab", ".", "OrdererConfig", "{", "oConfig", ",", "_", ":=", "c", ".", "OrdererConfig", "(", "\"", "\"", ")", "\n", "return", "[", "]", "fab", ".", "OrdererConfig", "{", "*", "oConfig", "}", "\n", "}" ]

[ "OrderersConfig", "returns", "a", "list", "of", "defined", "orderers" ]

[ "func", "(", "c", "*", "MockConfig", ")", "OrdererConfig", "(", "name", "string", ")", "(", "*", "fab", ".", "OrdererConfig", ",", "bool", ")", "{", "if", "name", "==", "\"", "\"", "{", "return", "nil", ",", "false", "\n", "}", "\n", "if", "c", ".", "customOrdererCfg", "!=", "nil", "{", "return", "c", ".", "customOrdererCfg", ",", "true", "\n", "}", "\n", "oConfig", ":=", "fab", ".", "OrdererConfig", "{", "URL", ":", "\"", "\"", ",", "}", "\n\n", "return", "&", "oConfig", ",", "true", "\n", "}" ]

[ "OrdererConfig", "not", "implemented" ]

[ "func", "(", "c", "*", "MockConfig", ")", "SetCustomChannelConfig", "(", "channelID", "string", ",", "config", "*", "fab", ".", "ChannelEndpointConfig", ")", "{", "if", "c", ".", "chConfig", "==", "nil", "{", "c", ".", "chConfig", "=", "make", "(", "map", "[", "string", "]", "*", "fab", ".", "ChannelEndpointConfig", ")", "\n", "}", "\n", "c", ".", "chConfig", "[", "channelID", "]", "=", "config", "\n", "}" ]

[ "SetCustomChannelConfig", "sets", "the", "config", "for", "the", "given", "channel" ]

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

[ "Lookup", "gets", "the", "Value", "from", "config", "file", "by", "Key" ]

[ "func", "(", "m", "*", "MockBroadcastServer", ")", "Broadcast", "(", "server", "po", ".", "AtomicBroadcast_BroadcastServer", ")", "error", "{", "res", ",", "err", ":=", "server", ".", "Recv", "(", ")", "\n", "if", "err", "==", "io", ".", "EOF", "{", "return", "nil", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "m", ".", "BroadcastError", "!=", "nil", "{", "return", "m", ".", "BroadcastError", "\n", "}", "\n\n", "if", "m", ".", "BroadcastInternalServerError", "{", "return", "server", ".", "Send", "(", "broadcastResponseError", ")", "\n", "}", "\n\n", "if", "m", ".", "BroadcastCustomResponse", "!=", "nil", "{", "return", "server", ".", "Send", "(", "m", ".", "BroadcastCustomResponse", ")", "\n", "}", "\n\n", "err", "=", "server", ".", "Send", "(", "broadcastResponseSuccess", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "m", ".", "mockBlockDelivery", "(", "res", ".", "Payload", ")", "\n", "}" ]

[ "Broadcast", "mock", "broadcast" ]

[ "func", "(", "m", "*", "MockBroadcastServer", ")", "Deliver", "(", "server", "po", ".", "AtomicBroadcast_DeliverServer", ")", "error", "{", "if", "m", ".", "DeliverError", "!=", "nil", "{", "return", "m", ".", "DeliverError", "\n", "}", "\n\n", "if", "m", ".", "DeliverResponse", "!=", "nil", "{", "if", "_", ",", "err", ":=", "server", ".", "Recv", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "server", ".", "SendMsg", "(", "m", ".", "DeliverResponse", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "server", ".", "Recv", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "server", ".", "Send", "(", "TestBlock", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Deliver", "mock", "deliver" ]

[ "func", "(", "m", "*", "MockBroadcastServer", ")", "Start", "(", "address", "string", ")", "string", "{", "if", "m", ".", "srv", "!=", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// pass in TLS creds if present", "if", "m", ".", "Creds", "!=", "nil", "{", "m", ".", "srv", "=", "grpc", ".", "NewServer", "(", "grpc", ".", "Creds", "(", "m", ".", "Creds", ")", ")", "\n", "}", "else", "{", "m", ".", "srv", "=", "grpc", ".", "NewServer", "(", ")", "\n", "}", "\n\n", "lis", ",", "err", ":=", "net", ".", "Listen", "(", "\"", "\"", ",", "address", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n", "addr", ":=", "lis", ".", "Addr", "(", ")", ".", "String", "(", ")", "\n\n", "test", ".", "Logf", "(", "\"", "\"", ",", "addr", ")", "\n", "po", ".", "RegisterAtomicBroadcastServer", "(", "m", ".", "srv", ",", "m", ")", "\n", "m", ".", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "defer", "m", ".", "wg", ".", "Done", "(", ")", "\n", "if", "err", ":=", "m", ".", "srv", ".", "Serve", "(", "lis", ")", ";", "err", "!=", "nil", "{", "test", ".", "Logf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "addr", "\n", "}" ]

[ "Start", "the", "mock", "broadcast", "server" ]

[ "func", "New", "(", "opts", "...", "coptions", ".", "Opt", ")", "options", ".", "PeerSorter", "{", "params", ":=", "defaultParams", "(", ")", "\n", "coptions", ".", "Apply", "(", "params", ",", "opts", ")", "\n\n", "sorter", ":=", "&", "sorter", "{", "params", ":", "params", ",", "}", "\n\n", "return", "func", "(", "peers", "[", "]", "fab", ".", "Peer", ")", "[", "]", "fab", ".", "Peer", "{", "return", "sorter", ".", "Sort", "(", "peers", ")", "\n", "}", "\n", "}" ]

[ "New", "returns", "a", "peer", "sorter", "that", "uses", "block", "height", "and", "the", "provided", "balancer", "to", "sort", "the", "peers", ".", "This", "sorter", "uses", "a", "block", "-", "height", "-", "lag", "-", "threshold", "property", "which", "is", "the", "number", "of", "blocks", "from", "the", "highest", "block", "of", "a", "group", "of", "peers", "that", "a", "peer", "can", "lag", "behind", "and", "still", "be", "considered", "to", "be", "up", "-", "to", "-", "date", ".", "These", "peers", "are", "sorted", "using", "the", "given", "Balancer", ".", "If", "a", "peer", "s", "block", "height", "falls", "behind", "this", "lag", "threshold", "then", "it", "will", "be", "demoted", "to", "a", "lower", "priority", "list", "of", "peers", "which", "will", "be", "sorted", "according", "to", "block", "height", "." ]

[ "func", "(", "f", "*", "sorter", ")", "Sort", "(", "peers", "[", "]", "fab", ".", "Peer", ")", "[", "]", "fab", ".", "Peer", "{", "if", "len", "(", "peers", ")", "<=", "1", "{", "return", "peers", "\n", "}", "\n\n", "if", "f", ".", "blockHeightLagThreshold", "<", "0", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "f", ".", "balancer", "(", "peers", ")", "\n", "}", "\n\n", "maxHeight", ":=", "getMaxBlockHeight", "(", "peers", ")", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "maxHeight", ")", "\n\n", "if", "maxHeight", "<=", "uint64", "(", "f", ".", "blockHeightLagThreshold", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "maxHeight", ",", "f", ".", "blockHeightLagThreshold", ")", "\n", "return", "f", ".", "balancer", "(", "peers", ")", "\n", "}", "\n\n", "cutoffHeight", ":=", "maxHeight", "-", "uint64", "(", "f", ".", "blockHeightLagThreshold", ")", "\n\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "cutoffHeight", ")", "\n\n", "// preferredPeers are all of the peers that have the same priority", "var", "preferredPeers", "[", "]", "fab", ".", "Peer", "\n\n", "// otherPeers are peers that did not make the cutoff", "var", "otherPeers", "[", "]", "fab", ".", "Peer", "\n\n", "for", "_", ",", "p", ":=", "range", "peers", "{", "peerState", ",", "ok", ":=", "p", ".", "(", "fab", ".", "PeerState", ")", "\n", "if", "!", "ok", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "p", ".", "URL", "(", ")", ")", "\n", "preferredPeers", "=", "append", "(", "preferredPeers", ",", "p", ")", "\n", "}", "else", "if", "peerState", ".", "BlockHeight", "(", ")", ">=", "cutoffHeight", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "p", ".", "URL", "(", ")", ",", "peerState", ".", "BlockHeight", "(", ")", ",", "cutoffHeight", ")", "\n", "preferredPeers", "=", "append", "(", "preferredPeers", ",", "p", ")", "\n", "}", "else", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "p", ".", "URL", "(", ")", ",", "peerState", ".", "BlockHeight", "(", ")", ",", "cutoffHeight", ")", "\n", "otherPeers", "=", "append", "(", "otherPeers", ",", "p", ")", "\n", "}", "\n", "}", "\n\n", "// Apply the balancer on the prefferred peers", "preferredPeers", "=", "f", ".", "balancer", "(", "preferredPeers", ")", "\n\n", "// Sort the remaining peers in reverse order of block height", "sort", ".", "Sort", "(", "sort", ".", "Reverse", "(", "&", "peerSorter", "{", "peers", ":", "otherPeers", ",", "}", ")", ")", "\n\n", "return", "append", "(", "preferredPeers", ",", "otherPeers", "...", ")", "\n", "}" ]

[ "Sort", "sorts", "the", "given", "peers", "according", "to", "block", "height", "and", "lag", "threshold", "." ]

[ "func", "(", "dp", "*", "MockStaticDiscoveryProvider", ")", "CreateLocalDiscoveryService", "(", "mspID", "string", ")", "(", "fab", ".", "DiscoveryService", ",", "error", ")", "{", "if", "dp", ".", "customDiscoveryService", "!=", "nil", "{", "return", "dp", ".", "customDiscoveryService", ",", "nil", "\n", "}", "\n\n", "return", "NewMockDiscoveryService", "(", "dp", ".", "Error", ",", "dp", ".", "Peers", "...", ")", ",", "nil", "\n", "}" ]

[ "CreateLocalDiscoveryService", "return", "local", "discovery", "service" ]

[ "func", "(", "ds", "*", "MockStaticDiscoveryService", ")", "GetPeers", "(", ")", "(", "[", "]", "fab", ".", "Peer", ",", "error", ")", "{", "if", "ds", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "ds", ".", "Error", "\n", "}", "\n\n", "if", "ds", ".", "Peers", "==", "nil", "{", "mockPeer", ":=", "MockPeer", "{", "MockName", ":", "\"", "\"", ",", "MockURL", ":", "\"", "\"", ",", "MockRoles", ":", "[", "]", "string", "{", "}", ",", "MockCert", ":", "nil", ",", "MockMSP", ":", "\"", "\"", "}", "\n", "peers", ":=", "make", "(", "[", "]", "fab", ".", "Peer", ",", "0", ")", "\n", "peers", "=", "append", "(", "peers", ",", "&", "mockPeer", ")", "\n", "ds", ".", "Peers", "=", "peers", "\n", "}", "\n\n", "return", "ds", ".", "Peers", ",", "nil", "\n\n", "}" ]

[ "GetPeers", "is", "used", "to", "discover", "eligible", "peers", "for", "chaincode" ]

[ "func", "NewRefCache", "(", "refresh", "time", ".", "Duration", ")", "*", "lazycache", ".", "Cache", "{", "initializer", ":=", "func", "(", "key", "lazycache", ".", "Key", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "ck", ",", "ok", ":=", "key", ".", "(", "CacheKey", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "NewRef", "(", "refresh", ",", "ck", ".", "Context", "(", ")", ",", "ck", ".", "ChConfigRef", "(", ")", ")", ",", "nil", "\n", "}", "\n\n", "return", "lazycache", ".", "New", "(", "\"", "\"", ",", "initializer", ")", "\n", "}" ]

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

[ "func", "(", "sdk", "*", "FabricSDK", ")", "initMetrics", "(", "configs", "*", "configs", ")", "{", "if", "configs", "==", "nil", "{", "return", "\n", "}", "\n", "if", "sdk", ".", "system", "==", "nil", "{", "sdk", ".", "system", "=", "newOperationsSystem", "(", "configs", ")", "\n\n", "err", ":=", "sdk", ".", "system", ".", "Start", "(", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "// for now NewClientMetrics supports channel client. TODO: if other client types require metrics tracking, update this function", "sdk", ".", "clientMetrics", "=", "metrics", ".", "NewClientMetrics", "(", "sdk", ".", "system", ".", "Provider", ")", "\n", "}", "\n", "}" ]

[ "initMetrics", "will", "initialize", "the", "Go", "SDK", "s", "metric", "s", "system", "instance", "to", "allow", "capturing", "metrics", "data", "by", "the", "SDK", "clients", "." ]

[ "func", "NewCachingConnector", "(", "sweepTime", "time", ".", "Duration", ",", "idleTime", "time", ".", "Duration", ")", "*", "CachingConnector", "{", "cc", ":=", "CachingConnector", "{", "conns", ":", "map", "[", "string", "]", "*", "cachedConn", "{", "}", ",", "index", ":", "map", "[", "*", "grpc", ".", "ClientConn", "]", "*", "cachedConn", "{", "}", ",", "janitorDone", ":", "make", "(", "chan", "bool", ",", "1", ")", ",", "janitorClosed", ":", "make", "(", "chan", "bool", ",", "1", ")", ",", "sweepTime", ":", "sweepTime", ",", "idleTime", ":", "idleTime", ",", "}", "\n\n", "// cc.janitorClosed determines if a goroutine needs to be spun up.", "// The janitor is able to shut itself down when it has no connection to monitor.", "// When it shuts itself down, it pushes a value onto janitorClosed. We initialize", "// the go chan with a bootstrap value so that cachingConnector spins up the", "// goroutine on first usage.", "cc", ".", "janitorClosed", "<-", "true", "\n", "return", "&", "cc", "\n", "}" ]

[ "NewCachingConnector", "creates", "a", "GRPC", "connection", "cache", ".", "The", "cache", "is", "governed", "by", "sweepTime", "and", "idleTime", "." ]

[ "func", "(", "cc", "*", "CachingConnector", ")", "Close", "(", ")", "{", "cc", ".", "lock", ".", "RLock", "(", ")", "\n", "// Safety check to see if the connector has been closed. This represents a", "// bug in the calling code, but it's not good to panic here.", "if", "cc", ".", "janitorDone", "==", "nil", "{", "cc", ".", "lock", ".", "RUnlock", "(", ")", "\n", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "cc", ".", "lock", ".", "RUnlock", "(", ")", "\n", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "select", "{", "case", "<-", "cc", ".", "janitorClosed", ":", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "default", ":", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "cc", ".", "janitorDone", "<-", "true", "\n", "cc", ".", "waitgroup", ".", "Wait", "(", ")", "\n", "}", "\n\n", "cc", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "cc", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "if", "len", "(", "cc", ".", "index", ")", ">", "0", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "len", "(", "cc", ".", "index", ")", ")", "\n", "}", "else", "{", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n\n", "cc", ".", "flush", "(", ")", "\n", "close", "(", "cc", ".", "janitorClosed", ")", "\n", "close", "(", "cc", ".", "janitorDone", ")", "\n", "cc", ".", "janitorDone", "=", "nil", "\n", "}" ]

[ "Close", "cleans", "up", "cached", "connections", "." ]

[ "func", "(", "cc", "*", "CachingConnector", ")", "DialContext", "(", "ctx", "context", ".", "Context", ",", "target", "string", ",", "opts", "...", "grpc", ".", "DialOption", ")", "(", "*", "grpc", ".", "ClientConn", ",", "error", ")", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "target", ")", "\n\n", "cc", ".", "lock", ".", "Lock", "(", ")", "\n", "c", ",", "ok", ":=", "cc", ".", "loadConn", "(", "target", ")", "\n", "if", "!", "ok", "{", "createdConn", ",", "err", ":=", "cc", ".", "createConn", "(", "ctx", ",", "target", ",", "opts", "...", ")", "\n", "if", "err", "!=", "nil", "{", "cc", ".", "lock", ".", "Unlock", "(", ")", "\n", "return", "nil", ",", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "c", "=", "createdConn", "\n", "}", "\n\n", "cc", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "if", "err", ":=", "cc", ".", "openConn", "(", "ctx", ",", "c", ")", ";", "err", "!=", "nil", "{", "cc", ".", "lock", ".", "Lock", "(", ")", "\n", "setClosed", "(", "c", ")", "\n", "cc", ".", "lock", ".", "Unlock", "(", ")", "\n", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "target", ")", "\n", "}", "\n", "return", "c", ".", "conn", ",", "nil", "\n", "}" ]

[ "DialContext", "is", "a", "wrapper", "for", "grpc", ".", "DialContext", "where", "connections", "are", "cached", "." ]

[ "func", "(", "cc", "*", "CachingConnector", ")", "ReleaseConn", "(", "conn", "*", "grpc", ".", "ClientConn", ")", "{", "cc", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "cc", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "// Safety check to see if the connector has been closed. This represents a", "// bug in the calling code, but it's not good to panic here.", "if", "cc", ".", "janitorDone", "==", "nil", "{", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n\n", "if", "conn", ".", "GetState", "(", ")", "!=", "connectivity", ".", "Shutdown", "{", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "conn", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}", "\n\n", "cconn", ",", "ok", ":=", "cc", ".", "index", "[", "conn", "]", "\n", "if", "!", "ok", "{", "logger", ".", "Warnf", "(", "\"", "\"", ",", "conn", ")", "\n", "return", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "cconn", ".", "target", ")", "\n\n", "setClosed", "(", "cconn", ")", "\n\n", "cc", ".", "ensureJanitorStarted", "(", ")", "\n", "}" ]

[ "ReleaseConn", "notifies", "the", "cache", "that", "the", "connection", "is", "no", "longer", "in", "use", "." ]

[ "func", "NewSelectAndEndorseHandler", "(", "next", "...", "Handler", ")", "Handler", "{", "return", "&", "SelectAndEndorseHandler", "{", "EndorsementHandler", ":", "NewEndorsementHandler", "(", ")", ",", "next", ":", "getNext", "(", "next", ")", ",", "}", "\n", "}" ]

[ "NewSelectAndEndorseHandler", "returns", "a", "new", "SelectAndEndorseHandler" ]

[ "func", "(", "e", "*", "SelectAndEndorseHandler", ")", "Handle", "(", "requestContext", "*", "RequestContext", ",", "clientContext", "*", "ClientContext", ")", "{", "var", "ccCalls", "[", "]", "*", "fab", ".", "ChaincodeCall", "\n", "targets", ":=", "requestContext", ".", "Opts", ".", "Targets", "\n", "if", "len", "(", "targets", ")", "==", "0", "{", "var", "err", "error", "\n", "ccCalls", ",", "requestContext", ".", "Opts", ".", "Targets", ",", "err", "=", "getEndorsers", "(", "requestContext", ",", "clientContext", ")", "\n", "if", "err", "!=", "nil", "{", "requestContext", ".", "Error", "=", "err", "\n", "return", "\n", "}", "\n", "}", "\n\n", "e", ".", "EndorsementHandler", ".", "Handle", "(", "requestContext", ",", "clientContext", ")", "\n\n", "if", "requestContext", ".", "Error", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "len", "(", "targets", ")", "==", "0", "&&", "len", "(", "requestContext", ".", "Response", ".", "Responses", ")", ">", "0", "{", "additionalEndorsers", ",", "err", ":=", "getAdditionalEndorsers", "(", "requestContext", ",", "clientContext", ",", "ccCalls", ")", "\n", "if", "err", "!=", "nil", "{", "// Log a warning. No need to fail the endorsement. Use the responses collected so far,", "// which may be sufficient to satisfy the chaincode policy.", "logger", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "if", "len", "(", "additionalEndorsers", ")", ">", "0", "{", "requestContext", ".", "Opts", ".", "Targets", "=", "additionalEndorsers", "\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "len", "(", "additionalEndorsers", ")", ")", "\n", "additionalResponses", ",", "err", ":=", "clientContext", ".", "Transactor", ".", "SendTransactionProposal", "(", "requestContext", ".", "Response", ".", "Proposal", ",", "peer", ".", "PeersToTxnProcessors", "(", "additionalEndorsers", ")", ")", "\n", "if", "err", "!=", "nil", "{", "requestContext", ".", "Error", "=", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "// Add the new endorsements to the list of responses", "requestContext", ".", "Response", ".", "Responses", "=", "append", "(", "requestContext", ".", "Response", ".", "Responses", ",", "additionalResponses", "...", ")", "\n", "}", "else", "{", "logger", ".", "Debugf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "e", ".", "next", "!=", "nil", "{", "e", ".", "next", ".", "Handle", "(", "requestContext", ",", "clientContext", ")", "\n", "}", "\n", "}" ]

[ "Handle", "selects", "endorsers", "and", "sends", "proposals", "to", "the", "endorsers" ]

[ "func", "NewChainedCCFilter", "(", "filters", "...", "CCFilter", ")", "CCFilter", "{", "return", "func", "(", "ccID", "string", ")", "bool", "{", "for", "_", ",", "filter", ":=", "range", "filters", "{", "if", "!", "filter", "(", "ccID", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}", "\n", "}" ]

[ "NewChainedCCFilter", "returns", "a", "chaincode", "filter", "that", "chains", "multiple", "filters", "together", ".", "False", "is", "returned", "if", "at", "least", "one", "of", "the", "filters", "in", "the", "chain", "returns", "false", "." ]

[ "func", "getCCCall", "(", "invocChain", "[", "]", "*", "fab", ".", "ChaincodeCall", ",", "ccID", "string", ")", "(", "*", "fab", ".", "ChaincodeCall", ",", "bool", ")", "{", "for", "_", ",", "ccCall", ":=", "range", "invocChain", "{", "if", "ccCall", ".", "ID", "==", "ccID", "{", "return", "ccCall", ",", "true", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "false", "\n", "}" ]

[ "getCC", "returns", "the", "ChaincodeCall", "from", "the", "invocation", "chain", "that", "matches", "the", "chaincode", "ID", "or", "returns", "nil", "if", "the", "ChaincodeCall", "is", "not", "found", "." ]

[ "func", "merge", "(", "c1", "*", "fab", ".", "ChaincodeCall", ",", "c2", "*", "fab", ".", "ChaincodeCall", ")", "(", "*", "fab", ".", "ChaincodeCall", ",", "bool", ")", "{", "c", ":=", "&", "fab", ".", "ChaincodeCall", "{", "ID", ":", "c1", ".", "ID", ",", "Collections", ":", "c1", ".", "Collections", "}", "\n", "merged", ":=", "false", "\n", "for", "_", ",", "coll", ":=", "range", "c2", ".", "Collections", "{", "if", "!", "contains", "(", "c", ".", "Collections", ",", "coll", ")", "{", "c", ".", "Collections", "=", "append", "(", "c", ".", "Collections", ",", "coll", ")", "\n", "merged", "=", "true", "\n", "}", "\n", "}", "\n", "return", "c", ",", "merged", "\n", "}" ]

[ "merge", "merges", "the", "collections", "from", "c1", "and", "c2", "and", "returns", "the", "resulting", "ChaincodeCall", ".", "true", "is", "returned", "if", "a", "merge", "was", "necessary", ";", "false", "is", "returned", "if", "the", "two", "ChaincodeCalls", "were", "the", "same", "." ]

[ "func", "prioritizePeers", "(", "peers", "[", "]", "fab", ".", "Peer", ")", "selectopts", ".", "PrioritySelector", "{", "return", "func", "(", "peer1", ",", "peer2", "fab", ".", "Peer", ")", "int", "{", "hasPeer1", ":=", "containsPeer", "(", "peers", ",", "peer1", ")", "\n", "hasPeer2", ":=", "containsPeer", "(", "peers", ",", "peer2", ")", "\n\n", "if", "hasPeer1", "&&", "hasPeer2", "{", "return", "0", "\n", "}", "\n", "if", "hasPeer1", "{", "return", "1", "\n", "}", "\n", "if", "hasPeer2", "{", "return", "-", "1", "\n", "}", "\n", "return", "0", "\n", "}", "\n", "}" ]

[ "prioritizePeers", "is", "a", "priority", "selector", "that", "gives", "priority", "to", "the", "peers", "that", "are", "in", "the", "given", "set" ]

[ "func", "New", "(", "initializer", "Initializer", ",", "opts", "...", "options", ".", "Opt", ")", "*", "Reference", "{", "return", "NewWithData", "(", "func", "(", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "return", "initializer", "(", ")", "\n", "}", ",", "opts", "...", ")", "\n", "}" ]

[ "New", "creates", "a", "new", "reference" ]

[ "func", "NewWithData", "(", "initializer", "InitializerWithData", ",", "opts", "...", "options", ".", "Opt", ")", "*", "Reference", "{", "lazyRef", ":=", "&", "Reference", "{", "params", ":", "params", "{", "initialInit", ":", "InitOnFirstAccess", ",", "}", ",", "initializer", ":", "initializer", ",", "}", "\n\n", "options", ".", "Apply", "(", "lazyRef", ",", "opts", ")", "\n\n", "if", "lazyRef", ".", "expirationProvider", "!=", "nil", "{", "// This is an expiring reference. After the initializer is", "// called, set a timer that will call the expiration handler.", "initializer", ":=", "lazyRef", ".", "initializer", "\n", "initialExpiration", ":=", "lazyRef", ".", "expirationProvider", "(", ")", "\n", "lazyRef", ".", "initializer", "=", "func", "(", "data", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "value", ",", "err", ":=", "initializer", "(", "data", ")", "\n", "if", "err", "==", "nil", "{", "lazyRef", ".", "ensureTimerStarted", "(", "initialExpiration", ")", "\n", "}", "\n", "return", "value", ",", "err", "\n", "}", "\n\n", "lazyRef", ".", "closech", "=", "make", "(", "chan", "bool", ",", "1", ")", "\n\n", "if", "lazyRef", ".", "expirationHandler", "==", "nil", "{", "if", "lazyRef", ".", "expiryType", "==", "Refreshing", "{", "lazyRef", ".", "expirationHandler", "=", "lazyRef", ".", "refreshValue", "\n", "}", "else", "{", "lazyRef", ".", "expirationHandler", "=", "lazyRef", ".", "resetValue", "\n", "}", "\n", "}", "\n\n", "if", "lazyRef", ".", "initialInit", ">=", "0", "{", "lazyRef", ".", "ensureTimerStarted", "(", "lazyRef", ".", "initialInit", ")", "\n", "}", "\n", "}", "\n\n", "return", "lazyRef", "\n", "}" ]

[ "NewWithData", "creates", "a", "new", "reference", "where", "data", "is", "passed", "from", "the", "Get", "function", "to", "the", "initializer", ".", "This", "is", "useful", "for", "refreshing", "the", "reference", "with", "dynamic", "data", "." ]

[ "func", "(", "r", "*", "Reference", ")", "Get", "(", "data", "...", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "r", ".", "IsClosed", "(", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Try outside of a lock", "if", "value", ",", "ok", ":=", "r", ".", "get", "(", ")", ";", "ok", "{", "return", "value", ",", "nil", "\n", "}", "\n\n", "r", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "// Try again inside the lock", "if", "value", ",", "ok", ":=", "r", ".", "get", "(", ")", ";", "ok", "{", "return", "value", ",", "nil", "\n", "}", "\n\n", "// Value hasn't been set yet", "value", ",", "err", ":=", "r", ".", "initializer", "(", "first", "(", "data", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "r", ".", "set", "(", "value", ")", "\n\n", "return", "value", ",", "nil", "\n", "}" ]

[ "Get", "returns", "the", "value", "or", "an", "error", "if", "the", "initialiser", "returned", "an", "error", "." ]

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

[ "MustGet", "returns", "the", "value", ".", "If", "an", "error", "is", "returned", "during", "initialization", "of", "the", "value", "then", "this", "function", "will", "panic", "." ]

[ "func", "(", "l", "*", "ModuleLevels", ")", "GetLevel", "(", "module", "string", ")", "api", ".", "Level", "{", "level", ",", "exists", ":=", "l", ".", "levels", "[", "module", "]", "\n", "if", "!", "exists", "{", "level", ",", "exists", "=", "l", ".", "levels", "[", "\"", "\"", "]", "\n", "// no configuration exists, default to info", "if", "!", "exists", "{", "level", "=", "api", ".", "INFO", "\n", "}", "\n", "}", "\n", "return", "level", "\n", "}" ]

[ "GetLevel", "returns", "the", "log", "level", "for", "the", "given", "module", "." ]

[ "func", "(", "l", "*", "ModuleLevels", ")", "SetLevel", "(", "module", "string", ",", "level", "api", ".", "Level", ")", "{", "if", "l", ".", "levels", "==", "nil", "{", "l", ".", "levels", "=", "make", "(", "map", "[", "string", "]", "api", ".", "Level", ")", "\n", "}", "\n", "l", ".", "levels", "[", "module", "]", "=", "level", "\n", "}" ]

[ "SetLevel", "sets", "the", "log", "level", "for", "the", "given", "module", "." ]

[ "func", "(", "l", "*", "ModuleLevels", ")", "IsEnabledFor", "(", "module", "string", ",", "level", "api", ".", "Level", ")", "bool", "{", "return", "level", "<=", "l", ".", "GetLevel", "(", "module", ")", "\n", "}" ]

[ "IsEnabledFor", "will", "return", "true", "if", "logging", "is", "enabled", "for", "the", "given", "module", "." ]

[ "func", "NewRef", "(", "ctx", "fab", ".", "ClientContext", ",", "pvdr", "Provider", ",", "channel", "string", ",", "opts", "...", "options", ".", "Opt", ")", "*", "Ref", "{", "params", ":=", "newDefaultParams", "(", ")", "\n", "options", ".", "Apply", "(", "params", ",", "opts", ")", "\n\n", "cfgRef", ":=", "&", "Ref", "{", "pvdr", ":", "pvdr", ",", "ctx", ":", "ctx", ",", "channelID", ":", "channel", ",", "errHandler", ":", "params", ".", "errHandler", ",", "}", "\n\n", "cfgRef", ".", "Reference", "=", "lazyref", ".", "New", "(", "cfgRef", ".", "initializer", "(", ")", ",", "lazyref", ".", "WithRefreshInterval", "(", "lazyref", ".", "InitImmediately", ",", "params", ".", "refreshInterval", ")", ",", ")", "\n\n", "return", "cfgRef", "\n", "}" ]

[ "NewRef", "returns", "a", "new", "channel", "config", "reference" ]

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

[ "New", "returns", "a", "new", "event", "client" ]

[ "func", "(", "c", "*", "Client", ")", "SetAfterConnectHandler", "(", "h", "handler", ")", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "c", ".", "afterConnect", "=", "h", "\n", "}" ]

[ "SetAfterConnectHandler", "registers", "a", "handler", "that", "is", "called", "after", "the", "client", "connects", "to", "the", "event", "server", ".", "This", "allows", "for", "custom", "code", "to", "be", "executed", "for", "a", "particular", "event", "client", "implementation", "." ]

[ "func", "(", "c", "*", "Client", ")", "SetBeforeReconnectHandler", "(", "h", "handler", ")", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "c", ".", "beforeReconnect", "=", "h", "\n", "}" ]

[ "SetBeforeReconnectHandler", "registers", "a", "handler", "that", "will", "be", "called", "before", "retrying", "to", "reconnect", "to", "the", "event", "server", ".", "This", "allows", "for", "custom", "code", "to", "be", "executed", "for", "a", "particular", "event", "client", "implementation", "." ]

[ "func", "(", "c", "*", "Client", ")", "Connect", "(", ")", "error", "{", "if", "c", ".", "maxConnAttempts", "==", "1", "{", "return", "c", ".", "connect", "(", ")", "\n", "}", "\n", "return", "c", ".", "connectWithRetry", "(", "c", ".", "maxConnAttempts", ",", "c", ".", "timeBetweenConnAttempts", ")", "\n", "}" ]

[ "Connect", "connects", "to", "the", "peer", "and", "registers", "for", "events", "on", "a", "particular", "channel", "." ]

[ "func", "(", "c", "*", "Client", ")", "CloseIfIdle", "(", ")", "bool", "{", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// Check if there are any outstanding registrations", "regInfoCh", ":=", "make", "(", "chan", "*", "esdispatcher", ".", "RegistrationInfo", ")", "\n", "err", ":=", "c", ".", "Submit", "(", "esdispatcher", ".", "NewRegistrationInfoEvent", "(", "regInfoCh", ")", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n", "regInfo", ":=", "<-", "regInfoCh", "\n\n", "logger", ".", "Debugf", "(", "\"", "\"", ",", "regInfo", ".", "TotalRegistrations", ")", "\n\n", "if", "regInfo", ".", "TotalRegistrations", ">", "0", "{", "logger", ".", "Debugf", "(", "\"", "\"", ",", "regInfo", ".", "TotalRegistrations", ")", "\n", "return", "false", "\n", "}", "\n\n", "c", ".", "Close", "(", ")", "\n\n", "return", "true", "\n", "}" ]

[ "CloseIfIdle", "closes", "the", "connection", "to", "the", "event", "server", "only", "if", "there", "are", "no", "outstanding", "registrations", ".", "Returns", "true", "if", "the", "client", "was", "closed", ".", "In", "this", "case", "the", "client", "may", "no", "longer", "be", "used", ".", "A", "return", "value", "of", "false", "indicates", "that", "the", "client", "could", "not", "be", "closed", "since", "there", "was", "at", "least", "one", "registration", "." ]

[ "func", "(", "c", "*", "Client", ")", "TransferRegistrations", "(", "close", "bool", ")", "(", "fab", ".", "EventSnapshot", ",", "error", ")", "{", "if", "!", "close", "{", "return", "c", ".", "Transfer", "(", ")", "\n", "}", "\n\n", "var", "snapshot", "fab", ".", "EventSnapshot", "\n", "var", "err", "error", "\n", "c", ".", "close", "(", "func", "(", ")", "{", "logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "snapshot", ",", "err", "=", "c", ".", "StopAndTransfer", "(", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", ")", "\n\n", "return", "snapshot", ",", "err", "\n", "}" ]

[ "TransferRegistrations", "transfers", "all", "registrations", "into", "an", "EventSnapshot", ".", "The", "registrations", "are", "not", "closed", "and", "may", "susequently", "be", "transferred", "to", "a", "new", "event", "client", ".", "-", "close", "-", "if", "true", "then", "the", "client", "will", "also", "be", "closed" ]

[ "func", "(", "c", "*", "Client", ")", "registerConnectionEvent", "(", ")", "(", "fab", ".", "Registration", ",", "chan", "*", "dispatcher", ".", "ConnectionEvent", ",", "error", ")", "{", "if", "c", ".", "Stopped", "(", ")", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "eventch", ":=", "make", "(", "chan", "*", "dispatcher", ".", "ConnectionEvent", ",", "c", ".", "eventConsumerBufferSize", ")", "\n", "errch", ":=", "make", "(", "chan", "error", ")", "\n", "regch", ":=", "make", "(", "chan", "fab", ".", "Registration", ")", "\n", "err1", ":=", "c", ".", "Submit", "(", "dispatcher", ".", "NewRegisterConnectionEvent", "(", "eventch", ",", "regch", ",", "errch", ")", ")", "\n", "if", "err1", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err1", "\n", "}", "\n", "select", "{", "case", "reg", ":=", "<-", "regch", ":", "return", "reg", ",", "eventch", ",", "nil", "\n", "case", "err", ":=", "<-", "errch", ":", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "}" ]

[ "registerConnectionEvent", "registers", "a", "connection", "event", ".", "The", "returned", "ConnectionEvent", "channel", "will", "be", "called", "whenever", "the", "client", "clients", "or", "disconnects", "from", "the", "event", "server" ]

[ "func", "(", "c", "*", "Client", ")", "setConnectionState", "(", "currentState", ",", "newState", "ConnectionState", ")", "bool", "{", "return", "atomic", ".", "CompareAndSwapInt32", "(", "&", "c", ".", "connectionState", ",", "int32", "(", "currentState", ")", ",", "int32", "(", "newState", ")", ")", "\n", "}" ]

[ "setConnectionState", "sets", "the", "connection", "state", "only", "if", "the", "given", "currentState", "matches", "the", "actual", "state", ".", "True", "is", "returned", "if", "the", "connection", "state", "was", "successfully", "set", "." ]

[ "func", "(", "e", "*", "EndorsementHandler", ")", "Handle", "(", "requestContext", "*", "RequestContext", ",", "clientContext", "*", "ClientContext", ")", "{", "if", "len", "(", "requestContext", ".", "Opts", ".", "Targets", ")", "==", "0", "{", "requestContext", ".", "Error", "=", "status", ".", "New", "(", "status", ".", "ClientStatus", ",", "status", ".", "NoPeersFound", ".", "ToInt32", "(", ")", ",", "\"", "\"", ",", "nil", ")", "\n", "return", "\n", "}", "\n\n", "// Endorse Tx", "var", "TxnHeaderOpts", "[", "]", "fab", ".", "TxnHeaderOpt", "\n", "if", "e", ".", "headerOptsProvider", "!=", "nil", "{", "TxnHeaderOpts", "=", "e", ".", "headerOptsProvider", "(", ")", "\n", "}", "\n\n", "transactionProposalResponses", ",", "proposal", ",", "err", ":=", "createAndSendTransactionProposal", "(", "clientContext", ".", "Transactor", ",", "&", "requestContext", ".", "Request", ",", "peer", ".", "PeersToTxnProcessors", "(", "requestContext", ".", "Opts", ".", "Targets", ")", ",", "TxnHeaderOpts", "...", ",", ")", "\n\n", "requestContext", ".", "Response", ".", "Proposal", "=", "proposal", "\n", "requestContext", ".", "Response", ".", "TransactionID", "=", "proposal", ".", "TxnID", "// TODO: still needed?", "\n\n", "if", "err", "!=", "nil", "{", "requestContext", ".", "Error", "=", "err", "\n", "return", "\n", "}", "\n\n", "requestContext", ".", "Response", ".", "Responses", "=", "transactionProposalResponses", "\n", "if", "len", "(", "transactionProposalResponses", ")", ">", "0", "{", "requestContext", ".", "Response", ".", "Payload", "=", "transactionProposalResponses", "[", "0", "]", ".", "ProposalResponse", ".", "GetResponse", "(", ")", ".", "Payload", "\n", "requestContext", ".", "Response", ".", "ChaincodeStatus", "=", "transactionProposalResponses", "[", "0", "]", ".", "ChaincodeStatus", "\n", "}", "\n\n", "//Delegate to next step if any", "if", "e", ".", "next", "!=", "nil", "{", "e", ".", "next", ".", "Handle", "(", "requestContext", ",", "clientContext", ")", "\n", "}", "\n", "}" ]

[ "Handle", "for", "endorsing", "transactions" ]

[ "func", "(", "h", "*", "ProposalProcessorHandler", ")", "Handle", "(", "requestContext", "*", "RequestContext", ",", "clientContext", "*", "ClientContext", ")", "{", "//Get proposal processor, if not supplied then use selection service to get available peers as endorser", "if", "len", "(", "requestContext", ".", "Opts", ".", "Targets", ")", "==", "0", "{", "var", "selectionOpts", "[", "]", "options", ".", "Opt", "\n", "if", "requestContext", ".", "SelectionFilter", "!=", "nil", "{", "selectionOpts", "=", "append", "(", "selectionOpts", ",", "selectopts", ".", "WithPeerFilter", "(", "requestContext", ".", "SelectionFilter", ")", ")", "\n", "}", "\n", "if", "requestContext", ".", "PeerSorter", "!=", "nil", "{", "selectionOpts", "=", "append", "(", "selectionOpts", ",", "selectopts", ".", "WithPeerSorter", "(", "requestContext", ".", "PeerSorter", ")", ")", "\n", "}", "\n\n", "endorsers", ",", "err", ":=", "clientContext", ".", "Selection", ".", "GetEndorsersForChaincode", "(", "newInvocationChain", "(", "requestContext", ")", ",", "selectionOpts", "...", ")", "\n", "if", "err", "!=", "nil", "{", "requestContext", ".", "Error", "=", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "requestContext", ".", "Opts", ".", "Targets", "=", "endorsers", "\n", "}", "\n\n", "//Delegate to next step if any", "if", "h", ".", "next", "!=", "nil", "{", "h", ".", "next", ".", "Handle", "(", "requestContext", ",", "clientContext", ")", "\n", "}", "\n", "}" ]

[ "Handle", "selects", "proposal", "processors" ]

[ "func", "(", "f", "*", "EndorsementValidationHandler", ")", "Handle", "(", "requestContext", "*", "RequestContext", ",", "clientContext", "*", "ClientContext", ")", "{", "//Filter tx proposal responses", "err", ":=", "f", ".", "validate", "(", "requestContext", ".", "Response", ".", "Responses", ")", "\n", "if", "err", "!=", "nil", "{", "requestContext", ".", "Error", "=", "errors", ".", "WithMessage", "(", "err", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "//Delegate to next step if any", "if", "f", ".", "next", "!=", "nil", "{", "f", ".", "next", ".", "Handle", "(", "requestContext", ",", "clientContext", ")", "\n", "}", "\n", "}" ]

[ "Handle", "for", "Filtering", "proposal", "response" ]

[ "func", "(", "c", "*", "CommitTxHandler", ")", "Handle", "(", "requestContext", "*", "RequestContext", ",", "clientContext", "*", "ClientContext", ")", "{", "txnID", ":=", "requestContext", ".", "Response", ".", "TransactionID", "\n\n", "//Register Tx event", "reg", ",", "statusNotifier", ",", "err", ":=", "clientContext", ".", "EventService", ".", "RegisterTxStatusEvent", "(", "string", "(", "txnID", ")", ")", "// TODO: Change func to use TransactionID instead of string", "\n", "if", "err", "!=", "nil", "{", "requestContext", ".", "Error", "=", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "defer", "clientContext", ".", "EventService", ".", "Unregister", "(", "reg", ")", "\n\n", "_", ",", "err", "=", "createAndSendTransaction", "(", "clientContext", ".", "Transactor", ",", "requestContext", ".", "Response", ".", "Proposal", ",", "requestContext", ".", "Response", ".", "Responses", ")", "\n", "if", "err", "!=", "nil", "{", "requestContext", ".", "Error", "=", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "select", "{", "case", "txStatus", ":=", "<-", "statusNotifier", ":", "requestContext", ".", "Response", ".", "TxValidationCode", "=", "txStatus", ".", "TxValidationCode", "\n\n", "if", "txStatus", ".", "TxValidationCode", "!=", "pb", ".", "TxValidationCode_VALID", "{", "requestContext", ".", "Error", "=", "status", ".", "New", "(", "status", ".", "EventServerStatus", ",", "int32", "(", "txStatus", ".", "TxValidationCode", ")", ",", "\"", "\"", ",", "nil", ")", "\n", "return", "\n", "}", "\n", "case", "<-", "requestContext", ".", "Ctx", ".", "Done", "(", ")", ":", "requestContext", ".", "Error", "=", "status", ".", "New", "(", "status", ".", "ClientStatus", ",", "status", ".", "Timeout", ".", "ToInt32", "(", ")", ",", "\"", "\"", ",", "nil", ")", "\n", "return", "\n", "}", "\n\n", "//Delegate to next step if any", "if", "c", ".", "next", "!=", "nil", "{", "c", ".", "next", ".", "Handle", "(", "requestContext", ",", "clientContext", ")", "\n", "}", "\n", "}" ]

[ "Handle", "handles", "commit", "tx" ]

[ "func", "NewEndorsementHandlerWithOpts", "(", "next", "Handler", ",", "provider", "TxnHeaderOptsProvider", ")", "*", "EndorsementHandler", "{", "return", "&", "EndorsementHandler", "{", "next", ":", "next", ",", "headerOptsProvider", ":", "provider", "}", "\n", "}" ]

[ "NewEndorsementHandlerWithOpts", "returns", "a", "handler", "that", "endorses", "a", "transaction", "proposal" ]

[ "func", "(", "lbp", "*", "RoundRobin", ")", "Choose", "(", "peers", "[", "]", "fab", ".", "Peer", ")", "(", "fab", ".", "Peer", ",", "error", ")", "{", "if", "len", "(", "peers", ")", "==", "0", "{", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "peers", "[", "lbp", ".", "counter", ".", "Next", "(", "len", "(", "peers", ")", ")", "]", ",", "nil", "\n", "}" ]

[ "Choose", "chooses", "from", "the", "list", "of", "peers", "in", "round", "-", "robin", "fashion" ]

[ "func", "New", "(", "cryptoProvider", "core", ".", "CryptoSuite", ")", "(", "*", "SigningManager", ",", "error", ")", "{", "return", "&", "SigningManager", "{", "cryptoProvider", ":", "cryptoProvider", ",", "hashOpts", ":", "cryptosuite", ".", "GetSHAOpts", "(", ")", "}", ",", "nil", "\n", "}" ]

[ "New", "Constructor", "for", "a", "signing", "manager", "." ]

[ "func", "NewBox", "(", "path", "string", ")", "Box", "{", "var", "cd", "string", "\n", "if", "!", "filepath", ".", "IsAbs", "(", "path", ")", "{", "_", ",", "filename", ",", "_", ",", "_", ":=", "runtime", ".", "Caller", "(", "1", ")", "\n", "cd", "=", "filepath", ".", "Dir", "(", "filename", ")", "\n", "}", "\n\n", "// this little hack courtesy of the `-cover` flag!!", "cov", ":=", "filepath", ".", "Join", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "cd", "=", "strings", ".", "Replace", "(", "cd", ",", "string", "(", "filepath", ".", "Separator", ")", "+", "cov", ",", "\"", "\"", ",", "1", ")", "\n", "if", "!", "filepath", ".", "IsAbs", "(", "cd", ")", "&&", "cd", "!=", "\"", "\"", "{", "cd", "=", "filepath", ".", "Join", "(", "GoPath", "(", ")", ",", "\"", "\"", ",", "cd", ")", "\n", "}", "\n\n", "return", "Box", "{", "Path", ":", "path", ",", "callingDir", ":", "cd", ",", "data", ":", "map", "[", "string", "]", "[", "]", "byte", "{", "}", ",", "}", "\n", "}" ]

[ "NewBox", "returns", "a", "Box", "that", "can", "be", "used", "to", "retrieve", "files", "from", "either", "disk", "or", "the", "embedded", "binary", "." ]

[ "func", "(", "b", "Box", ")", "String", "(", ")", "string", "{", "x", ",", "_", ":=", "json", ".", "Marshal", "(", "b", ")", "\n", "return", "string", "(", "x", ")", "\n", "}" ]

[ "String", "-", "json", "returned" ]

[ "func", "NewBox", "(", "name", "string", ",", "path", "string", ")", "*", "Box", "{", "if", "len", "(", "name", ")", "==", "0", "{", "name", "=", "path", "\n", "}", "\n", "name", "=", "strings", ".", "Replace", "(", "name", ",", "\"", "\\\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "pwd", ",", "_", ":=", "os", ".", "Getwd", "(", ")", "\n", "box", ":=", "&", "Box", "{", "Name", ":", "name", ",", "Path", ":", "path", ",", "PWD", ":", "pwd", ",", "}", "\n", "return", "box", "\n", "}" ]

[ "NewBox", "stub", "from", "the", "name", "and", "the", "path", "provided" ]

[ "func", "Pack", "(", "opts", "PackOptions", ")", "error", "{", "pwd", ",", "err", ":=", "os", ".", "Getwd", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "opts", ".", "Roots", "=", "append", "(", "opts", ".", "Roots", ",", "pwd", ")", "\n", "if", "err", ":=", "Clean", "(", "opts", ".", "Roots", "...", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "p", ",", "err", ":=", "parser", ".", "NewFromRoots", "(", "opts", ".", "Roots", ",", "&", "parser", ".", "RootsOptions", "{", "IgnoreImports", ":", "opts", ".", "IgnoreImports", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "boxes", ",", "err", ":=", "p", ".", "Run", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// reduce boxes - remove ones we don't want", "// MB: current assumption is we want all these", "// boxes, just adding a comment suggesting they're", "// might be a reason to exclude some", "plog", ".", "Logger", ".", "Debugf", "(", "\"", "\"", ",", "len", "(", "boxes", ")", ")", "\n\n", "if", "len", "(", "opts", ".", "StoreCmd", ")", "!=", "0", "{", "return", "ShellPack", "(", "opts", ",", "boxes", ")", "\n", "}", "\n\n", "var", "st", "store", ".", "Store", "=", "store", ".", "NewDisk", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "if", "opts", ".", "Legacy", "{", "st", "=", "store", ".", "NewLegacy", "(", ")", "\n", "}", "\n\n", "for", "_", ",", "b", ":=", "range", "boxes", "{", "if", "b", ".", "Name", "==", "store", ".", "DISK_GLOBAL_KEY", "{", "continue", "\n", "}", "\n", "if", "err", ":=", "st", ".", "Pack", "(", "b", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "if", "cl", ",", "ok", ":=", "st", ".", "(", "io", ".", "Closer", ")", ";", "ok", "{", "return", "cl", ".", "Close", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Pack", "the", "roots", "given", "+", "PWD" ]

[ "func", "(", "b", "*", "Builder", ")", "Run", "(", ")", "error", "{", "wg", ":=", "&", "errgroup", ".", "Group", "{", "}", "\n", "root", ",", "err", ":=", "filepath", ".", "EvalSymlinks", "(", "b", ".", "RootPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "filepath", ".", "Walk", "(", "root", ",", "func", "(", "path", "string", ",", "info", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "info", "==", "nil", "{", "return", "filepath", ".", "SkipDir", "\n", "}", "\n\n", "base", ":=", "strings", ".", "ToLower", "(", "filepath", ".", "Base", "(", "path", ")", ")", "\n", "if", "strings", ".", "HasPrefix", "(", "base", ",", "\"", "\"", ")", "{", "return", "filepath", ".", "SkipDir", "\n", "}", "\n", "for", "_", ",", "f", ":=", "range", "b", ".", "IgnoredFolders", "{", "if", "strings", ".", "ToLower", "(", "f", ")", "==", "base", "{", "if", "info", ".", "IsDir", "(", ")", "{", "return", "filepath", ".", "SkipDir", "\n", "}", "else", "{", "return", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "!", "info", ".", "IsDir", "(", ")", "{", "wg", ".", "Go", "(", "func", "(", ")", "error", "{", "return", "b", ".", "process", "(", "path", ")", "\n", "}", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "wg", ".", "Wait", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "b", ".", "dump", "(", ")", "\n", "}" ]

[ "Run", "the", "builder", "." ]

[ "func", "New", "(", "ctx", "context", ".", "Context", ",", "path", "string", ")", "*", "Builder", "{", "return", "&", "Builder", "{", "Context", ":", "ctx", ",", "RootPath", ":", "path", ",", "IgnoredBoxes", ":", "[", "]", "string", "{", "}", ",", "IgnoredFolders", ":", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", ",", "pkgs", ":", "map", "[", "string", "]", "pkg", "{", "}", ",", "moot", ":", "&", "sync", ".", "Mutex", "{", "}", ",", "}", "\n", "}" ]

[ "New", "Builder", "with", "a", "given", "context", "and", "path" ]

[ "func", "(", "f", "*", "File", ")", "String", "(", ")", "string", "{", "src", ",", "_", ":=", "ioutil", ".", "ReadAll", "(", "f", ")", "\n", "f", ".", "Reader", "=", "bytes", ".", "NewReader", "(", "src", ")", "\n", "return", "string", "(", "src", ")", "\n", "}" ]

[ "String", "returns", "the", "contents", "of", "the", "reader" ]

[ "func", "NewFile", "(", "path", "string", ",", "r", "io", ".", "Reader", ")", "*", "File", "{", "if", "r", "==", "nil", "{", "r", "=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "}", "\n", "if", "seek", ",", "ok", ":=", "r", ".", "(", "io", ".", "Seeker", ")", ";", "ok", "{", "seek", ".", "Seek", "(", "0", ",", "0", ")", "\n", "}", "\n", "abs", ":=", "path", "\n", "if", "!", "filepath", ".", "IsAbs", "(", "path", ")", "{", "abs", ",", "_", "=", "filepath", ".", "Abs", "(", "path", ")", "\n", "}", "\n", "return", "&", "File", "{", "Reader", ":", "r", ",", "Path", ":", "path", ",", "AbsPath", ":", "abs", ",", "}", "\n", "}" ]

[ "NewFile", "takes", "the", "name", "of", "the", "file", "you", "want", "to", "write", "to", "and", "a", "reader", "to", "reader", "from" ]