repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
hyperledger/fabric-sdk-go | pkg/common/errors/status/codes.go | String | func (c Code) String() string {
if s, ok := CodeName[c.ToInt32()]; ok {
return s
}
return strconv.Itoa(int(c))
} | go | func (c Code) String() string {
if s, ok := CodeName[c.ToInt32()]; ok {
return s
}
return strconv.Itoa(int(c))
} | [
"func",
"(",
"c",
"Code",
")",
"String",
"(",
")",
"string",
"{",
"if",
"s",
",",
"ok",
":=",
"CodeName",
"[",
"c",
".",
"ToInt32",
"(",
")",
"]",
";",
"ok",
"{",
"return",
"s",
"\n",
"}",
"\n",
"return",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"c",
")",
")",
"\n",
"}"
] | // String representation of the code | [
"String",
"representation",
"of",
"the",
"code"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/common/errors/status/codes.go#L94-L99 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/cryptosuite.go | GetDefault | func GetDefault() core.CryptoSuite {
if atomic.LoadInt32(&initialized) > 0 {
return defaultCryptoSuite
}
//Set default suite
logger.Info("No default cryptosuite found, using default SW implementation")
// Use SW as the default cryptosuite when not initialized properly - should be for testing only
s, err := sw.GetSuiteWithDefaultEphemeral()
if err != nil {
logger.Panicf("Could not initialize default cryptosuite: %s", err)
}
err = initSuite(s)
if err != nil {
logger.Panicf("Could not set default cryptosuite: %s", err)
}
return defaultCryptoSuite
} | go | func GetDefault() core.CryptoSuite {
if atomic.LoadInt32(&initialized) > 0 {
return defaultCryptoSuite
}
//Set default suite
logger.Info("No default cryptosuite found, using default SW implementation")
// Use SW as the default cryptosuite when not initialized properly - should be for testing only
s, err := sw.GetSuiteWithDefaultEphemeral()
if err != nil {
logger.Panicf("Could not initialize default cryptosuite: %s", err)
}
err = initSuite(s)
if err != nil {
logger.Panicf("Could not set default cryptosuite: %s", err)
}
return defaultCryptoSuite
} | [
"func",
"GetDefault",
"(",
")",
"core",
".",
"CryptoSuite",
"{",
"if",
"atomic",
".",
"LoadInt32",
"(",
"&",
"initialized",
")",
">",
"0",
"{",
"return",
"defaultCryptoSuite",
"\n",
"}",
"\n",
"logger",
".",
"Info",
"(",
"\"No default cryptosuite found, using default SW implementation\"",
")",
"\n",
"s",
",",
"err",
":=",
"sw",
".",
"GetSuiteWithDefaultEphemeral",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Panicf",
"(",
"\"Could not initialize default cryptosuite: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"initSuite",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Panicf",
"(",
"\"Could not set default cryptosuite: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"defaultCryptoSuite",
"\n",
"}"
] | //GetDefault returns default core | [
"GetDefault",
"returns",
"default",
"core"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/cryptosuite.go#L40-L58 | train |
hyperledger/fabric-sdk-go | pkg/fab/resource/resource.go | WithRetry | func WithRetry(retry retry.Opts) Opt {
return func(options *options) {
options.retry = retry
}
} | go | func WithRetry(retry retry.Opts) Opt {
return func(options *options) {
options.retry = retry
}
} | [
"func",
"WithRetry",
"(",
"retry",
"retry",
".",
"Opts",
")",
"Opt",
"{",
"return",
"func",
"(",
"options",
"*",
"options",
")",
"{",
"options",
".",
"retry",
"=",
"retry",
"\n",
"}",
"\n",
"}"
] | // WithRetry supplies retry options | [
"WithRetry",
"supplies",
"retry",
"options"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/resource/resource.go#L46-L50 | train |
hyperledger/fabric-sdk-go | pkg/fab/resource/resource.go | SignChannelConfig | func SignChannelConfig(ctx context.Client, config []byte, signer msp.SigningIdentity) (*common.ConfigSignature, error) {
logger.Debug("SignChannelConfig - start")
if config == nil {
return nil, errors.New("channel configuration required")
}
signingUser := signer
// If signing user is not provided default to client's user context
if signingUser == nil {
signingUser = ctx
}
if signingUser == nil {
return nil, errors.New("user context required")
}
sigCtx := fabCtx{
Providers: ctx,
SigningIdentity: signingUser,
}
return CreateConfigSignature(sigCtx, config)
} | go | func SignChannelConfig(ctx context.Client, config []byte, signer msp.SigningIdentity) (*common.ConfigSignature, error) {
logger.Debug("SignChannelConfig - start")
if config == nil {
return nil, errors.New("channel configuration required")
}
signingUser := signer
// If signing user is not provided default to client's user context
if signingUser == nil {
signingUser = ctx
}
if signingUser == nil {
return nil, errors.New("user context required")
}
sigCtx := fabCtx{
Providers: ctx,
SigningIdentity: signingUser,
}
return CreateConfigSignature(sigCtx, config)
} | [
"func",
"SignChannelConfig",
"(",
"ctx",
"context",
".",
"Client",
",",
"config",
"[",
"]",
"byte",
",",
"signer",
"msp",
".",
"SigningIdentity",
")",
"(",
"*",
"common",
".",
"ConfigSignature",
",",
"error",
")",
"{",
"logger",
".",
"Debug",
"(",
"\"SignChannelConfig - start\"",
")",
"\n",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"channel configuration required\"",
")",
"\n",
"}",
"\n",
"signingUser",
":=",
"signer",
"\n",
"if",
"signingUser",
"==",
"nil",
"{",
"signingUser",
"=",
"ctx",
"\n",
"}",
"\n",
"if",
"signingUser",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"user context required\"",
")",
"\n",
"}",
"\n",
"sigCtx",
":=",
"fabCtx",
"{",
"Providers",
":",
"ctx",
",",
"SigningIdentity",
":",
"signingUser",
",",
"}",
"\n",
"return",
"CreateConfigSignature",
"(",
"sigCtx",
",",
"config",
")",
"\n",
"}"
] | // SignChannelConfig signs a configuration. | [
"SignChannelConfig",
"signs",
"a",
"configuration",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/resource/resource.go#L53-L76 | train |
hyperledger/fabric-sdk-go | pkg/fab/resource/resource.go | CreateChannel | func CreateChannel(reqCtx reqContext.Context, request CreateChannelRequest, opts ...Opt) (fab.TransactionID, error) {
if request.Orderer == nil {
return fab.EmptyTransactionID, errors.New("missing orderer request parameter for the initialize channel")
}
if request.Name == "" {
return fab.EmptyTransactionID, errors.New("missing name request parameter for the new channel")
}
if request.Envelope != nil {
return createChannelFromEnvelope(reqCtx, request)
}
if request.Config == nil {
return fab.EmptyTransactionID, errors.New("missing envelope request parameter containing the configuration of the new channel")
}
if request.Signatures == nil {
return fab.EmptyTransactionID, errors.New("missing signatures request parameter for the new channel")
}
ctx, ok := contextImpl.RequestClientContext(reqCtx)
if !ok {
return fab.EmptyTransactionID, errors.New("creation of transaction header failed, failed to extract client context from reqContext")
}
txh, err := txn.NewHeader(ctx, request.Name)
if err != nil {
return fab.EmptyTransactionID, errors.WithMessage(err, "creation of transaction header failed")
}
optionsValue := getOpts(opts...)
_, err = retry.NewInvoker(retry.New(optionsValue.retry)).Invoke(
func() (interface{}, error) {
return nil, createOrUpdateChannel(reqCtx, txh, request)
},
)
return txh.TransactionID(), err
} | go | func CreateChannel(reqCtx reqContext.Context, request CreateChannelRequest, opts ...Opt) (fab.TransactionID, error) {
if request.Orderer == nil {
return fab.EmptyTransactionID, errors.New("missing orderer request parameter for the initialize channel")
}
if request.Name == "" {
return fab.EmptyTransactionID, errors.New("missing name request parameter for the new channel")
}
if request.Envelope != nil {
return createChannelFromEnvelope(reqCtx, request)
}
if request.Config == nil {
return fab.EmptyTransactionID, errors.New("missing envelope request parameter containing the configuration of the new channel")
}
if request.Signatures == nil {
return fab.EmptyTransactionID, errors.New("missing signatures request parameter for the new channel")
}
ctx, ok := contextImpl.RequestClientContext(reqCtx)
if !ok {
return fab.EmptyTransactionID, errors.New("creation of transaction header failed, failed to extract client context from reqContext")
}
txh, err := txn.NewHeader(ctx, request.Name)
if err != nil {
return fab.EmptyTransactionID, errors.WithMessage(err, "creation of transaction header failed")
}
optionsValue := getOpts(opts...)
_, err = retry.NewInvoker(retry.New(optionsValue.retry)).Invoke(
func() (interface{}, error) {
return nil, createOrUpdateChannel(reqCtx, txh, request)
},
)
return txh.TransactionID(), err
} | [
"func",
"CreateChannel",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"request",
"CreateChannelRequest",
",",
"opts",
"...",
"Opt",
")",
"(",
"fab",
".",
"TransactionID",
",",
"error",
")",
"{",
"if",
"request",
".",
"Orderer",
"==",
"nil",
"{",
"return",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"missing orderer request parameter for the initialize channel\"",
")",
"\n",
"}",
"\n",
"if",
"request",
".",
"Name",
"==",
"\"\"",
"{",
"return",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"missing name request parameter for the new channel\"",
")",
"\n",
"}",
"\n",
"if",
"request",
".",
"Envelope",
"!=",
"nil",
"{",
"return",
"createChannelFromEnvelope",
"(",
"reqCtx",
",",
"request",
")",
"\n",
"}",
"\n",
"if",
"request",
".",
"Config",
"==",
"nil",
"{",
"return",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"missing envelope request parameter containing the configuration of the new channel\"",
")",
"\n",
"}",
"\n",
"if",
"request",
".",
"Signatures",
"==",
"nil",
"{",
"return",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"missing signatures request parameter for the new channel\"",
")",
"\n",
"}",
"\n",
"ctx",
",",
"ok",
":=",
"contextImpl",
".",
"RequestClientContext",
"(",
"reqCtx",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"creation of transaction header failed, failed to extract client context from reqContext\"",
")",
"\n",
"}",
"\n",
"txh",
",",
"err",
":=",
"txn",
".",
"NewHeader",
"(",
"ctx",
",",
"request",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"creation of transaction header failed\"",
")",
"\n",
"}",
"\n",
"optionsValue",
":=",
"getOpts",
"(",
"opts",
"...",
")",
"\n",
"_",
",",
"err",
"=",
"retry",
".",
"NewInvoker",
"(",
"retry",
".",
"New",
"(",
"optionsValue",
".",
"retry",
")",
")",
".",
"Invoke",
"(",
"func",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"nil",
",",
"createOrUpdateChannel",
"(",
"reqCtx",
",",
"txh",
",",
"request",
")",
"\n",
"}",
",",
")",
"\n",
"return",
"txh",
".",
"TransactionID",
"(",
")",
",",
"err",
"\n",
"}"
] | // CreateChannel calls the orderer to start building the new channel. | [
"CreateChannel",
"calls",
"the",
"orderer",
"to",
"start",
"building",
"the",
"new",
"channel",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/resource/resource.go#L79-L117 | train |
hyperledger/fabric-sdk-go | pkg/fab/resource/resource.go | GenesisBlockFromOrderer | func GenesisBlockFromOrderer(reqCtx reqContext.Context, channelName string, orderer fab.Orderer, opts ...Opt) (*common.Block, error) {
optionsValue := getOpts(opts...)
return retrieveBlock(reqCtx, []fab.Orderer{orderer}, channelName, newSpecificSeekPosition(0), optionsValue)
} | go | func GenesisBlockFromOrderer(reqCtx reqContext.Context, channelName string, orderer fab.Orderer, opts ...Opt) (*common.Block, error) {
optionsValue := getOpts(opts...)
return retrieveBlock(reqCtx, []fab.Orderer{orderer}, channelName, newSpecificSeekPosition(0), optionsValue)
} | [
"func",
"GenesisBlockFromOrderer",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"channelName",
"string",
",",
"orderer",
"fab",
".",
"Orderer",
",",
"opts",
"...",
"Opt",
")",
"(",
"*",
"common",
".",
"Block",
",",
"error",
")",
"{",
"optionsValue",
":=",
"getOpts",
"(",
"opts",
"...",
")",
"\n",
"return",
"retrieveBlock",
"(",
"reqCtx",
",",
"[",
"]",
"fab",
".",
"Orderer",
"{",
"orderer",
"}",
",",
"channelName",
",",
"newSpecificSeekPosition",
"(",
"0",
")",
",",
"optionsValue",
")",
"\n",
"}"
] | // GenesisBlockFromOrderer returns the genesis block from the defined orderer that may be
// used in a join request | [
"GenesisBlockFromOrderer",
"returns",
"the",
"genesis",
"block",
"from",
"the",
"defined",
"orderer",
"that",
"may",
"be",
"used",
"in",
"a",
"join",
"request"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/resource/resource.go#L135-L138 | train |
hyperledger/fabric-sdk-go | pkg/fab/resource/resource.go | LastConfigFromOrderer | func LastConfigFromOrderer(reqCtx reqContext.Context, channelName string, orderer fab.Orderer, opts ...Opt) (*common.Block, error) {
logger.Debugf("channelConfig - start for channel %s", channelName)
optionsValue := getOpts(opts...)
// Get the newest block
block, err := retrieveBlock(reqCtx, []fab.Orderer{orderer}, channelName, newNewestSeekPosition(), optionsValue)
if err != nil {
return nil, err
}
logger.Debugf("channelConfig - Retrieved newest block number: %d\n", block.Header.Number)
// Get the index of the last config block
lastConfig, err := GetLastConfigFromBlock(block)
if err != nil {
return nil, errors.Wrap(err, "GetLastConfigFromBlock failed")
}
logger.Debugf("channelConfig - Last config index: %d\n", lastConfig.Index)
// Get the last config block
block, err = retrieveBlock(reqCtx, []fab.Orderer{orderer}, channelName, newSpecificSeekPosition(lastConfig.Index), optionsValue)
if err != nil {
return nil, errors.WithMessage(err, "retrieve block failed")
}
logger.Debugf("channelConfig - Last config block number %d, Number of tx: %d", block.Header.Number, len(block.Data.Data))
if len(block.Data.Data) != 1 {
return nil, errors.New("apiconfig block must contain one transaction")
}
return block, nil
} | go | func LastConfigFromOrderer(reqCtx reqContext.Context, channelName string, orderer fab.Orderer, opts ...Opt) (*common.Block, error) {
logger.Debugf("channelConfig - start for channel %s", channelName)
optionsValue := getOpts(opts...)
// Get the newest block
block, err := retrieveBlock(reqCtx, []fab.Orderer{orderer}, channelName, newNewestSeekPosition(), optionsValue)
if err != nil {
return nil, err
}
logger.Debugf("channelConfig - Retrieved newest block number: %d\n", block.Header.Number)
// Get the index of the last config block
lastConfig, err := GetLastConfigFromBlock(block)
if err != nil {
return nil, errors.Wrap(err, "GetLastConfigFromBlock failed")
}
logger.Debugf("channelConfig - Last config index: %d\n", lastConfig.Index)
// Get the last config block
block, err = retrieveBlock(reqCtx, []fab.Orderer{orderer}, channelName, newSpecificSeekPosition(lastConfig.Index), optionsValue)
if err != nil {
return nil, errors.WithMessage(err, "retrieve block failed")
}
logger.Debugf("channelConfig - Last config block number %d, Number of tx: %d", block.Header.Number, len(block.Data.Data))
if len(block.Data.Data) != 1 {
return nil, errors.New("apiconfig block must contain one transaction")
}
return block, nil
} | [
"func",
"LastConfigFromOrderer",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"channelName",
"string",
",",
"orderer",
"fab",
".",
"Orderer",
",",
"opts",
"...",
"Opt",
")",
"(",
"*",
"common",
".",
"Block",
",",
"error",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"channelConfig - start for channel %s\"",
",",
"channelName",
")",
"\n",
"optionsValue",
":=",
"getOpts",
"(",
"opts",
"...",
")",
"\n",
"block",
",",
"err",
":=",
"retrieveBlock",
"(",
"reqCtx",
",",
"[",
"]",
"fab",
".",
"Orderer",
"{",
"orderer",
"}",
",",
"channelName",
",",
"newNewestSeekPosition",
"(",
")",
",",
"optionsValue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"channelConfig - Retrieved newest block number: %d\\n\"",
",",
"\\n",
")",
"\n",
"block",
".",
"Header",
".",
"Number",
"\n",
"lastConfig",
",",
"err",
":=",
"GetLastConfigFromBlock",
"(",
"block",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"GetLastConfigFromBlock failed\"",
")",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"channelConfig - Last config index: %d\\n\"",
",",
"\\n",
")",
"\n",
"lastConfig",
".",
"Index",
"\n",
"block",
",",
"err",
"=",
"retrieveBlock",
"(",
"reqCtx",
",",
"[",
"]",
"fab",
".",
"Orderer",
"{",
"orderer",
"}",
",",
"channelName",
",",
"newSpecificSeekPosition",
"(",
"lastConfig",
".",
"Index",
")",
",",
"optionsValue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"retrieve block failed\"",
")",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"channelConfig - Last config block number %d, Number of tx: %d\"",
",",
"block",
".",
"Header",
".",
"Number",
",",
"len",
"(",
"block",
".",
"Data",
".",
"Data",
")",
")",
"\n",
"}"
] | // LastConfigFromOrderer fetches the current configuration block for the specified channel
// from the given orderer | [
"LastConfigFromOrderer",
"fetches",
"the",
"current",
"configuration",
"block",
"for",
"the",
"specified",
"channel",
"from",
"the",
"given",
"orderer"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/resource/resource.go#L142-L173 | train |
hyperledger/fabric-sdk-go | pkg/fab/resource/resource.go | createOrUpdateChannel | func createOrUpdateChannel(reqCtx reqContext.Context, txh *txn.TransactionHeader, request CreateChannelRequest) error {
configUpdateEnvelope := &common.ConfigUpdateEnvelope{
ConfigUpdate: request.Config,
Signatures: request.Signatures,
}
configUpdateEnvelopeBytes, err := proto.Marshal(configUpdateEnvelope)
if err != nil {
return errors.Wrap(err, "marshal configUpdateEnvelope failed")
}
ctx, ok := contextImpl.RequestClientContext(reqCtx)
if !ok {
return errors.New("failed get client context from reqContext for Creating ChannelHeader")
}
hash, err := ccomm.TLSCertHash(ctx.EndpointConfig())
if err != nil {
return errors.WithMessage(err, "failed to get tls cert hash")
}
channelHeaderOpts := txn.ChannelHeaderOpts{
TxnHeader: txh,
TLSCertHash: hash,
}
channelHeader, err := txn.CreateChannelHeader(common.HeaderType_CONFIG_UPDATE, channelHeaderOpts)
if err != nil {
return errors.WithMessage(err, "CreateChannelHeader failed")
}
payload, err := txn.CreatePayload(txh, channelHeader, configUpdateEnvelopeBytes)
if err != nil {
return errors.WithMessage(err, "CreatePayload failed")
}
_, err = txn.BroadcastPayload(reqCtx, payload, []fab.Orderer{request.Orderer})
if err != nil {
return errors.WithMessage(err, "SendEnvelope failed")
}
return nil
} | go | func createOrUpdateChannel(reqCtx reqContext.Context, txh *txn.TransactionHeader, request CreateChannelRequest) error {
configUpdateEnvelope := &common.ConfigUpdateEnvelope{
ConfigUpdate: request.Config,
Signatures: request.Signatures,
}
configUpdateEnvelopeBytes, err := proto.Marshal(configUpdateEnvelope)
if err != nil {
return errors.Wrap(err, "marshal configUpdateEnvelope failed")
}
ctx, ok := contextImpl.RequestClientContext(reqCtx)
if !ok {
return errors.New("failed get client context from reqContext for Creating ChannelHeader")
}
hash, err := ccomm.TLSCertHash(ctx.EndpointConfig())
if err != nil {
return errors.WithMessage(err, "failed to get tls cert hash")
}
channelHeaderOpts := txn.ChannelHeaderOpts{
TxnHeader: txh,
TLSCertHash: hash,
}
channelHeader, err := txn.CreateChannelHeader(common.HeaderType_CONFIG_UPDATE, channelHeaderOpts)
if err != nil {
return errors.WithMessage(err, "CreateChannelHeader failed")
}
payload, err := txn.CreatePayload(txh, channelHeader, configUpdateEnvelopeBytes)
if err != nil {
return errors.WithMessage(err, "CreatePayload failed")
}
_, err = txn.BroadcastPayload(reqCtx, payload, []fab.Orderer{request.Orderer})
if err != nil {
return errors.WithMessage(err, "SendEnvelope failed")
}
return nil
} | [
"func",
"createOrUpdateChannel",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"txh",
"*",
"txn",
".",
"TransactionHeader",
",",
"request",
"CreateChannelRequest",
")",
"error",
"{",
"configUpdateEnvelope",
":=",
"&",
"common",
".",
"ConfigUpdateEnvelope",
"{",
"ConfigUpdate",
":",
"request",
".",
"Config",
",",
"Signatures",
":",
"request",
".",
"Signatures",
",",
"}",
"\n",
"configUpdateEnvelopeBytes",
",",
"err",
":=",
"proto",
".",
"Marshal",
"(",
"configUpdateEnvelope",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"marshal configUpdateEnvelope failed\"",
")",
"\n",
"}",
"\n",
"ctx",
",",
"ok",
":=",
"contextImpl",
".",
"RequestClientContext",
"(",
"reqCtx",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"failed get client context from reqContext for Creating ChannelHeader\"",
")",
"\n",
"}",
"\n",
"hash",
",",
"err",
":=",
"ccomm",
".",
"TLSCertHash",
"(",
"ctx",
".",
"EndpointConfig",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"failed to get tls cert hash\"",
")",
"\n",
"}",
"\n",
"channelHeaderOpts",
":=",
"txn",
".",
"ChannelHeaderOpts",
"{",
"TxnHeader",
":",
"txh",
",",
"TLSCertHash",
":",
"hash",
",",
"}",
"\n",
"channelHeader",
",",
"err",
":=",
"txn",
".",
"CreateChannelHeader",
"(",
"common",
".",
"HeaderType_CONFIG_UPDATE",
",",
"channelHeaderOpts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"CreateChannelHeader failed\"",
")",
"\n",
"}",
"\n",
"payload",
",",
"err",
":=",
"txn",
".",
"CreatePayload",
"(",
"txh",
",",
"channelHeader",
",",
"configUpdateEnvelopeBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"CreatePayload failed\"",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"txn",
".",
"BroadcastPayload",
"(",
"reqCtx",
",",
"payload",
",",
"[",
"]",
"fab",
".",
"Orderer",
"{",
"request",
".",
"Orderer",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"SendEnvelope failed\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // createOrUpdateChannel creates a new channel or updates an existing channel. | [
"createOrUpdateChannel",
"creates",
"a",
"new",
"channel",
"or",
"updates",
"an",
"existing",
"channel",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/resource/resource.go#L228-L268 | train |
hyperledger/fabric-sdk-go | pkg/fab/resource/resource.go | QueryChannels | func QueryChannels(reqCtx reqContext.Context, peer fab.ProposalProcessor, opts ...Opt) (*pb.ChannelQueryResponse, error) {
if peer == nil {
return nil, errors.New("peer required")
}
optionsValue := getOpts(opts...)
cir := createChannelsInvokeRequest()
payload, err := queryChaincodeWithTarget(reqCtx, cir, peer, optionsValue)
if err != nil {
return nil, errors.WithMessage(err, "cscc.GetChannels failed")
}
response := new(pb.ChannelQueryResponse)
err = proto.Unmarshal(payload, response)
if err != nil {
return nil, errors.Wrap(err, "unmarshal ChannelQueryResponse failed")
}
return response, nil
} | go | func QueryChannels(reqCtx reqContext.Context, peer fab.ProposalProcessor, opts ...Opt) (*pb.ChannelQueryResponse, error) {
if peer == nil {
return nil, errors.New("peer required")
}
optionsValue := getOpts(opts...)
cir := createChannelsInvokeRequest()
payload, err := queryChaincodeWithTarget(reqCtx, cir, peer, optionsValue)
if err != nil {
return nil, errors.WithMessage(err, "cscc.GetChannels failed")
}
response := new(pb.ChannelQueryResponse)
err = proto.Unmarshal(payload, response)
if err != nil {
return nil, errors.Wrap(err, "unmarshal ChannelQueryResponse failed")
}
return response, nil
} | [
"func",
"QueryChannels",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"peer",
"fab",
".",
"ProposalProcessor",
",",
"opts",
"...",
"Opt",
")",
"(",
"*",
"pb",
".",
"ChannelQueryResponse",
",",
"error",
")",
"{",
"if",
"peer",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"peer required\"",
")",
"\n",
"}",
"\n",
"optionsValue",
":=",
"getOpts",
"(",
"opts",
"...",
")",
"\n",
"cir",
":=",
"createChannelsInvokeRequest",
"(",
")",
"\n",
"payload",
",",
"err",
":=",
"queryChaincodeWithTarget",
"(",
"reqCtx",
",",
"cir",
",",
"peer",
",",
"optionsValue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"cscc.GetChannels failed\"",
")",
"\n",
"}",
"\n",
"response",
":=",
"new",
"(",
"pb",
".",
"ChannelQueryResponse",
")",
"\n",
"err",
"=",
"proto",
".",
"Unmarshal",
"(",
"payload",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"unmarshal ChannelQueryResponse failed\"",
")",
"\n",
"}",
"\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | // QueryChannels queries the names of all the channels that a peer has joined. | [
"QueryChannels",
"queries",
"the",
"names",
"of",
"all",
"the",
"channels",
"that",
"a",
"peer",
"has",
"joined",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/resource/resource.go#L271-L291 | train |
hyperledger/fabric-sdk-go | pkg/fab/resource/resource.go | InstallChaincode | func InstallChaincode(reqCtx reqContext.Context, req InstallChaincodeRequest, targets []fab.ProposalProcessor, opts ...Opt) ([]*fab.TransactionProposalResponse, fab.TransactionID, error) {
if req.Name == "" {
return nil, fab.EmptyTransactionID, errors.New("chaincode name required")
}
if req.Path == "" {
return nil, fab.EmptyTransactionID, errors.New("chaincode path required")
}
if req.Version == "" {
return nil, fab.EmptyTransactionID, errors.New("chaincode version required")
}
if req.Package == nil {
return nil, fab.EmptyTransactionID, errors.New("chaincode package is required")
}
propReq := ChaincodeInstallRequest{
Name: req.Name,
Path: req.Path,
Version: req.Version,
Package: &ChaincodePackage{
Type: req.Package.Type,
Code: req.Package.Code,
},
}
ctx, ok := contextImpl.RequestClientContext(reqCtx)
if !ok {
return nil, fab.EmptyTransactionID, errors.New("failed get client context from reqContext for txn header")
}
txh, err := txn.NewHeader(ctx, fab.SystemChannel)
if err != nil {
return nil, fab.EmptyTransactionID, errors.WithMessage(err, "create transaction ID failed")
}
prop, err := CreateChaincodeInstallProposal(txh, propReq)
if err != nil {
return nil, fab.EmptyTransactionID, errors.WithMessage(err, "creation of install chaincode proposal failed")
}
optionsValue := getOpts(opts...)
resp, err := retry.NewInvoker(retry.New(optionsValue.retry)).Invoke(
func() (interface{}, error) {
return txn.SendProposal(reqCtx, prop, targets)
},
)
if err != nil {
return nil, fab.EmptyTransactionID, err
}
return resp.([]*fab.TransactionProposalResponse), prop.TxnID, nil
} | go | func InstallChaincode(reqCtx reqContext.Context, req InstallChaincodeRequest, targets []fab.ProposalProcessor, opts ...Opt) ([]*fab.TransactionProposalResponse, fab.TransactionID, error) {
if req.Name == "" {
return nil, fab.EmptyTransactionID, errors.New("chaincode name required")
}
if req.Path == "" {
return nil, fab.EmptyTransactionID, errors.New("chaincode path required")
}
if req.Version == "" {
return nil, fab.EmptyTransactionID, errors.New("chaincode version required")
}
if req.Package == nil {
return nil, fab.EmptyTransactionID, errors.New("chaincode package is required")
}
propReq := ChaincodeInstallRequest{
Name: req.Name,
Path: req.Path,
Version: req.Version,
Package: &ChaincodePackage{
Type: req.Package.Type,
Code: req.Package.Code,
},
}
ctx, ok := contextImpl.RequestClientContext(reqCtx)
if !ok {
return nil, fab.EmptyTransactionID, errors.New("failed get client context from reqContext for txn header")
}
txh, err := txn.NewHeader(ctx, fab.SystemChannel)
if err != nil {
return nil, fab.EmptyTransactionID, errors.WithMessage(err, "create transaction ID failed")
}
prop, err := CreateChaincodeInstallProposal(txh, propReq)
if err != nil {
return nil, fab.EmptyTransactionID, errors.WithMessage(err, "creation of install chaincode proposal failed")
}
optionsValue := getOpts(opts...)
resp, err := retry.NewInvoker(retry.New(optionsValue.retry)).Invoke(
func() (interface{}, error) {
return txn.SendProposal(reqCtx, prop, targets)
},
)
if err != nil {
return nil, fab.EmptyTransactionID, err
}
return resp.([]*fab.TransactionProposalResponse), prop.TxnID, nil
} | [
"func",
"InstallChaincode",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"req",
"InstallChaincodeRequest",
",",
"targets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
",",
"opts",
"...",
"Opt",
")",
"(",
"[",
"]",
"*",
"fab",
".",
"TransactionProposalResponse",
",",
"fab",
".",
"TransactionID",
",",
"error",
")",
"{",
"if",
"req",
".",
"Name",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"chaincode name required\"",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"Path",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"chaincode path required\"",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"Version",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"chaincode version required\"",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"Package",
"==",
"nil",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"chaincode package is required\"",
")",
"\n",
"}",
"\n",
"propReq",
":=",
"ChaincodeInstallRequest",
"{",
"Name",
":",
"req",
".",
"Name",
",",
"Path",
":",
"req",
".",
"Path",
",",
"Version",
":",
"req",
".",
"Version",
",",
"Package",
":",
"&",
"ChaincodePackage",
"{",
"Type",
":",
"req",
".",
"Package",
".",
"Type",
",",
"Code",
":",
"req",
".",
"Package",
".",
"Code",
",",
"}",
",",
"}",
"\n",
"ctx",
",",
"ok",
":=",
"contextImpl",
".",
"RequestClientContext",
"(",
"reqCtx",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"failed get client context from reqContext for txn header\"",
")",
"\n",
"}",
"\n",
"txh",
",",
"err",
":=",
"txn",
".",
"NewHeader",
"(",
"ctx",
",",
"fab",
".",
"SystemChannel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"create transaction ID failed\"",
")",
"\n",
"}",
"\n",
"prop",
",",
"err",
":=",
"CreateChaincodeInstallProposal",
"(",
"txh",
",",
"propReq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"creation of install chaincode proposal failed\"",
")",
"\n",
"}",
"\n",
"optionsValue",
":=",
"getOpts",
"(",
"opts",
"...",
")",
"\n",
"resp",
",",
"err",
":=",
"retry",
".",
"NewInvoker",
"(",
"retry",
".",
"New",
"(",
"optionsValue",
".",
"retry",
")",
")",
".",
"Invoke",
"(",
"func",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"txn",
".",
"SendProposal",
"(",
"reqCtx",
",",
"prop",
",",
"targets",
")",
"\n",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"err",
"\n",
"}",
"\n",
"return",
"resp",
".",
"(",
"[",
"]",
"*",
"fab",
".",
"TransactionProposalResponse",
")",
",",
"prop",
".",
"TxnID",
",",
"nil",
"\n",
"}"
] | // InstallChaincode sends an install proposal to one or more endorsing peers. | [
"InstallChaincode",
"sends",
"an",
"install",
"proposal",
"to",
"one",
"or",
"more",
"endorsing",
"peers",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/resource/resource.go#L319-L371 | train |
hyperledger/fabric-sdk-go | pkg/fab/comm/connectionopts.go | WithHostOverride | func WithHostOverride(value string) options.Opt {
return func(p options.Params) {
if setter, ok := p.(hostOverrideSetter); ok {
setter.SetHostOverride(value)
}
}
} | go | func WithHostOverride(value string) options.Opt {
return func(p options.Params) {
if setter, ok := p.(hostOverrideSetter); ok {
setter.SetHostOverride(value)
}
}
} | [
"func",
"WithHostOverride",
"(",
"value",
"string",
")",
"options",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"options",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"hostOverrideSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetHostOverride",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithHostOverride sets the host name that will be used to resolve the TLS certificate | [
"WithHostOverride",
"sets",
"the",
"host",
"name",
"that",
"will",
"be",
"used",
"to",
"resolve",
"the",
"TLS",
"certificate"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connectionopts.go#L36-L42 | train |
hyperledger/fabric-sdk-go | pkg/fab/comm/connectionopts.go | WithCertificate | func WithCertificate(value *x509.Certificate) options.Opt {
return func(p options.Params) {
if setter, ok := p.(certificateSetter); ok {
setter.SetCertificate(value)
}
}
} | go | func WithCertificate(value *x509.Certificate) options.Opt {
return func(p options.Params) {
if setter, ok := p.(certificateSetter); ok {
setter.SetCertificate(value)
}
}
} | [
"func",
"WithCertificate",
"(",
"value",
"*",
"x509",
".",
"Certificate",
")",
"options",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"options",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"certificateSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetCertificate",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithCertificate sets the X509 certificate used for the TLS connection | [
"WithCertificate",
"sets",
"the",
"X509",
"certificate",
"used",
"for",
"the",
"TLS",
"connection"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connectionopts.go#L45-L51 | train |
hyperledger/fabric-sdk-go | pkg/fab/comm/connectionopts.go | WithKeepAliveParams | func WithKeepAliveParams(value keepalive.ClientParameters) options.Opt {
return func(p options.Params) {
if setter, ok := p.(keepAliveParamsSetter); ok {
setter.SetKeepAliveParams(value)
}
}
} | go | func WithKeepAliveParams(value keepalive.ClientParameters) options.Opt {
return func(p options.Params) {
if setter, ok := p.(keepAliveParamsSetter); ok {
setter.SetKeepAliveParams(value)
}
}
} | [
"func",
"WithKeepAliveParams",
"(",
"value",
"keepalive",
".",
"ClientParameters",
")",
"options",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"options",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"keepAliveParamsSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetKeepAliveParams",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithKeepAliveParams sets the GRPC keep-alive parameters | [
"WithKeepAliveParams",
"sets",
"the",
"GRPC",
"keep",
"-",
"alive",
"parameters"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connectionopts.go#L54-L60 | train |
hyperledger/fabric-sdk-go | pkg/fab/comm/connectionopts.go | WithFailFast | func WithFailFast(value bool) options.Opt {
return func(p options.Params) {
if setter, ok := p.(failFastSetter); ok {
setter.SetFailFast(value)
}
}
} | go | func WithFailFast(value bool) options.Opt {
return func(p options.Params) {
if setter, ok := p.(failFastSetter); ok {
setter.SetFailFast(value)
}
}
} | [
"func",
"WithFailFast",
"(",
"value",
"bool",
")",
"options",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"options",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"failFastSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetFailFast",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithFailFast sets the GRPC fail-fast parameter | [
"WithFailFast",
"sets",
"the",
"GRPC",
"fail",
"-",
"fast",
"parameter"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connectionopts.go#L63-L69 | train |
hyperledger/fabric-sdk-go | pkg/fab/comm/connectionopts.go | WithConnectTimeout | func WithConnectTimeout(value time.Duration) options.Opt {
return func(p options.Params) {
if setter, ok := p.(connectTimeoutSetter); ok {
setter.SetConnectTimeout(value)
}
}
} | go | func WithConnectTimeout(value time.Duration) options.Opt {
return func(p options.Params) {
if setter, ok := p.(connectTimeoutSetter); ok {
setter.SetConnectTimeout(value)
}
}
} | [
"func",
"WithConnectTimeout",
"(",
"value",
"time",
".",
"Duration",
")",
"options",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"options",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"connectTimeoutSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetConnectTimeout",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithConnectTimeout sets the GRPC connection timeout | [
"WithConnectTimeout",
"sets",
"the",
"GRPC",
"connection",
"timeout"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connectionopts.go#L72-L78 | train |
hyperledger/fabric-sdk-go | pkg/fab/comm/connectionopts.go | WithInsecure | func WithInsecure() options.Opt {
return func(p options.Params) {
if setter, ok := p.(insecureSetter); ok {
setter.SetInsecure(true)
}
}
} | go | func WithInsecure() options.Opt {
return func(p options.Params) {
if setter, ok := p.(insecureSetter); ok {
setter.SetInsecure(true)
}
}
} | [
"func",
"WithInsecure",
"(",
")",
"options",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"options",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"insecureSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetInsecure",
"(",
"true",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithInsecure indicates to fall back to an insecure connection if the
// connection URL does not specify a protocol | [
"WithInsecure",
"indicates",
"to",
"fall",
"back",
"to",
"an",
"insecure",
"connection",
"if",
"the",
"connection",
"URL",
"does",
"not",
"specify",
"a",
"protocol"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connectionopts.go#L82-L88 | train |
hyperledger/fabric-sdk-go | pkg/fab/comm/connectionopts.go | OptsFromPeerConfig | func OptsFromPeerConfig(peerCfg *fab.PeerConfig) []options.Opt {
opts := []options.Opt{
WithHostOverride(getServerNameOverride(peerCfg)),
WithFailFast(getFailFast(peerCfg)),
WithKeepAliveParams(getKeepAliveOptions(peerCfg)),
WithCertificate(peerCfg.TLSCACert),
}
if isInsecureAllowed(peerCfg) {
opts = append(opts, WithInsecure())
}
return opts
} | go | func OptsFromPeerConfig(peerCfg *fab.PeerConfig) []options.Opt {
opts := []options.Opt{
WithHostOverride(getServerNameOverride(peerCfg)),
WithFailFast(getFailFast(peerCfg)),
WithKeepAliveParams(getKeepAliveOptions(peerCfg)),
WithCertificate(peerCfg.TLSCACert),
}
if isInsecureAllowed(peerCfg) {
opts = append(opts, WithInsecure())
}
return opts
} | [
"func",
"OptsFromPeerConfig",
"(",
"peerCfg",
"*",
"fab",
".",
"PeerConfig",
")",
"[",
"]",
"options",
".",
"Opt",
"{",
"opts",
":=",
"[",
"]",
"options",
".",
"Opt",
"{",
"WithHostOverride",
"(",
"getServerNameOverride",
"(",
"peerCfg",
")",
")",
",",
"WithFailFast",
"(",
"getFailFast",
"(",
"peerCfg",
")",
")",
",",
"WithKeepAliveParams",
"(",
"getKeepAliveOptions",
"(",
"peerCfg",
")",
")",
",",
"WithCertificate",
"(",
"peerCfg",
".",
"TLSCACert",
")",
",",
"}",
"\n",
"if",
"isInsecureAllowed",
"(",
"peerCfg",
")",
"{",
"opts",
"=",
"append",
"(",
"opts",
",",
"WithInsecure",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"opts",
"\n",
"}"
] | // OptsFromPeerConfig returns a set of connection options from the given peer config | [
"OptsFromPeerConfig",
"returns",
"a",
"set",
"of",
"connection",
"options",
"from",
"the",
"given",
"peer",
"config"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connectionopts.go#L149-L162 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/peerresolver/preferpeer/preferpeer.go | New | func New(dispatcher service.Dispatcher, context context.Client, channelID string, preferredPeers []string, opts ...options.Opt) *PeerResolver {
params := defaultParams(context, channelID)
options.Apply(params, opts)
logger.Debugf("Creating new PreferPeer peer resolver with options: Preferred Peers [%s]", preferredPeers)
return &PeerResolver{
params: params,
preferredPeers: preferredPeers,
preferOrgResolver: preferorg.New(dispatcher, context, channelID, opts...),
minBlockHeightResolver: minblockheight.New(dispatcher, context, channelID, opts...),
}
} | go | func New(dispatcher service.Dispatcher, context context.Client, channelID string, preferredPeers []string, opts ...options.Opt) *PeerResolver {
params := defaultParams(context, channelID)
options.Apply(params, opts)
logger.Debugf("Creating new PreferPeer peer resolver with options: Preferred Peers [%s]", preferredPeers)
return &PeerResolver{
params: params,
preferredPeers: preferredPeers,
preferOrgResolver: preferorg.New(dispatcher, context, channelID, opts...),
minBlockHeightResolver: minblockheight.New(dispatcher, context, channelID, opts...),
}
} | [
"func",
"New",
"(",
"dispatcher",
"service",
".",
"Dispatcher",
",",
"context",
"context",
".",
"Client",
",",
"channelID",
"string",
",",
"preferredPeers",
"[",
"]",
"string",
",",
"opts",
"...",
"options",
".",
"Opt",
")",
"*",
"PeerResolver",
"{",
"params",
":=",
"defaultParams",
"(",
"context",
",",
"channelID",
")",
"\n",
"options",
".",
"Apply",
"(",
"params",
",",
"opts",
")",
"\n",
"logger",
".",
"Debugf",
"(",
"\"Creating new PreferPeer peer resolver with options: Preferred Peers [%s]\"",
",",
"preferredPeers",
")",
"\n",
"return",
"&",
"PeerResolver",
"{",
"params",
":",
"params",
",",
"preferredPeers",
":",
"preferredPeers",
",",
"preferOrgResolver",
":",
"preferorg",
".",
"New",
"(",
"dispatcher",
",",
"context",
",",
"channelID",
",",
"opts",
"...",
")",
",",
"minBlockHeightResolver",
":",
"minblockheight",
".",
"New",
"(",
"dispatcher",
",",
"context",
",",
"channelID",
",",
"opts",
"...",
")",
",",
"}",
"\n",
"}"
] | // New returns a new "prefer peer" resolver. | [
"New",
"returns",
"a",
"new",
"prefer",
"peer",
"resolver",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/peerresolver/preferpeer/preferpeer.go#L44-L56 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/peerresolver/preferpeer/preferpeer.go | Resolve | func (r *PeerResolver) Resolve(peers []fab.Peer) (fab.Peer, error) {
preferredPeers := r.getPreferredPeers(r.minBlockHeightResolver.Filter(peers))
if len(preferredPeers) > 0 {
// At least one of our preferred peers is suitable. Use the default balancer to balance between them.
logger.Debugf("Choosing a peer from the list of preferred peers")
return r.loadBalancePolicy.Choose(preferredPeers)
}
logger.Debugf("There are no suitable peers from the list of preferred peers [%s] so choosing another peer using the 'prefer org' resolver", r.preferredPeers)
return r.preferOrgResolver.Resolve(peers)
} | go | func (r *PeerResolver) Resolve(peers []fab.Peer) (fab.Peer, error) {
preferredPeers := r.getPreferredPeers(r.minBlockHeightResolver.Filter(peers))
if len(preferredPeers) > 0 {
// At least one of our preferred peers is suitable. Use the default balancer to balance between them.
logger.Debugf("Choosing a peer from the list of preferred peers")
return r.loadBalancePolicy.Choose(preferredPeers)
}
logger.Debugf("There are no suitable peers from the list of preferred peers [%s] so choosing another peer using the 'prefer org' resolver", r.preferredPeers)
return r.preferOrgResolver.Resolve(peers)
} | [
"func",
"(",
"r",
"*",
"PeerResolver",
")",
"Resolve",
"(",
"peers",
"[",
"]",
"fab",
".",
"Peer",
")",
"(",
"fab",
".",
"Peer",
",",
"error",
")",
"{",
"preferredPeers",
":=",
"r",
".",
"getPreferredPeers",
"(",
"r",
".",
"minBlockHeightResolver",
".",
"Filter",
"(",
"peers",
")",
")",
"\n",
"if",
"len",
"(",
"preferredPeers",
")",
">",
"0",
"{",
"logger",
".",
"Debugf",
"(",
"\"Choosing a peer from the list of preferred peers\"",
")",
"\n",
"return",
"r",
".",
"loadBalancePolicy",
".",
"Choose",
"(",
"preferredPeers",
")",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"There are no suitable peers from the list of preferred peers [%s] so choosing another peer using the 'prefer org' resolver\"",
",",
"r",
".",
"preferredPeers",
")",
"\n",
"return",
"r",
".",
"preferOrgResolver",
".",
"Resolve",
"(",
"peers",
")",
"\n",
"}"
] | // Resolve uses the MinBlockHeight resolver to choose peers but will prefer the ones in the list of preferred peers. | [
"Resolve",
"uses",
"the",
"MinBlockHeight",
"resolver",
"to",
"choose",
"peers",
"but",
"will",
"prefer",
"the",
"ones",
"in",
"the",
"list",
"of",
"preferred",
"peers",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/peerresolver/preferpeer/preferpeer.go#L59-L69 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/peerresolver/preferpeer/preferpeer.go | ShouldDisconnect | func (r *PeerResolver) ShouldDisconnect(peers []fab.Peer, connectedPeer fab.Peer) bool {
if !r.isPreferred(connectedPeer) {
// We're not connected to a preferred peer. Check if we can connect back to one.
logger.Debugf("Currently connected to [%s]. Checking if any of the preferred peers [%s] is suitable to connect back to", connectedPeer.URL(), r.preferredPeers)
if len(r.getPreferredPeers(r.minBlockHeightResolver.Filter(peers))) > 0 {
logger.Debugf("At least one of our preferred peers is suitable to connect back to so the event client will be disconnected from peer [%s]", connectedPeer.URL())
return true
}
logger.Debugf("None of our preferred peers is suitable to connect back to so the event client will NOT be disconnected from peer [%s]", connectedPeer.URL())
}
logger.Debugf("Using the 'prefer org' resolver to determine whether peer [%s] should be disconnected", connectedPeer.URL())
return r.preferOrgResolver.ShouldDisconnect(peers, connectedPeer)
} | go | func (r *PeerResolver) ShouldDisconnect(peers []fab.Peer, connectedPeer fab.Peer) bool {
if !r.isPreferred(connectedPeer) {
// We're not connected to a preferred peer. Check if we can connect back to one.
logger.Debugf("Currently connected to [%s]. Checking if any of the preferred peers [%s] is suitable to connect back to", connectedPeer.URL(), r.preferredPeers)
if len(r.getPreferredPeers(r.minBlockHeightResolver.Filter(peers))) > 0 {
logger.Debugf("At least one of our preferred peers is suitable to connect back to so the event client will be disconnected from peer [%s]", connectedPeer.URL())
return true
}
logger.Debugf("None of our preferred peers is suitable to connect back to so the event client will NOT be disconnected from peer [%s]", connectedPeer.URL())
}
logger.Debugf("Using the 'prefer org' resolver to determine whether peer [%s] should be disconnected", connectedPeer.URL())
return r.preferOrgResolver.ShouldDisconnect(peers, connectedPeer)
} | [
"func",
"(",
"r",
"*",
"PeerResolver",
")",
"ShouldDisconnect",
"(",
"peers",
"[",
"]",
"fab",
".",
"Peer",
",",
"connectedPeer",
"fab",
".",
"Peer",
")",
"bool",
"{",
"if",
"!",
"r",
".",
"isPreferred",
"(",
"connectedPeer",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"Currently connected to [%s]. Checking if any of the preferred peers [%s] is suitable to connect back to\"",
",",
"connectedPeer",
".",
"URL",
"(",
")",
",",
"r",
".",
"preferredPeers",
")",
"\n",
"if",
"len",
"(",
"r",
".",
"getPreferredPeers",
"(",
"r",
".",
"minBlockHeightResolver",
".",
"Filter",
"(",
"peers",
")",
")",
")",
">",
"0",
"{",
"logger",
".",
"Debugf",
"(",
"\"At least one of our preferred peers is suitable to connect back to so the event client will be disconnected from peer [%s]\"",
",",
"connectedPeer",
".",
"URL",
"(",
")",
")",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"None of our preferred peers is suitable to connect back to so the event client will NOT be disconnected from peer [%s]\"",
",",
"connectedPeer",
".",
"URL",
"(",
")",
")",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"Using the 'prefer org' resolver to determine whether peer [%s] should be disconnected\"",
",",
"connectedPeer",
".",
"URL",
"(",
")",
")",
"\n",
"return",
"r",
".",
"preferOrgResolver",
".",
"ShouldDisconnect",
"(",
"peers",
",",
"connectedPeer",
")",
"\n",
"}"
] | // ShouldDisconnect determines whether the connected peer should be disconnected and reconnected to the preferred peer. | [
"ShouldDisconnect",
"determines",
"whether",
"the",
"connected",
"peer",
"should",
"be",
"disconnected",
"and",
"reconnected",
"to",
"the",
"preferred",
"peer",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/peerresolver/preferpeer/preferpeer.go#L72-L87 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/dispatcher/opts.go | WithLoadBalancePolicy | func WithLoadBalancePolicy(value lbp.LoadBalancePolicy) options.Opt {
return func(p options.Params) {
if setter, ok := p.(loadBalancePolicySetter); ok {
setter.SetLoadBalancePolicy(value)
}
}
} | go | func WithLoadBalancePolicy(value lbp.LoadBalancePolicy) options.Opt {
return func(p options.Params) {
if setter, ok := p.(loadBalancePolicySetter); ok {
setter.SetLoadBalancePolicy(value)
}
}
} | [
"func",
"WithLoadBalancePolicy",
"(",
"value",
"lbp",
".",
"LoadBalancePolicy",
")",
"options",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"options",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"loadBalancePolicySetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetLoadBalancePolicy",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithLoadBalancePolicy sets the load-balance policy to use when
// choosing an event endpoint from a set of endpoints | [
"WithLoadBalancePolicy",
"sets",
"the",
"load",
"-",
"balance",
"policy",
"to",
"use",
"when",
"choosing",
"an",
"event",
"endpoint",
"from",
"a",
"set",
"of",
"endpoints"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/dispatcher/opts.go#L53-L59 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/dispatcher/opts.go | WithPeerMonitorPeriod | func WithPeerMonitorPeriod(value time.Duration) options.Opt {
return func(p options.Params) {
if setter, ok := p.(peerMonitorPeriodSetter); ok {
setter.SetPeerMonitorPeriod(value)
}
}
} | go | func WithPeerMonitorPeriod(value time.Duration) options.Opt {
return func(p options.Params) {
if setter, ok := p.(peerMonitorPeriodSetter); ok {
setter.SetPeerMonitorPeriod(value)
}
}
} | [
"func",
"WithPeerMonitorPeriod",
"(",
"value",
"time",
".",
"Duration",
")",
"options",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"options",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"peerMonitorPeriodSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetPeerMonitorPeriod",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithPeerMonitorPeriod is the period with which the connected peer is monitored
// to see whether or not it should be disconnected. | [
"WithPeerMonitorPeriod",
"is",
"the",
"period",
"with",
"which",
"the",
"connected",
"peer",
"is",
"monitored",
"to",
"see",
"whether",
"or",
"not",
"it",
"should",
"be",
"disconnected",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/dispatcher/opts.go#L63-L69 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/dispatcher/opts.go | WithPeerResolver | func WithPeerResolver(value peerresolver.Provider) options.Opt {
return func(p options.Params) {
if setter, ok := p.(peerResolverSetter); ok {
setter.SetPeerResolver(value)
}
}
} | go | func WithPeerResolver(value peerresolver.Provider) options.Opt {
return func(p options.Params) {
if setter, ok := p.(peerResolverSetter); ok {
setter.SetPeerResolver(value)
}
}
} | [
"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. | [
"WithPeerResolver",
"sets",
"the",
"peer",
"resolver",
"that",
"chooses",
"the",
"peer",
"from",
"a",
"discovered",
"list",
"of",
"peers",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/dispatcher/opts.go#L72-L78 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/dynamicselection/pgresolver/mocks.go | NewPrincipal | func NewPrincipal(name string, classification mb.MSPPrincipal_Classification) (*mb.MSPPrincipal, error) {
member1Role, err := proto.Marshal(&mb.MSPRole{Role: mb.MSPRole_MEMBER, MspIdentifier: name})
if err != nil {
return nil, errors.WithMessage(err, "Error marshal MSPRole")
}
return &mb.MSPPrincipal{
PrincipalClassification: classification,
Principal: member1Role}, nil
} | go | func NewPrincipal(name string, classification mb.MSPPrincipal_Classification) (*mb.MSPPrincipal, error) {
member1Role, err := proto.Marshal(&mb.MSPRole{Role: mb.MSPRole_MEMBER, MspIdentifier: name})
if err != nil {
return nil, errors.WithMessage(err, "Error marshal MSPRole")
}
return &mb.MSPPrincipal{
PrincipalClassification: classification,
Principal: member1Role}, nil
} | [
"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",
",",
"\"Error marshal MSPRole\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"mb",
".",
"MSPPrincipal",
"{",
"PrincipalClassification",
":",
"classification",
",",
"Principal",
":",
"member1Role",
"}",
",",
"nil",
"\n",
"}"
] | // NewPrincipal creates a new MSPPrincipal | [
"NewPrincipal",
"creates",
"a",
"new",
"MSPPrincipal"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/dynamicselection/pgresolver/mocks.go#L17-L25 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/dynamicselection/pgresolver/mocks.go | NewSignedByPolicy | func NewSignedByPolicy(index int32) *common.SignaturePolicy {
return &common.SignaturePolicy{
Type: &common.SignaturePolicy_SignedBy{
SignedBy: index,
}}
} | go | func NewSignedByPolicy(index int32) *common.SignaturePolicy {
return &common.SignaturePolicy{
Type: &common.SignaturePolicy_SignedBy{
SignedBy: index,
}}
} | [
"func",
"NewSignedByPolicy",
"(",
"index",
"int32",
")",
"*",
"common",
".",
"SignaturePolicy",
"{",
"return",
"&",
"common",
".",
"SignaturePolicy",
"{",
"Type",
":",
"&",
"common",
".",
"SignaturePolicy_SignedBy",
"{",
"SignedBy",
":",
"index",
",",
"}",
"}",
"\n",
"}"
] | // NewSignedByPolicy creates a SignaturePolicy at the given index | [
"NewSignedByPolicy",
"creates",
"a",
"SignaturePolicy",
"at",
"the",
"given",
"index"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/dynamicselection/pgresolver/mocks.go#L28-L33 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/dynamicselection/pgresolver/mocks.go | NewNOutOfPolicy | func NewNOutOfPolicy(n int32, signedBy ...*common.SignaturePolicy) *common.SignaturePolicy {
return &common.SignaturePolicy{
Type: &common.SignaturePolicy_NOutOf_{
NOutOf: &common.SignaturePolicy_NOutOf{
N: n,
Rules: signedBy,
}}}
} | go | func NewNOutOfPolicy(n int32, signedBy ...*common.SignaturePolicy) *common.SignaturePolicy {
return &common.SignaturePolicy{
Type: &common.SignaturePolicy_NOutOf_{
NOutOf: &common.SignaturePolicy_NOutOf{
N: n,
Rules: signedBy,
}}}
} | [
"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 | [
"NewNOutOfPolicy",
"creates",
"an",
"NOutOf",
"signature",
"policy"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/dynamicselection/pgresolver/mocks.go#L36-L43 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/dynamicselection/pgresolver/mocks.go | GetPolicies | func GetPolicies(mspIDs ...string) (signedBy []*common.SignaturePolicy, identities []*mb.MSPPrincipal, err error) {
for i, mspID := range mspIDs {
signedBy = append(signedBy, NewSignedByPolicy(int32(i)))
principal, err := NewPrincipal(mspID, mb.MSPPrincipal_ROLE)
if err != nil {
return nil, nil, err
}
identities = append(identities, principal)
}
return
} | go | func GetPolicies(mspIDs ...string) (signedBy []*common.SignaturePolicy, identities []*mb.MSPPrincipal, err error) {
for i, mspID := range mspIDs {
signedBy = append(signedBy, NewSignedByPolicy(int32(i)))
principal, err := NewPrincipal(mspID, mb.MSPPrincipal_ROLE)
if err != nil {
return nil, nil, err
}
identities = append(identities, principal)
}
return
} | [
"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 | [
"GetPolicies",
"creates",
"a",
"set",
"of",
"signed",
"by",
"signature",
"policies",
"and",
"corresponding",
"identities",
"for",
"the",
"given",
"set",
"of",
"MSP",
"IDs"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/dynamicselection/pgresolver/mocks.go#L46-L56 | train |
hyperledger/fabric-sdk-go | pkg/msp/identitymgr.go | NewIdentityManager | func NewIdentityManager(orgName string, userStore msp.UserStore, cryptoSuite core.CryptoSuite, endpointConfig fab.EndpointConfig) (*IdentityManager, error) {
netConfig := endpointConfig.NetworkConfig()
// viper keys are case insensitive
orgConfig, ok := netConfig.Organizations[strings.ToLower(orgName)]
if !ok {
return nil, errors.New("org config retrieval failed")
}
if orgConfig.CryptoPath == "" && len(orgConfig.Users) == 0 {
return nil, errors.New("Either a cryptopath or an embedded list of users is required")
}
var mspPrivKeyStore core.KVStore
var mspCertStore core.KVStore
orgCryptoPathTemplate := orgConfig.CryptoPath
if orgCryptoPathTemplate != "" {
var err error
if !filepath.IsAbs(orgCryptoPathTemplate) {
orgCryptoPathTemplate = filepath.Join(endpointConfig.CryptoConfigPath(), orgCryptoPathTemplate)
}
mspPrivKeyStore, err = NewFileKeyStore(orgCryptoPathTemplate)
if err != nil {
return nil, errors.Wrap(err, "creating a private key store failed")
}
mspCertStore, err = NewFileCertStore(orgCryptoPathTemplate)
if err != nil {
return nil, errors.Wrap(err, "creating a cert store failed")
}
} else {
logger.Warnf("Cryptopath not provided for organization [%s], MSP stores not created", orgName)
}
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
}
return mgr, nil
} | go | func NewIdentityManager(orgName string, userStore msp.UserStore, cryptoSuite core.CryptoSuite, endpointConfig fab.EndpointConfig) (*IdentityManager, error) {
netConfig := endpointConfig.NetworkConfig()
// viper keys are case insensitive
orgConfig, ok := netConfig.Organizations[strings.ToLower(orgName)]
if !ok {
return nil, errors.New("org config retrieval failed")
}
if orgConfig.CryptoPath == "" && len(orgConfig.Users) == 0 {
return nil, errors.New("Either a cryptopath or an embedded list of users is required")
}
var mspPrivKeyStore core.KVStore
var mspCertStore core.KVStore
orgCryptoPathTemplate := orgConfig.CryptoPath
if orgCryptoPathTemplate != "" {
var err error
if !filepath.IsAbs(orgCryptoPathTemplate) {
orgCryptoPathTemplate = filepath.Join(endpointConfig.CryptoConfigPath(), orgCryptoPathTemplate)
}
mspPrivKeyStore, err = NewFileKeyStore(orgCryptoPathTemplate)
if err != nil {
return nil, errors.Wrap(err, "creating a private key store failed")
}
mspCertStore, err = NewFileCertStore(orgCryptoPathTemplate)
if err != nil {
return nil, errors.Wrap(err, "creating a cert store failed")
}
} else {
logger.Warnf("Cryptopath not provided for organization [%s], MSP stores not created", orgName)
}
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
}
return mgr, nil
} | [
"func",
"NewIdentityManager",
"(",
"orgName",
"string",
",",
"userStore",
"msp",
".",
"UserStore",
",",
"cryptoSuite",
"core",
".",
"CryptoSuite",
",",
"endpointConfig",
"fab",
".",
"EndpointConfig",
")",
"(",
"*",
"IdentityManager",
",",
"error",
")",
"{",
"netConfig",
":=",
"endpointConfig",
".",
"NetworkConfig",
"(",
")",
"\n",
"orgConfig",
",",
"ok",
":=",
"netConfig",
".",
"Organizations",
"[",
"strings",
".",
"ToLower",
"(",
"orgName",
")",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"org config retrieval failed\"",
")",
"\n",
"}",
"\n",
"if",
"orgConfig",
".",
"CryptoPath",
"==",
"\"\"",
"&&",
"len",
"(",
"orgConfig",
".",
"Users",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"Either a cryptopath or an embedded list of users is required\"",
")",
"\n",
"}",
"\n",
"var",
"mspPrivKeyStore",
"core",
".",
"KVStore",
"\n",
"var",
"mspCertStore",
"core",
".",
"KVStore",
"\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",
",",
"\"creating a private key store failed\"",
")",
"\n",
"}",
"\n",
"mspCertStore",
",",
"err",
"=",
"NewFileCertStore",
"(",
"orgCryptoPathTemplate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"creating a cert store failed\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"logger",
".",
"Warnf",
"(",
"\"Cryptopath not provided for organization [%s], MSP stores not created\"",
",",
"orgName",
")",
"\n",
"}",
"\n",
"mgr",
":=",
"&",
"IdentityManager",
"{",
"orgName",
":",
"orgName",
",",
"orgMSPID",
":",
"orgConfig",
".",
"MSPID",
",",
"config",
":",
"endpointConfig",
",",
"cryptoSuite",
":",
"cryptoSuite",
",",
"mspPrivKeyStore",
":",
"mspPrivKeyStore",
",",
"mspCertStore",
":",
"mspCertStore",
",",
"embeddedUsers",
":",
"orgConfig",
".",
"Users",
",",
"userStore",
":",
"userStore",
",",
"}",
"\n",
"return",
"mgr",
",",
"nil",
"\n",
"}"
] | // NewIdentityManager creates a new instance of IdentityManager | [
"NewIdentityManager",
"creates",
"a",
"new",
"instance",
"of",
"IdentityManager"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/msp/identitymgr.go#L33-L79 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockmspmanager.go | NewMockMSPManagerWithError | func NewMockMSPManagerWithError(msps map[string]msp.MSP, err error) *MockMSPManager {
return &MockMSPManager{MSPs: msps, Err: err}
} | go | func NewMockMSPManagerWithError(msps map[string]msp.MSP, err error) *MockMSPManager {
return &MockMSPManager{MSPs: msps, Err: err}
} | [
"func",
"NewMockMSPManagerWithError",
"(",
"msps",
"map",
"[",
"string",
"]",
"msp",
".",
"MSP",
",",
"err",
"error",
")",
"*",
"MockMSPManager",
"{",
"return",
"&",
"MockMSPManager",
"{",
"MSPs",
":",
"msps",
",",
"Err",
":",
"err",
"}",
"\n",
"}"
] | // NewMockMSPManagerWithError mockcore msp manager | [
"NewMockMSPManagerWithError",
"mockcore",
"msp",
"manager"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockmspmanager.go#L26-L28 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockmspmanager.go | GetMSPs | func (mgr *MockMSPManager) GetMSPs() (map[string]msp.MSP, error) {
if mgr.Err != nil && mgr.Err.Error() == "GetMSPs" {
return nil, mgr.Err
}
return mgr.MSPs, nil
} | go | func (mgr *MockMSPManager) GetMSPs() (map[string]msp.MSP, error) {
if mgr.Err != nil && mgr.Err.Error() == "GetMSPs" {
return nil, mgr.Err
}
return mgr.MSPs, nil
} | [
"func",
"(",
"mgr",
"*",
"MockMSPManager",
")",
"GetMSPs",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"msp",
".",
"MSP",
",",
"error",
")",
"{",
"if",
"mgr",
".",
"Err",
"!=",
"nil",
"&&",
"mgr",
".",
"Err",
".",
"Error",
"(",
")",
"==",
"\"GetMSPs\"",
"{",
"return",
"nil",
",",
"mgr",
".",
"Err",
"\n",
"}",
"\n",
"return",
"mgr",
".",
"MSPs",
",",
"nil",
"\n",
"}"
] | // GetMSPs Provides a list of Membership Service providers | [
"GetMSPs",
"Provides",
"a",
"list",
"of",
"Membership",
"Service",
"providers"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockmspmanager.go#L46-L52 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockidentitymgr.go | NewMockIdentityManager | func NewMockIdentityManager(opts ...UsersOption) msp.IdentityManager {
manager := MockIdentityManager{}
usersOptions := UsersOptions{}
for _, param := range opts {
err := param(&usersOptions)
if err != nil {
panic(fmt.Errorf("failed to create IdentityManager: %s", err))
}
}
if usersOptions.users != nil {
manager.users = usersOptions.users
} else {
manager.users = make(map[string]msp.SigningIdentity)
}
return &manager
} | go | func NewMockIdentityManager(opts ...UsersOption) msp.IdentityManager {
manager := MockIdentityManager{}
usersOptions := UsersOptions{}
for _, param := range opts {
err := param(&usersOptions)
if err != nil {
panic(fmt.Errorf("failed to create IdentityManager: %s", err))
}
}
if usersOptions.users != nil {
manager.users = usersOptions.users
} else {
manager.users = make(map[string]msp.SigningIdentity)
}
return &manager
} | [
"func",
"NewMockIdentityManager",
"(",
"opts",
"...",
"UsersOption",
")",
"msp",
".",
"IdentityManager",
"{",
"manager",
":=",
"MockIdentityManager",
"{",
"}",
"\n",
"usersOptions",
":=",
"UsersOptions",
"{",
"}",
"\n",
"for",
"_",
",",
"param",
":=",
"range",
"opts",
"{",
"err",
":=",
"param",
"(",
"&",
"usersOptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"failed to create IdentityManager: %s\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"usersOptions",
".",
"users",
"!=",
"nil",
"{",
"manager",
".",
"users",
"=",
"usersOptions",
".",
"users",
"\n",
"}",
"else",
"{",
"manager",
".",
"users",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"msp",
".",
"SigningIdentity",
")",
"\n",
"}",
"\n",
"return",
"&",
"manager",
"\n",
"}"
] | // NewMockIdentityManager Constructor for a identity manager. | [
"NewMockIdentityManager",
"Constructor",
"for",
"a",
"identity",
"manager",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockidentitymgr.go#L54-L73 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockidentitymgr.go | GetSigningIdentity | func (mgr *MockIdentityManager) GetSigningIdentity(id string) (msp.SigningIdentity, error) {
si, ok := mgr.users[id]
if !ok {
return nil, msp.ErrUserNotFound
}
return si, nil
} | go | func (mgr *MockIdentityManager) GetSigningIdentity(id string) (msp.SigningIdentity, error) {
si, ok := mgr.users[id]
if !ok {
return nil, msp.ErrUserNotFound
}
return si, nil
} | [
"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 | [
"GetSigningIdentity",
"will",
"return",
"an",
"identity",
"that",
"can",
"be",
"used",
"to",
"cryptographically",
"sign",
"an",
"object"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockidentitymgr.go#L76-L82 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockorderer.go | SendBroadcast | 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
}
select {
case err := <-o.BroadcastErrors:
return nil, err
default:
return nil, nil
}
} | go | 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
}
select {
case err := <-o.BroadcastErrors:
return nil, err
default:
return nil, nil
}
} | [
"func",
"(",
"o",
"*",
"MockOrderer",
")",
"SendBroadcast",
"(",
"ctx",
"reqContext",
".",
"Context",
",",
"envelope",
"*",
"fab",
".",
"SignedEnvelope",
")",
"(",
"*",
"common",
".",
"Status",
",",
"error",
")",
"{",
"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 | [
"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"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockorderer.go#L88-L99 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockevents.go | NewBlock | func NewBlock(channelID string, transactions ...*TxInfo) *cb.Block {
var data [][]byte
txValidationFlags := make([]uint8, len(transactions))
for i, txInfo := range transactions {
envBytes, err := proto.Marshal(newEnvelope(channelID, txInfo))
if err != nil {
panic(err)
}
data = append(data, envBytes)
txValidationFlags[i] = uint8(txInfo.TxValidationCode)
}
blockMetaData := make([][]byte, 4)
blockMetaData[cb.BlockMetadataIndex_TRANSACTIONS_FILTER] = txValidationFlags
return &cb.Block{
Header: &cb.BlockHeader{},
Metadata: &cb.BlockMetadata{Metadata: blockMetaData},
Data: &cb.BlockData{Data: data},
}
} | go | func NewBlock(channelID string, transactions ...*TxInfo) *cb.Block {
var data [][]byte
txValidationFlags := make([]uint8, len(transactions))
for i, txInfo := range transactions {
envBytes, err := proto.Marshal(newEnvelope(channelID, txInfo))
if err != nil {
panic(err)
}
data = append(data, envBytes)
txValidationFlags[i] = uint8(txInfo.TxValidationCode)
}
blockMetaData := make([][]byte, 4)
blockMetaData[cb.BlockMetadataIndex_TRANSACTIONS_FILTER] = txValidationFlags
return &cb.Block{
Header: &cb.BlockHeader{},
Metadata: &cb.BlockMetadata{Metadata: blockMetaData},
Data: &cb.BlockData{Data: data},
}
} | [
"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",
"blockMetaData",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"4",
")",
"\n",
"blockMetaData",
"[",
"cb",
".",
"BlockMetadataIndex_TRANSACTIONS_FILTER",
"]",
"=",
"txValidationFlags",
"\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 | [
"NewBlock",
"returns",
"a",
"new",
"mock",
"block",
"initialized",
"with",
"the",
"given",
"channel"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockevents.go#L16-L36 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockevents.go | NewTransaction | func NewTransaction(txID string, txValidationCode pb.TxValidationCode, headerType cb.HeaderType) *TxInfo {
return &TxInfo{
TxID: txID,
TxValidationCode: txValidationCode,
HeaderType: headerType,
}
} | go | func NewTransaction(txID string, txValidationCode pb.TxValidationCode, headerType cb.HeaderType) *TxInfo {
return &TxInfo{
TxID: txID,
TxValidationCode: txValidationCode,
HeaderType: headerType,
}
} | [
"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 | [
"NewTransaction",
"creates",
"a",
"new",
"transaction"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockevents.go#L50-L56 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockevents.go | NewTransactionWithCCEvent | 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,
}
} | go | 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,
}
} | [
"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 | [
"NewTransactionWithCCEvent",
"creates",
"a",
"new",
"transaction",
"with",
"the",
"given",
"chaincode",
"event"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockevents.go#L59-L68 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockevents.go | NewFilteredBlock | func NewFilteredBlock(channelID string, filteredTx ...*pb.FilteredTransaction) *pb.FilteredBlock {
return &pb.FilteredBlock{
ChannelId: channelID,
FilteredTransactions: filteredTx,
}
} | go | func NewFilteredBlock(channelID string, filteredTx ...*pb.FilteredTransaction) *pb.FilteredBlock {
return &pb.FilteredBlock{
ChannelId: channelID,
FilteredTransactions: filteredTx,
}
} | [
"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 | [
"NewFilteredBlock",
"returns",
"a",
"new",
"mock",
"filtered",
"block",
"initialized",
"with",
"the",
"given",
"channel",
"and",
"filtered",
"transactions"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockevents.go#L72-L77 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockevents.go | NewFilteredTx | func NewFilteredTx(txID string, txValidationCode pb.TxValidationCode) *pb.FilteredTransaction {
return &pb.FilteredTransaction{
Txid: txID,
TxValidationCode: txValidationCode,
}
} | go | func NewFilteredTx(txID string, txValidationCode pb.TxValidationCode) *pb.FilteredTransaction {
return &pb.FilteredTransaction{
Txid: txID,
TxValidationCode: txValidationCode,
}
} | [
"func",
"NewFilteredTx",
"(",
"txID",
"string",
",",
"txValidationCode",
"pb",
".",
"TxValidationCode",
")",
"*",
"pb",
".",
"FilteredTransaction",
"{",
"return",
"&",
"pb",
".",
"FilteredTransaction",
"{",
"Txid",
":",
"txID",
",",
"TxValidationCode",
":",
"txValidationCode",
",",
"}",
"\n",
"}"
] | // NewFilteredTx returns a new mock filtered transaction | [
"NewFilteredTx",
"returns",
"a",
"new",
"mock",
"filtered",
"transaction"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockevents.go#L80-L85 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockevents.go | NewFilteredTxWithCCEvent | 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,
},
},
},
},
},
}
} | go | 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,
},
},
},
},
},
}
} | [
"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 | [
"NewFilteredTxWithCCEvent",
"returns",
"a",
"new",
"mock",
"filtered",
"transaction",
"with",
"the",
"given",
"chaincode",
"event"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockevents.go#L89-L106 | train |
hyperledger/fabric-sdk-go | pkg/fab/orderer/orderer.go | New | func New(config fab.EndpointConfig, opts ...Option) (*Orderer, error) {
orderer := &Orderer{
config: config,
commManager: &defCommManager{},
}
for _, opt := range opts {
err := opt(orderer)
if err != nil {
return nil, err
}
}
var grpcOpts []grpc.DialOption
if orderer.kap.Time > 0 {
grpcOpts = append(grpcOpts, grpc.WithKeepaliveParams(orderer.kap))
}
grpcOpts = append(grpcOpts, grpc.WithDefaultCallOptions(grpc.WaitForReady(!orderer.failFast)))
if endpoint.AttemptSecured(orderer.url, orderer.allowInsecure) {
//tls config
tlsConfig, err := comm.TLSConfig(orderer.tlsCACert, orderer.serverName, config)
if err != nil {
return nil, err
}
tlsConfig.VerifyPeerCertificate = func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
return verifier.VerifyPeerCertificate(rawCerts, verifiedChains)
}
grpcOpts = append(grpcOpts, grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)))
} else {
grpcOpts = append(grpcOpts, grpc.WithInsecure())
}
grpcOpts = append(grpcOpts, grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(maxCallRecvMsgSize),
grpc.MaxCallSendMsgSize(maxCallSendMsgSize)))
orderer.dialTimeout = config.Timeout(fab.OrdererConnection)
orderer.url = endpoint.ToAddress(orderer.url)
orderer.grpcDialOption = grpcOpts
return orderer, nil
} | go | func New(config fab.EndpointConfig, opts ...Option) (*Orderer, error) {
orderer := &Orderer{
config: config,
commManager: &defCommManager{},
}
for _, opt := range opts {
err := opt(orderer)
if err != nil {
return nil, err
}
}
var grpcOpts []grpc.DialOption
if orderer.kap.Time > 0 {
grpcOpts = append(grpcOpts, grpc.WithKeepaliveParams(orderer.kap))
}
grpcOpts = append(grpcOpts, grpc.WithDefaultCallOptions(grpc.WaitForReady(!orderer.failFast)))
if endpoint.AttemptSecured(orderer.url, orderer.allowInsecure) {
//tls config
tlsConfig, err := comm.TLSConfig(orderer.tlsCACert, orderer.serverName, config)
if err != nil {
return nil, err
}
tlsConfig.VerifyPeerCertificate = func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
return verifier.VerifyPeerCertificate(rawCerts, verifiedChains)
}
grpcOpts = append(grpcOpts, grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)))
} else {
grpcOpts = append(grpcOpts, grpc.WithInsecure())
}
grpcOpts = append(grpcOpts, grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(maxCallRecvMsgSize),
grpc.MaxCallSendMsgSize(maxCallSendMsgSize)))
orderer.dialTimeout = config.Timeout(fab.OrdererConnection)
orderer.url = endpoint.ToAddress(orderer.url)
orderer.grpcDialOption = grpcOpts
return orderer, nil
} | [
"func",
"New",
"(",
"config",
"fab",
".",
"EndpointConfig",
",",
"opts",
"...",
"Option",
")",
"(",
"*",
"Orderer",
",",
"error",
")",
"{",
"orderer",
":=",
"&",
"Orderer",
"{",
"config",
":",
"config",
",",
"commManager",
":",
"&",
"defCommManager",
"{",
"}",
",",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"err",
":=",
"opt",
"(",
"orderer",
")",
"\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",
")",
"{",
"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",
"grpcOpts",
"=",
"append",
"(",
"grpcOpts",
",",
"grpc",
".",
"WithTransportCredentials",
"(",
"credentials",
".",
"NewTLS",
"(",
"tlsConfig",
")",
")",
")",
"\n",
"}",
"else",
"{",
"grpcOpts",
"=",
"append",
"(",
"grpcOpts",
",",
"grpc",
".",
"WithInsecure",
"(",
")",
")",
"\n",
"}",
"\n",
"grpcOpts",
"=",
"append",
"(",
"grpcOpts",
",",
"grpc",
".",
"WithDefaultCallOptions",
"(",
"grpc",
".",
"MaxCallRecvMsgSize",
"(",
"maxCallRecvMsgSize",
")",
",",
"grpc",
".",
"MaxCallSendMsgSize",
"(",
"maxCallSendMsgSize",
")",
")",
")",
"\n",
"orderer",
".",
"dialTimeout",
"=",
"config",
".",
"Timeout",
"(",
"fab",
".",
"OrdererConnection",
")",
"\n",
"orderer",
".",
"url",
"=",
"endpoint",
".",
"ToAddress",
"(",
"orderer",
".",
"url",
")",
"\n",
"orderer",
".",
"grpcDialOption",
"=",
"grpcOpts",
"\n",
"return",
"orderer",
",",
"nil",
"\n",
"}"
] | // New Returns a Orderer instance | [
"New",
"Returns",
"a",
"Orderer",
"instance"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L60-L101 | train |
hyperledger/fabric-sdk-go | pkg/fab/orderer/orderer.go | WithURL | func WithURL(url string) Option {
return func(o *Orderer) error {
o.url = url
return nil
}
} | go | func WithURL(url string) Option {
return func(o *Orderer) error {
o.url = url
return nil
}
} | [
"func",
"WithURL",
"(",
"url",
"string",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"Orderer",
")",
"error",
"{",
"o",
".",
"url",
"=",
"url",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithURL is a functional option for the orderer.New constructor that configures the orderer's URL. | [
"WithURL",
"is",
"a",
"functional",
"option",
"for",
"the",
"orderer",
".",
"New",
"constructor",
"that",
"configures",
"the",
"orderer",
"s",
"URL",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L104-L110 | train |
hyperledger/fabric-sdk-go | pkg/fab/orderer/orderer.go | WithTLSCert | func WithTLSCert(tlsCACert *x509.Certificate) Option {
return func(o *Orderer) error {
o.tlsCACert = tlsCACert
return nil
}
} | go | func WithTLSCert(tlsCACert *x509.Certificate) Option {
return func(o *Orderer) error {
o.tlsCACert = tlsCACert
return nil
}
} | [
"func",
"WithTLSCert",
"(",
"tlsCACert",
"*",
"x509",
".",
"Certificate",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"Orderer",
")",
"error",
"{",
"o",
".",
"tlsCACert",
"=",
"tlsCACert",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithTLSCert is a functional option for the orderer.New constructor that configures the orderer's TLS certificate | [
"WithTLSCert",
"is",
"a",
"functional",
"option",
"for",
"the",
"orderer",
".",
"New",
"constructor",
"that",
"configures",
"the",
"orderer",
"s",
"TLS",
"certificate"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L113-L119 | train |
hyperledger/fabric-sdk-go | pkg/fab/orderer/orderer.go | WithServerName | func WithServerName(serverName string) Option {
return func(o *Orderer) error {
o.serverName = serverName
return nil
}
} | go | func WithServerName(serverName string) Option {
return func(o *Orderer) error {
o.serverName = serverName
return nil
}
} | [
"func",
"WithServerName",
"(",
"serverName",
"string",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"Orderer",
")",
"error",
"{",
"o",
".",
"serverName",
"=",
"serverName",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithServerName is a functional option for the orderer.New constructor that configures the orderer's server name | [
"WithServerName",
"is",
"a",
"functional",
"option",
"for",
"the",
"orderer",
".",
"New",
"constructor",
"that",
"configures",
"the",
"orderer",
"s",
"server",
"name"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L122-L128 | train |
hyperledger/fabric-sdk-go | pkg/fab/orderer/orderer.go | FromOrdererConfig | func FromOrdererConfig(ordererCfg *fab.OrdererConfig) Option {
return func(o *Orderer) error {
o.url = ordererCfg.URL
o.tlsCACert = ordererCfg.TLSCACert
if ordererCfg.GRPCOptions["allow-insecure"] == false {
//verify if certificate was expired or not yet valid
err := verifier.ValidateCertificateDates(o.tlsCACert)
if err != nil {
//log this error
logger.Warn(err)
}
}
o.serverName = getServerNameOverride(ordererCfg)
o.kap = getKeepAliveOptions(ordererCfg)
o.failFast = getFailFast(ordererCfg)
o.allowInsecure = isInsecureConnectionAllowed(ordererCfg)
return nil
}
} | go | func FromOrdererConfig(ordererCfg *fab.OrdererConfig) Option {
return func(o *Orderer) error {
o.url = ordererCfg.URL
o.tlsCACert = ordererCfg.TLSCACert
if ordererCfg.GRPCOptions["allow-insecure"] == false {
//verify if certificate was expired or not yet valid
err := verifier.ValidateCertificateDates(o.tlsCACert)
if err != nil {
//log this error
logger.Warn(err)
}
}
o.serverName = getServerNameOverride(ordererCfg)
o.kap = getKeepAliveOptions(ordererCfg)
o.failFast = getFailFast(ordererCfg)
o.allowInsecure = isInsecureConnectionAllowed(ordererCfg)
return nil
}
} | [
"func",
"FromOrdererConfig",
"(",
"ordererCfg",
"*",
"fab",
".",
"OrdererConfig",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"Orderer",
")",
"error",
"{",
"o",
".",
"url",
"=",
"ordererCfg",
".",
"URL",
"\n",
"o",
".",
"tlsCACert",
"=",
"ordererCfg",
".",
"TLSCACert",
"\n",
"if",
"ordererCfg",
".",
"GRPCOptions",
"[",
"\"allow-insecure\"",
"]",
"==",
"false",
"{",
"err",
":=",
"verifier",
".",
"ValidateCertificateDates",
"(",
"o",
".",
"tlsCACert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warn",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"o",
".",
"serverName",
"=",
"getServerNameOverride",
"(",
"ordererCfg",
")",
"\n",
"o",
".",
"kap",
"=",
"getKeepAliveOptions",
"(",
"ordererCfg",
")",
"\n",
"o",
".",
"failFast",
"=",
"getFailFast",
"(",
"ordererCfg",
")",
"\n",
"o",
".",
"allowInsecure",
"=",
"isInsecureConnectionAllowed",
"(",
"ordererCfg",
")",
"\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 | [
"FromOrdererConfig",
"is",
"a",
"functional",
"option",
"for",
"the",
"orderer",
".",
"New",
"constructor",
"that",
"configures",
"a",
"new",
"orderer",
"from",
"a",
"apiconfig",
".",
"OrdererConfig",
"struct"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L141-L162 | train |
hyperledger/fabric-sdk-go | pkg/fab/orderer/orderer.go | FromOrdererName | func FromOrdererName(name string) Option {
return func(o *Orderer) error {
ordererCfg, found := o.config.OrdererConfig(name)
if !found {
return errors.Errorf("orderer config not found for orderer : %s", name)
}
return FromOrdererConfig(ordererCfg)(o)
}
} | go | func FromOrdererName(name string) Option {
return func(o *Orderer) error {
ordererCfg, found := o.config.OrdererConfig(name)
if !found {
return errors.Errorf("orderer config not found for orderer : %s", name)
}
return FromOrdererConfig(ordererCfg)(o)
}
} | [
"func",
"FromOrdererName",
"(",
"name",
"string",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"Orderer",
")",
"error",
"{",
"ordererCfg",
",",
"found",
":=",
"o",
".",
"config",
".",
"OrdererConfig",
"(",
"name",
")",
"\n",
"if",
"!",
"found",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"orderer config not found for orderer : %s\"",
",",
"name",
")",
"\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 | [
"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"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L166-L175 | train |
hyperledger/fabric-sdk-go | pkg/fab/orderer/orderer.go | SendBroadcast | func (o *Orderer) SendBroadcast(ctx reqContext.Context, envelope *fab.SignedEnvelope) (*common.Status, error) {
conn, err := o.conn(ctx)
if err != nil {
rpcStatus, ok := grpcstatus.FromError(err)
if ok {
return nil, errors.WithMessage(status.NewFromGRPCStatus(rpcStatus), "connection failed")
}
return nil, status.New(status.OrdererClientStatus, status.ConnectionFailed.ToInt32(), err.Error(), nil)
}
defer o.releaseConn(ctx, conn)
broadcastClient, err := ab.NewAtomicBroadcastClient(conn).Broadcast(ctx)
if err != nil {
rpcStatus, ok := grpcstatus.FromError(err)
if ok {
err = status.NewFromGRPCStatus(rpcStatus)
}
return nil, errors.Wrap(err, "NewAtomicBroadcastClient failed")
}
responses := make(chan common.Status)
errs := make(chan error, 1)
go broadcastStream(broadcastClient, responses, errs)
err = broadcastClient.Send(&common.Envelope{
Payload: envelope.Payload,
Signature: envelope.Signature,
})
if err != nil {
return nil, errors.Wrap(err, "failed to send envelope to orderer")
}
if err = broadcastClient.CloseSend(); err != nil {
logger.Debugf("unable to close broadcast client [%s]", err)
}
return wrapStreamStatusRPC(responses, errs)
} | go | func (o *Orderer) SendBroadcast(ctx reqContext.Context, envelope *fab.SignedEnvelope) (*common.Status, error) {
conn, err := o.conn(ctx)
if err != nil {
rpcStatus, ok := grpcstatus.FromError(err)
if ok {
return nil, errors.WithMessage(status.NewFromGRPCStatus(rpcStatus), "connection failed")
}
return nil, status.New(status.OrdererClientStatus, status.ConnectionFailed.ToInt32(), err.Error(), nil)
}
defer o.releaseConn(ctx, conn)
broadcastClient, err := ab.NewAtomicBroadcastClient(conn).Broadcast(ctx)
if err != nil {
rpcStatus, ok := grpcstatus.FromError(err)
if ok {
err = status.NewFromGRPCStatus(rpcStatus)
}
return nil, errors.Wrap(err, "NewAtomicBroadcastClient failed")
}
responses := make(chan common.Status)
errs := make(chan error, 1)
go broadcastStream(broadcastClient, responses, errs)
err = broadcastClient.Send(&common.Envelope{
Payload: envelope.Payload,
Signature: envelope.Signature,
})
if err != nil {
return nil, errors.Wrap(err, "failed to send envelope to orderer")
}
if err = broadcastClient.CloseSend(); err != nil {
logger.Debugf("unable to close broadcast client [%s]", err)
}
return wrapStreamStatusRPC(responses, errs)
} | [
"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",
")",
",",
"\"connection failed\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"status",
".",
"New",
"(",
"status",
".",
"OrdererClientStatus",
",",
"status",
".",
"ConnectionFailed",
".",
"ToInt32",
"(",
")",
",",
"err",
".",
"Error",
"(",
")",
",",
"nil",
")",
"\n",
"}",
"\n",
"defer",
"o",
".",
"releaseConn",
"(",
"ctx",
",",
"conn",
")",
"\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",
",",
"\"NewAtomicBroadcastClient failed\"",
")",
"\n",
"}",
"\n",
"responses",
":=",
"make",
"(",
"chan",
"common",
".",
"Status",
")",
"\n",
"errs",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"go",
"broadcastStream",
"(",
"broadcastClient",
",",
"responses",
",",
"errs",
")",
"\n",
"err",
"=",
"broadcastClient",
".",
"Send",
"(",
"&",
"common",
".",
"Envelope",
"{",
"Payload",
":",
"envelope",
".",
"Payload",
",",
"Signature",
":",
"envelope",
".",
"Signature",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"failed to send envelope to orderer\"",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"broadcastClient",
".",
"CloseSend",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Debugf",
"(",
"\"unable to close broadcast client [%s]\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"wrapStreamStatusRPC",
"(",
"responses",
",",
"errs",
")",
"\n",
"}"
] | // SendBroadcast Send the created transaction to Orderer. | [
"SendBroadcast",
"Send",
"the",
"created",
"transaction",
"to",
"Orderer",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L246-L284 | train |
hyperledger/fabric-sdk-go | pkg/fab/orderer/orderer.go | wrapStreamStatusRPC | func wrapStreamStatusRPC(responses chan common.Status, errs chan error) (*common.Status, error) {
var status common.Status
var err multi.Errors
read:
for {
select {
case s, ok := <-responses:
if !ok {
break read
}
status = s
case e := <-errs:
err = append(err, e)
}
}
// drain remaining errors.
for i := 0; i < len(errs); i++ {
e := <-errs
err = append(err, e)
}
return &status, err.ToError()
} | go | func wrapStreamStatusRPC(responses chan common.Status, errs chan error) (*common.Status, error) {
var status common.Status
var err multi.Errors
read:
for {
select {
case s, ok := <-responses:
if !ok {
break read
}
status = s
case e := <-errs:
err = append(err, e)
}
}
// drain remaining errors.
for i := 0; i < len(errs); i++ {
e := <-errs
err = append(err, e)
}
return &status, err.ToError()
} | [
"func",
"wrapStreamStatusRPC",
"(",
"responses",
"chan",
"common",
".",
"Status",
",",
"errs",
"chan",
"error",
")",
"(",
"*",
"common",
".",
"Status",
",",
"error",
")",
"{",
"var",
"status",
"common",
".",
"Status",
"\n",
"var",
"err",
"multi",
".",
"Errors",
"\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",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"errs",
")",
";",
"i",
"++",
"{",
"e",
":=",
"<-",
"errs",
"\n",
"err",
"=",
"append",
"(",
"err",
",",
"e",
")",
"\n",
"}",
"\n",
"return",
"&",
"status",
",",
"err",
".",
"ToError",
"(",
")",
"\n",
"}"
] | // wrapStreamStatusRPC returns the last response and err and blocks until the chan is closed. | [
"wrapStreamStatusRPC",
"returns",
"the",
"last",
"response",
"and",
"err",
"and",
"blocks",
"until",
"the",
"chan",
"is",
"closed",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L287-L311 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/numevents.go | NewReceived | func NewReceived(numBlock NumBlock, numChaincode NumChaincode) Received {
return Received{NumBlock: numBlock, NumChaincode: numChaincode}
} | go | func NewReceived(numBlock NumBlock, numChaincode NumChaincode) Received {
return Received{NumBlock: numBlock, NumChaincode: numChaincode}
} | [
"func",
"NewReceived",
"(",
"numBlock",
"NumBlock",
",",
"numChaincode",
"NumChaincode",
")",
"Received",
"{",
"return",
"Received",
"{",
"NumBlock",
":",
"numBlock",
",",
"NumChaincode",
":",
"numChaincode",
"}",
"\n",
"}"
] | // NewReceived returns a new Received struct | [
"NewReceived",
"returns",
"a",
"new",
"Received",
"struct"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/numevents.go#L48-L50 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/ledger.go | NewLedger | func NewLedger(chName string) (*Ledger, error) {
l := Ledger{
chName: chName,
}
return &l, nil
} | go | func NewLedger(chName string) (*Ledger, error) {
l := Ledger{
chName: chName,
}
return &l, nil
} | [
"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. | [
"NewLedger",
"constructs",
"a",
"Ledger",
"client",
"for",
"the",
"current",
"context",
"and",
"named",
"channel",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L45-L50 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/ledger.go | QueryBlockByHash | 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("blockHash is required")
}
cir := createBlockByHashInvokeRequest(c.chName, blockHash)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses, errors := getConfigBlocks(tprs)
errs = multi.Append(errs, errors)
return responses, errs
} | go | 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("blockHash is required")
}
cir := createBlockByHashInvokeRequest(c.chName, blockHash)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses, errors := getConfigBlocks(tprs)
errs = multi.Append(errs, errors)
return responses, errs
} | [
"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",
"(",
"\"blockHash is required\"",
")",
"\n",
"}",
"\n",
"cir",
":=",
"createBlockByHashInvokeRequest",
"(",
"c",
".",
"chName",
",",
"blockHash",
")",
"\n",
"tprs",
",",
"errs",
":=",
"queryChaincode",
"(",
"reqCtx",
",",
"c",
".",
"chName",
",",
"cir",
",",
"targets",
",",
"verifier",
")",
"\n",
"responses",
",",
"errors",
":=",
"getConfigBlocks",
"(",
"tprs",
")",
"\n",
"errs",
"=",
"multi",
".",
"Append",
"(",
"errs",
",",
"errors",
")",
"\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. | [
"QueryBlockByHash",
"queries",
"the",
"ledger",
"for",
"Block",
"by",
"block",
"hash",
".",
"This",
"query",
"will",
"be",
"made",
"to",
"specified",
"targets",
".",
"Returns",
"the",
"block",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L84-L97 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/ledger.go | QueryBlockByTxID | func (c *Ledger) QueryBlockByTxID(reqCtx reqContext.Context, txID fab.TransactionID, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.Block, error) {
if txID == "" {
return nil, errors.New("txID is required")
}
cir := createBlockByTxIDInvokeRequest(c.chName, txID)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses, errors := getConfigBlocks(tprs)
errs = multi.Append(errs, errors)
return responses, errs
} | go | func (c *Ledger) QueryBlockByTxID(reqCtx reqContext.Context, txID fab.TransactionID, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.Block, error) {
if txID == "" {
return nil, errors.New("txID is required")
}
cir := createBlockByTxIDInvokeRequest(c.chName, txID)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses, errors := getConfigBlocks(tprs)
errs = multi.Append(errs, errors)
return responses, errs
} | [
"func",
"(",
"c",
"*",
"Ledger",
")",
"QueryBlockByTxID",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"txID",
"fab",
".",
"TransactionID",
",",
"targets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
",",
"verifier",
"ResponseVerifier",
")",
"(",
"[",
"]",
"*",
"common",
".",
"Block",
",",
"error",
")",
"{",
"if",
"txID",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"txID is required\"",
")",
"\n",
"}",
"\n",
"cir",
":=",
"createBlockByTxIDInvokeRequest",
"(",
"c",
".",
"chName",
",",
"txID",
")",
"\n",
"tprs",
",",
"errs",
":=",
"queryChaincode",
"(",
"reqCtx",
",",
"c",
".",
"chName",
",",
"cir",
",",
"targets",
",",
"verifier",
")",
"\n",
"responses",
",",
"errors",
":=",
"getConfigBlocks",
"(",
"tprs",
")",
"\n",
"errs",
"=",
"multi",
".",
"Append",
"(",
"errs",
",",
"errors",
")",
"\n",
"return",
"responses",
",",
"errs",
"\n",
"}"
] | // QueryBlockByTxID returns a block which contains a transaction
// This query will be made to specified targets.
// Returns the block. | [
"QueryBlockByTxID",
"returns",
"a",
"block",
"which",
"contains",
"a",
"transaction",
"This",
"query",
"will",
"be",
"made",
"to",
"specified",
"targets",
".",
"Returns",
"the",
"block",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L102-L115 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/ledger.go | QueryTransaction | func (c *Ledger) QueryTransaction(reqCtx reqContext.Context, transactionID fab.TransactionID, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*pb.ProcessedTransaction, error) {
cir := createTransactionByIDInvokeRequest(c.chName, transactionID)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*pb.ProcessedTransaction{}
for _, tpr := range tprs {
r, err := createProcessedTransaction(tpr)
if err != nil {
errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
} else {
responses = append(responses, r)
}
}
return responses, errs
} | go | func (c *Ledger) QueryTransaction(reqCtx reqContext.Context, transactionID fab.TransactionID, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*pb.ProcessedTransaction, error) {
cir := createTransactionByIDInvokeRequest(c.chName, transactionID)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*pb.ProcessedTransaction{}
for _, tpr := range tprs {
r, err := createProcessedTransaction(tpr)
if err != nil {
errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
} else {
responses = append(responses, r)
}
}
return responses, errs
} | [
"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",
"responses",
":=",
"[",
"]",
"*",
"pb",
".",
"ProcessedTransaction",
"{",
"}",
"\n",
"for",
"_",
",",
"tpr",
":=",
"range",
"tprs",
"{",
"r",
",",
"err",
":=",
"createProcessedTransaction",
"(",
"tpr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multi",
".",
"Append",
"(",
"errs",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"From target: \"",
"+",
"tpr",
".",
"Endorser",
")",
")",
"\n",
"}",
"else",
"{",
"responses",
"=",
"append",
"(",
"responses",
",",
"r",
")",
"\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. | [
"QueryTransaction",
"queries",
"the",
"ledger",
"for",
"Transaction",
"by",
"number",
".",
"This",
"query",
"will",
"be",
"made",
"to",
"specified",
"targets",
".",
"Returns",
"the",
"ProcessedTransaction",
"information",
"containing",
"the",
"transaction",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L157-L173 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/ledger.go | QueryInstantiatedChaincodes | func (c *Ledger) QueryInstantiatedChaincodes(reqCtx reqContext.Context, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*pb.ChaincodeQueryResponse, error) {
cir := createChaincodeInvokeRequest()
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*pb.ChaincodeQueryResponse{}
for _, tpr := range tprs {
r, err := createChaincodeQueryResponse(tpr)
if err != nil {
errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
} else {
responses = append(responses, r)
}
}
return responses, errs
} | go | func (c *Ledger) QueryInstantiatedChaincodes(reqCtx reqContext.Context, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*pb.ChaincodeQueryResponse, error) {
cir := createChaincodeInvokeRequest()
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*pb.ChaincodeQueryResponse{}
for _, tpr := range tprs {
r, err := createChaincodeQueryResponse(tpr)
if err != nil {
errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
} else {
responses = append(responses, r)
}
}
return responses, errs
} | [
"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",
"responses",
":=",
"[",
"]",
"*",
"pb",
".",
"ChaincodeQueryResponse",
"{",
"}",
"\n",
"for",
"_",
",",
"tpr",
":=",
"range",
"tprs",
"{",
"r",
",",
"err",
":=",
"createChaincodeQueryResponse",
"(",
"tpr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multi",
".",
"Append",
"(",
"errs",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"From target: \"",
"+",
"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. | [
"QueryInstantiatedChaincodes",
"queries",
"the",
"instantiated",
"chaincodes",
"on",
"this",
"channel",
".",
"This",
"query",
"will",
"be",
"made",
"to",
"specified",
"targets",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L186-L200 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/ledger.go | QueryCollectionsConfig | func (c *Ledger) QueryCollectionsConfig(reqCtx reqContext.Context, chaincodeName string, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.CollectionConfigPackage, error) {
cir := createCollectionsConfigInvokeRequest(chaincodeName)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*common.CollectionConfigPackage{}
for _, tpr := range tprs {
r, err := createCollectionsConfigQueryResponse(tpr)
if err != nil {
errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
} else {
responses = append(responses, r)
}
}
return responses, errs
} | go | func (c *Ledger) QueryCollectionsConfig(reqCtx reqContext.Context, chaincodeName string, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.CollectionConfigPackage, error) {
cir := createCollectionsConfigInvokeRequest(chaincodeName)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*common.CollectionConfigPackage{}
for _, tpr := range tprs {
r, err := createCollectionsConfigQueryResponse(tpr)
if err != nil {
errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
} else {
responses = append(responses, r)
}
}
return responses, errs
} | [
"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",
"responses",
":=",
"[",
"]",
"*",
"common",
".",
"CollectionConfigPackage",
"{",
"}",
"\n",
"for",
"_",
",",
"tpr",
":=",
"range",
"tprs",
"{",
"r",
",",
"err",
":=",
"createCollectionsConfigQueryResponse",
"(",
"tpr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multi",
".",
"Append",
"(",
"errs",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"From target: \"",
"+",
"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. | [
"QueryCollectionsConfig",
"queries",
"the",
"collections",
"config",
"for",
"a",
"chaincode",
"on",
"this",
"channel",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L212-L226 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/ledger.go | QueryConfigBlock | func (c *Ledger) QueryConfigBlock(reqCtx reqContext.Context, targets []fab.ProposalProcessor, verifier ResponseVerifier) (*common.Block, error) {
if len(targets) == 0 {
return nil, errors.New("target(s) required")
}
cir := createConfigBlockInvokeRequest(c.chName)
tprs, err := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
if err != nil && len(tprs) == 0 {
return nil, errors.WithMessage(err, "queryChaincode failed")
}
matchErr := verifier.Match(tprs)
if matchErr != nil {
return nil, matchErr
}
return createCommonBlock(tprs[0])
} | go | func (c *Ledger) QueryConfigBlock(reqCtx reqContext.Context, targets []fab.ProposalProcessor, verifier ResponseVerifier) (*common.Block, error) {
if len(targets) == 0 {
return nil, errors.New("target(s) required")
}
cir := createConfigBlockInvokeRequest(c.chName)
tprs, err := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
if err != nil && len(tprs) == 0 {
return nil, errors.WithMessage(err, "queryChaincode failed")
}
matchErr := verifier.Match(tprs)
if matchErr != nil {
return nil, matchErr
}
return createCommonBlock(tprs[0])
} | [
"func",
"(",
"c",
"*",
"Ledger",
")",
"QueryConfigBlock",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"targets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
",",
"verifier",
"ResponseVerifier",
")",
"(",
"*",
"common",
".",
"Block",
",",
"error",
")",
"{",
"if",
"len",
"(",
"targets",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"target(s) required\"",
")",
"\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",
",",
"\"queryChaincode failed\"",
")",
"\n",
"}",
"\n",
"matchErr",
":=",
"verifier",
".",
"Match",
"(",
"tprs",
")",
"\n",
"if",
"matchErr",
"!=",
"nil",
"{",
"return",
"nil",
",",
"matchErr",
"\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 | [
"QueryConfigBlock",
"returns",
"the",
"current",
"configuration",
"block",
"for",
"the",
"specified",
"channel",
".",
"If",
"the",
"peer",
"doesn",
"t",
"belong",
"to",
"the",
"channel",
"return",
"error"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L239-L256 | train |
hyperledger/fabric-sdk-go | pkg/client/event/opts.go | WithBlockNum | func WithBlockNum(from uint64) ClientOption {
return func(c *Client) error {
c.fromBlock = from
return nil
}
} | go | func WithBlockNum(from uint64) ClientOption {
return func(c *Client) error {
c.fromBlock = from
return nil
}
} | [
"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 | [
"WithBlockNum",
"indicates",
"the",
"block",
"number",
"from",
"which",
"events",
"are",
"to",
"be",
"received",
".",
"Only",
"deliverclient",
"supports",
"this"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/event/opts.go#L25-L30 | train |
hyperledger/fabric-sdk-go | pkg/client/event/opts.go | WithSeekType | func WithSeekType(seek seek.Type) ClientOption {
return func(c *Client) error {
c.seekType = seek
return nil
}
} | go | func WithSeekType(seek seek.Type) ClientOption {
return func(c *Client) error {
c.seekType = seek
return nil
}
} | [
"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 | [
"WithSeekType",
"indicates",
"the",
"type",
"of",
"seek",
"desired",
"-",
"newest",
"oldest",
"or",
"from",
"given",
"block",
"Only",
"deliverclient",
"supports",
"this"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/event/opts.go#L34-L39 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockpeer.go | NewMockStatefulPeer | func NewMockStatefulPeer(name, url string, opts ...MockPeerOpt) *MockPeer {
p := &MockPeer{
MockPeer: fabmocks.NewMockPeer(name, url),
}
for _, opt := range opts {
opt(p)
}
return p
} | go | func NewMockStatefulPeer(name, url string, opts ...MockPeerOpt) *MockPeer {
p := &MockPeer{
MockPeer: fabmocks.NewMockPeer(name, url),
}
for _, opt := range opts {
opt(p)
}
return p
} | [
"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 | [
"NewMockStatefulPeer",
"returns",
"a",
"new",
"MockPeer",
"with",
"the",
"given",
"options"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockpeer.go#L40-L48 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockpeer.go | BlockHeight | func (p *MockPeer) BlockHeight() uint64 {
p.lock.RLock()
defer p.lock.RUnlock()
return p.blockHeight
} | go | func (p *MockPeer) BlockHeight() uint64 {
p.lock.RLock()
defer p.lock.RUnlock()
return p.blockHeight
} | [
"func",
"(",
"p",
"*",
"MockPeer",
")",
"BlockHeight",
"(",
")",
"uint64",
"{",
"p",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"p",
".",
"blockHeight",
"\n",
"}"
] | // BlockHeight returns the block height | [
"BlockHeight",
"returns",
"the",
"block",
"height"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockpeer.go#L60-L64 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockpeer.go | SetBlockHeight | func (p *MockPeer) SetBlockHeight(blockHeight uint64) {
p.lock.Lock()
defer p.lock.Unlock()
p.blockHeight = blockHeight
} | go | func (p *MockPeer) SetBlockHeight(blockHeight uint64) {
p.lock.Lock()
defer p.lock.Unlock()
p.blockHeight = blockHeight
} | [
"func",
"(",
"p",
"*",
"MockPeer",
")",
"SetBlockHeight",
"(",
"blockHeight",
"uint64",
")",
"{",
"p",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"p",
".",
"blockHeight",
"=",
"blockHeight",
"\n",
"}"
] | // SetBlockHeight sets the block height | [
"SetBlockHeight",
"sets",
"the",
"block",
"height"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockpeer.go#L67-L71 | train |
hyperledger/fabric-sdk-go | pkg/client/ledger/ledger.go | New | func New(channelProvider context.ChannelProvider, opts ...ClientOption) (*Client, error) {
channelContext, err := channelProvider()
if err != nil {
return nil, err
}
if channelContext.ChannelService() == nil {
return nil, errors.New("channel service not initialized")
}
membership, err := channelContext.ChannelService().Membership()
if err != nil {
return nil, errors.WithMessage(err, "membership creation failed")
}
ledger, err := channel.NewLedger(channelContext.ChannelID())
if err != nil {
return nil, err
}
ledgerFilter := filter.NewEndpointFilter(channelContext, filter.LedgerQuery)
discoveryService, err := channelContext.ChannelService().Discovery()
if err != nil {
return nil, err
}
// Apply filter to discovery service
discovery := discovery.NewDiscoveryFilterService(discoveryService, ledgerFilter)
ledgerClient := Client{
ctx: channelContext,
ledger: ledger,
verifier: &verifier.Signature{Membership: membership},
discovery: discovery,
}
for _, opt := range opts {
err := opt(&ledgerClient)
if err != nil {
return nil, err
}
}
// 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("mspID not available in user context")
}
filter := &mspFilter{mspID: channelContext.Identifier().MSPID}
ledgerClient.filter = filter
}
return &ledgerClient, nil
} | go | func New(channelProvider context.ChannelProvider, opts ...ClientOption) (*Client, error) {
channelContext, err := channelProvider()
if err != nil {
return nil, err
}
if channelContext.ChannelService() == nil {
return nil, errors.New("channel service not initialized")
}
membership, err := channelContext.ChannelService().Membership()
if err != nil {
return nil, errors.WithMessage(err, "membership creation failed")
}
ledger, err := channel.NewLedger(channelContext.ChannelID())
if err != nil {
return nil, err
}
ledgerFilter := filter.NewEndpointFilter(channelContext, filter.LedgerQuery)
discoveryService, err := channelContext.ChannelService().Discovery()
if err != nil {
return nil, err
}
// Apply filter to discovery service
discovery := discovery.NewDiscoveryFilterService(discoveryService, ledgerFilter)
ledgerClient := Client{
ctx: channelContext,
ledger: ledger,
verifier: &verifier.Signature{Membership: membership},
discovery: discovery,
}
for _, opt := range opts {
err := opt(&ledgerClient)
if err != nil {
return nil, err
}
}
// 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("mspID not available in user context")
}
filter := &mspFilter{mspID: channelContext.Identifier().MSPID}
ledgerClient.filter = filter
}
return &ledgerClient, nil
} | [
"func",
"New",
"(",
"channelProvider",
"context",
".",
"ChannelProvider",
",",
"opts",
"...",
"ClientOption",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"channelContext",
",",
"err",
":=",
"channelProvider",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"channelContext",
".",
"ChannelService",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"channel service not initialized\"",
")",
"\n",
"}",
"\n",
"membership",
",",
"err",
":=",
"channelContext",
".",
"ChannelService",
"(",
")",
".",
"Membership",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"membership creation failed\"",
")",
"\n",
"}",
"\n",
"ledger",
",",
"err",
":=",
"channel",
".",
"NewLedger",
"(",
"channelContext",
".",
"ChannelID",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"ledgerFilter",
":=",
"filter",
".",
"NewEndpointFilter",
"(",
"channelContext",
",",
"filter",
".",
"LedgerQuery",
")",
"\n",
"discoveryService",
",",
"err",
":=",
"channelContext",
".",
"ChannelService",
"(",
")",
".",
"Discovery",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"discovery",
":=",
"discovery",
".",
"NewDiscoveryFilterService",
"(",
"discoveryService",
",",
"ledgerFilter",
")",
"\n",
"ledgerClient",
":=",
"Client",
"{",
"ctx",
":",
"channelContext",
",",
"ledger",
":",
"ledger",
",",
"verifier",
":",
"&",
"verifier",
".",
"Signature",
"{",
"Membership",
":",
"membership",
"}",
",",
"discovery",
":",
"discovery",
",",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"err",
":=",
"opt",
"(",
"&",
"ledgerClient",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"ledgerClient",
".",
"filter",
"==",
"nil",
"{",
"if",
"channelContext",
".",
"Identifier",
"(",
")",
".",
"MSPID",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"mspID not available in user context\"",
")",
"\n",
"}",
"\n",
"filter",
":=",
"&",
"mspFilter",
"{",
"mspID",
":",
"channelContext",
".",
"Identifier",
"(",
")",
".",
"MSPID",
"}",
"\n",
"ledgerClient",
".",
"filter",
"=",
"filter",
"\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. | [
"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",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/ledger/ledger.go#L63-L119 | train |
hyperledger/fabric-sdk-go | pkg/client/ledger/ledger.go | prepareRequestOpts | func (c *Client) prepareRequestOpts(options ...RequestOption) (requestOptions, error) {
opts := requestOptions{}
for _, option := range options {
err := option(c.ctx, &opts)
if err != nil {
return opts, errors.WithMessage(err, "Failed to read request opts")
}
}
// Set defaults for max targets
if opts.MaxTargets == 0 {
opts.MaxTargets = maxTargets
}
// Set defaults for min targets/matches
if opts.MinTargets == 0 {
opts.MinTargets = minTargets
}
if opts.MinTargets > opts.MaxTargets {
opts.MaxTargets = opts.MinTargets
}
return opts, nil
} | go | func (c *Client) prepareRequestOpts(options ...RequestOption) (requestOptions, error) {
opts := requestOptions{}
for _, option := range options {
err := option(c.ctx, &opts)
if err != nil {
return opts, errors.WithMessage(err, "Failed to read request opts")
}
}
// Set defaults for max targets
if opts.MaxTargets == 0 {
opts.MaxTargets = maxTargets
}
// Set defaults for min targets/matches
if opts.MinTargets == 0 {
opts.MinTargets = minTargets
}
if opts.MinTargets > opts.MaxTargets {
opts.MaxTargets = opts.MinTargets
}
return opts, nil
} | [
"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",
",",
"\"Failed to read request opts\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"opts",
".",
"MaxTargets",
"==",
"0",
"{",
"opts",
".",
"MaxTargets",
"=",
"maxTargets",
"\n",
"}",
"\n",
"if",
"opts",
".",
"MinTargets",
"==",
"0",
"{",
"opts",
".",
"MinTargets",
"=",
"minTargets",
"\n",
"}",
"\n",
"if",
"opts",
".",
"MinTargets",
">",
"opts",
".",
"MaxTargets",
"{",
"opts",
".",
"MaxTargets",
"=",
"opts",
".",
"MinTargets",
"\n",
"}",
"\n",
"return",
"opts",
",",
"nil",
"\n",
"}"
] | //prepareRequestOpts Reads Opts from Option array | [
"prepareRequestOpts",
"Reads",
"Opts",
"from",
"Option",
"array"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/ledger/ledger.go#L334-L358 | train |
hyperledger/fabric-sdk-go | pkg/fabsdk/provider/chpvdr/cachekey.go | newCtxtCacheKey | func newCtxtCacheKey(ctx fab.ClientContext) (*ctxtCacheKey, error) {
identity, err := ctx.Serialize()
if err != nil {
return nil, err
}
h := sha256.New()
if _, err := h.Write(identity); err != nil {
return nil, err
}
hash := h.Sum(nil)
return &ctxtCacheKey{
key: string(hash),
context: ctx,
}, nil
} | go | func newCtxtCacheKey(ctx fab.ClientContext) (*ctxtCacheKey, error) {
identity, err := ctx.Serialize()
if err != nil {
return nil, err
}
h := sha256.New()
if _, err := h.Write(identity); err != nil {
return nil, err
}
hash := h.Sum(nil)
return &ctxtCacheKey{
key: string(hash),
context: ctx,
}, nil
} | [
"func",
"newCtxtCacheKey",
"(",
"ctx",
"fab",
".",
"ClientContext",
")",
"(",
"*",
"ctxtCacheKey",
",",
"error",
")",
"{",
"identity",
",",
"err",
":=",
"ctx",
".",
"Serialize",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"h",
":=",
"sha256",
".",
"New",
"(",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"h",
".",
"Write",
"(",
"identity",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"hash",
":=",
"h",
".",
"Sum",
"(",
"nil",
")",
"\n",
"return",
"&",
"ctxtCacheKey",
"{",
"key",
":",
"string",
"(",
"hash",
")",
",",
"context",
":",
"ctx",
",",
"}",
",",
"nil",
"\n",
"}"
] | // newCtxtCacheKey returns a new cacheKey | [
"newCtxtCacheKey",
"returns",
"a",
"new",
"cacheKey"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fabsdk/provider/chpvdr/cachekey.go#L24-L41 | train |
hyperledger/fabric-sdk-go | pkg/fabsdk/provider/chpvdr/cachekey.go | newEventCacheKey | func newEventCacheKey(chConfig fab.ChannelCfg, opts ...options.Opt) (*eventCacheKey, error) {
params := defaultParams()
options.Apply(params, opts)
h := sha256.New()
if _, err := h.Write([]byte(params.getOptKey())); err != nil {
return nil, err
}
hash := h.Sum([]byte(chConfig.ID()))
return &eventCacheKey{
channelConfig: chConfig,
key: string(hash),
opts: opts,
}, nil
} | go | func newEventCacheKey(chConfig fab.ChannelCfg, opts ...options.Opt) (*eventCacheKey, error) {
params := defaultParams()
options.Apply(params, opts)
h := sha256.New()
if _, err := h.Write([]byte(params.getOptKey())); err != nil {
return nil, err
}
hash := h.Sum([]byte(chConfig.ID()))
return &eventCacheKey{
channelConfig: chConfig,
key: string(hash),
opts: opts,
}, nil
} | [
"func",
"newEventCacheKey",
"(",
"chConfig",
"fab",
".",
"ChannelCfg",
",",
"opts",
"...",
"options",
".",
"Opt",
")",
"(",
"*",
"eventCacheKey",
",",
"error",
")",
"{",
"params",
":=",
"defaultParams",
"(",
")",
"\n",
"options",
".",
"Apply",
"(",
"params",
",",
"opts",
")",
"\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",
"return",
"&",
"eventCacheKey",
"{",
"channelConfig",
":",
"chConfig",
",",
"key",
":",
"string",
"(",
"hash",
")",
",",
"opts",
":",
"opts",
",",
"}",
",",
"nil",
"\n",
"}"
] | // newEventCacheKey returns a new eventCacheKey | [
"newEventCacheKey",
"returns",
"a",
"new",
"eventCacheKey"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fabsdk/provider/chpvdr/cachekey.go#L73-L88 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockconfig.go | CAConfig | func (c *MockConfig) CAConfig(org string) (*msp.CAConfig, bool) {
caConfig := msp.CAConfig{
CAName: "org1",
}
return &caConfig, true
} | go | func (c *MockConfig) CAConfig(org string) (*msp.CAConfig, bool) {
caConfig := msp.CAConfig{
CAName: "org1",
}
return &caConfig, true
} | [
"func",
"(",
"c",
"*",
"MockConfig",
")",
"CAConfig",
"(",
"org",
"string",
")",
"(",
"*",
"msp",
".",
"CAConfig",
",",
"bool",
")",
"{",
"caConfig",
":=",
"msp",
".",
"CAConfig",
"{",
"CAName",
":",
"\"org1\"",
",",
"}",
"\n",
"return",
"&",
"caConfig",
",",
"true",
"\n",
"}"
] | // CAConfig not implemented | [
"CAConfig",
"not",
"implemented"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L103-L109 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockconfig.go | Timeout | func (c *MockConfig) Timeout(arg fab.TimeoutType) time.Duration {
return time.Second * 10
} | go | func (c *MockConfig) Timeout(arg fab.TimeoutType) time.Duration {
return time.Second * 10
} | [
"func",
"(",
"c",
"*",
"MockConfig",
")",
"Timeout",
"(",
"arg",
"fab",
".",
"TimeoutType",
")",
"time",
".",
"Duration",
"{",
"return",
"time",
".",
"Second",
"*",
"10",
"\n",
"}"
] | //Timeout not implemented | [
"Timeout",
"not",
"implemented"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L127-L129 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockconfig.go | PeersConfig | func (c *MockConfig) PeersConfig(org string) ([]fab.PeerConfig, bool) {
return nil, false
} | go | func (c *MockConfig) PeersConfig(org string) ([]fab.PeerConfig, bool) {
return nil, false
} | [
"func",
"(",
"c",
"*",
"MockConfig",
")",
"PeersConfig",
"(",
"org",
"string",
")",
"(",
"[",
"]",
"fab",
".",
"PeerConfig",
",",
"bool",
")",
"{",
"return",
"nil",
",",
"false",
"\n",
"}"
] | // PeersConfig Retrieves the fabric peers from the config file provided | [
"PeersConfig",
"Retrieves",
"the",
"fabric",
"peers",
"from",
"the",
"config",
"file",
"provided"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L132-L134 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockconfig.go | PeerConfig | func (c *MockConfig) PeerConfig(nameOrURL string) (*fab.PeerConfig, bool) {
if nameOrURL == "invalid" {
return nil, false
}
if c.customPeerCfg != nil {
return c.customPeerCfg, true
}
cfg := fab.PeerConfig{
URL: "example.com",
}
return &cfg, true
} | go | func (c *MockConfig) PeerConfig(nameOrURL string) (*fab.PeerConfig, bool) {
if nameOrURL == "invalid" {
return nil, false
}
if c.customPeerCfg != nil {
return c.customPeerCfg, true
}
cfg := fab.PeerConfig{
URL: "example.com",
}
return &cfg, true
} | [
"func",
"(",
"c",
"*",
"MockConfig",
")",
"PeerConfig",
"(",
"nameOrURL",
"string",
")",
"(",
"*",
"fab",
".",
"PeerConfig",
",",
"bool",
")",
"{",
"if",
"nameOrURL",
"==",
"\"invalid\"",
"{",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n",
"if",
"c",
".",
"customPeerCfg",
"!=",
"nil",
"{",
"return",
"c",
".",
"customPeerCfg",
",",
"true",
"\n",
"}",
"\n",
"cfg",
":=",
"fab",
".",
"PeerConfig",
"{",
"URL",
":",
"\"example.com\"",
",",
"}",
"\n",
"return",
"&",
"cfg",
",",
"true",
"\n",
"}"
] | // PeerConfig Retrieves a specific peer from the configuration by org and name | [
"PeerConfig",
"Retrieves",
"a",
"specific",
"peer",
"from",
"the",
"configuration",
"by",
"org",
"and",
"name"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L137-L149 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockconfig.go | OrderersConfig | func (c *MockConfig) OrderersConfig() []fab.OrdererConfig {
oConfig, _ := c.OrdererConfig("")
return []fab.OrdererConfig{*oConfig}
} | go | func (c *MockConfig) OrderersConfig() []fab.OrdererConfig {
oConfig, _ := c.OrdererConfig("")
return []fab.OrdererConfig{*oConfig}
} | [
"func",
"(",
"c",
"*",
"MockConfig",
")",
"OrderersConfig",
"(",
")",
"[",
"]",
"fab",
".",
"OrdererConfig",
"{",
"oConfig",
",",
"_",
":=",
"c",
".",
"OrdererConfig",
"(",
"\"\"",
")",
"\n",
"return",
"[",
"]",
"fab",
".",
"OrdererConfig",
"{",
"*",
"oConfig",
"}",
"\n",
"}"
] | // OrderersConfig returns a list of defined orderers | [
"OrderersConfig",
"returns",
"a",
"list",
"of",
"defined",
"orderers"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L183-L186 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockconfig.go | OrdererConfig | func (c *MockConfig) OrdererConfig(name string) (*fab.OrdererConfig, bool) {
if name == "Invalid" {
return nil, false
}
if c.customOrdererCfg != nil {
return c.customOrdererCfg, true
}
oConfig := fab.OrdererConfig{
URL: "example.com",
}
return &oConfig, true
} | go | func (c *MockConfig) OrdererConfig(name string) (*fab.OrdererConfig, bool) {
if name == "Invalid" {
return nil, false
}
if c.customOrdererCfg != nil {
return c.customOrdererCfg, true
}
oConfig := fab.OrdererConfig{
URL: "example.com",
}
return &oConfig, true
} | [
"func",
"(",
"c",
"*",
"MockConfig",
")",
"OrdererConfig",
"(",
"name",
"string",
")",
"(",
"*",
"fab",
".",
"OrdererConfig",
",",
"bool",
")",
"{",
"if",
"name",
"==",
"\"Invalid\"",
"{",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n",
"if",
"c",
".",
"customOrdererCfg",
"!=",
"nil",
"{",
"return",
"c",
".",
"customOrdererCfg",
",",
"true",
"\n",
"}",
"\n",
"oConfig",
":=",
"fab",
".",
"OrdererConfig",
"{",
"URL",
":",
"\"example.com\"",
",",
"}",
"\n",
"return",
"&",
"oConfig",
",",
"true",
"\n",
"}"
] | // OrdererConfig not implemented | [
"OrdererConfig",
"not",
"implemented"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L209-L221 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockconfig.go | SetCustomChannelConfig | func (c *MockConfig) SetCustomChannelConfig(channelID string, config *fab.ChannelEndpointConfig) {
if c.chConfig == nil {
c.chConfig = make(map[string]*fab.ChannelEndpointConfig)
}
c.chConfig[channelID] = config
} | go | func (c *MockConfig) SetCustomChannelConfig(channelID string, config *fab.ChannelEndpointConfig) {
if c.chConfig == nil {
c.chConfig = make(map[string]*fab.ChannelEndpointConfig)
}
c.chConfig[channelID] = config
} | [
"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 | [
"SetCustomChannelConfig",
"sets",
"the",
"config",
"for",
"the",
"given",
"channel"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L268-L273 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockconfig.go | Lookup | func (c *MockConfig) Lookup(key string) (interface{}, bool) {
if key == "invalid" {
return nil, false
}
value, ok := c.Lookup(key)
if !ok {
return nil, false
}
return value, true
} | go | func (c *MockConfig) Lookup(key string) (interface{}, bool) {
if key == "invalid" {
return nil, false
}
value, ok := c.Lookup(key)
if !ok {
return nil, false
}
return value, true
} | [
"func",
"(",
"c",
"*",
"MockConfig",
")",
"Lookup",
"(",
"key",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"if",
"key",
"==",
"\"invalid\"",
"{",
"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 | [
"Lookup",
"gets",
"the",
"Value",
"from",
"config",
"file",
"by",
"Key"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L338-L347 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockbroadcastserver.go | Broadcast | func (m *MockBroadcastServer) Broadcast(server po.AtomicBroadcast_BroadcastServer) error {
res, err := server.Recv()
if err == io.EOF {
return nil
}
if err != nil {
return err
}
if m.BroadcastError != nil {
return m.BroadcastError
}
if m.BroadcastInternalServerError {
return server.Send(broadcastResponseError)
}
if m.BroadcastCustomResponse != nil {
return server.Send(m.BroadcastCustomResponse)
}
err = server.Send(broadcastResponseSuccess)
if err != nil {
return err
}
return m.mockBlockDelivery(res.Payload)
} | go | func (m *MockBroadcastServer) Broadcast(server po.AtomicBroadcast_BroadcastServer) error {
res, err := server.Recv()
if err == io.EOF {
return nil
}
if err != nil {
return err
}
if m.BroadcastError != nil {
return m.BroadcastError
}
if m.BroadcastInternalServerError {
return server.Send(broadcastResponseError)
}
if m.BroadcastCustomResponse != nil {
return server.Send(m.BroadcastCustomResponse)
}
err = server.Send(broadcastResponseSuccess)
if err != nil {
return err
}
return m.mockBlockDelivery(res.Payload)
} | [
"func",
"(",
"m",
"*",
"MockBroadcastServer",
")",
"Broadcast",
"(",
"server",
"po",
".",
"AtomicBroadcast_BroadcastServer",
")",
"error",
"{",
"res",
",",
"err",
":=",
"server",
".",
"Recv",
"(",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"m",
".",
"BroadcastError",
"!=",
"nil",
"{",
"return",
"m",
".",
"BroadcastError",
"\n",
"}",
"\n",
"if",
"m",
".",
"BroadcastInternalServerError",
"{",
"return",
"server",
".",
"Send",
"(",
"broadcastResponseError",
")",
"\n",
"}",
"\n",
"if",
"m",
".",
"BroadcastCustomResponse",
"!=",
"nil",
"{",
"return",
"server",
".",
"Send",
"(",
"m",
".",
"BroadcastCustomResponse",
")",
"\n",
"}",
"\n",
"err",
"=",
"server",
".",
"Send",
"(",
"broadcastResponseSuccess",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"m",
".",
"mockBlockDelivery",
"(",
"res",
".",
"Payload",
")",
"\n",
"}"
] | // Broadcast mock broadcast | [
"Broadcast",
"mock",
"broadcast"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockbroadcastserver.go#L59-L87 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockbroadcastserver.go | Deliver | func (m *MockBroadcastServer) Deliver(server po.AtomicBroadcast_DeliverServer) error {
if m.DeliverError != nil {
return m.DeliverError
}
if m.DeliverResponse != nil {
if _, err := server.Recv(); err != nil {
return err
}
if err := server.SendMsg(m.DeliverResponse); err != nil {
return err
}
return nil
}
if _, err := server.Recv(); err != nil {
return err
}
if err := server.Send(TestBlock); err != nil {
return err
}
return nil
} | go | func (m *MockBroadcastServer) Deliver(server po.AtomicBroadcast_DeliverServer) error {
if m.DeliverError != nil {
return m.DeliverError
}
if m.DeliverResponse != nil {
if _, err := server.Recv(); err != nil {
return err
}
if err := server.SendMsg(m.DeliverResponse); err != nil {
return err
}
return nil
}
if _, err := server.Recv(); err != nil {
return err
}
if err := server.Send(TestBlock); err != nil {
return err
}
return nil
} | [
"func",
"(",
"m",
"*",
"MockBroadcastServer",
")",
"Deliver",
"(",
"server",
"po",
".",
"AtomicBroadcast_DeliverServer",
")",
"error",
"{",
"if",
"m",
".",
"DeliverError",
"!=",
"nil",
"{",
"return",
"m",
".",
"DeliverError",
"\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",
"if",
"_",
",",
"err",
":=",
"server",
".",
"Recv",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"server",
".",
"Send",
"(",
"TestBlock",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Deliver mock deliver | [
"Deliver",
"mock",
"deliver"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockbroadcastserver.go#L134-L157 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockbroadcastserver.go | Start | func (m *MockBroadcastServer) Start(address string) string {
if m.srv != nil {
panic("MockBroadcastServer already started")
}
// pass in TLS creds if present
if m.Creds != nil {
m.srv = grpc.NewServer(grpc.Creds(m.Creds))
} else {
m.srv = grpc.NewServer()
}
lis, err := net.Listen("tcp", address)
if err != nil {
panic(fmt.Sprintf("Error starting BroadcastServer %s", err))
}
addr := lis.Addr().String()
test.Logf("Starting MockEventServer [%s]", addr)
po.RegisterAtomicBroadcastServer(m.srv, m)
m.wg.Add(1)
go func() {
defer m.wg.Done()
if err := m.srv.Serve(lis); err != nil {
test.Logf("StartMockBroadcastServer failed [%s]", err)
}
}()
return addr
} | go | func (m *MockBroadcastServer) Start(address string) string {
if m.srv != nil {
panic("MockBroadcastServer already started")
}
// pass in TLS creds if present
if m.Creds != nil {
m.srv = grpc.NewServer(grpc.Creds(m.Creds))
} else {
m.srv = grpc.NewServer()
}
lis, err := net.Listen("tcp", address)
if err != nil {
panic(fmt.Sprintf("Error starting BroadcastServer %s", err))
}
addr := lis.Addr().String()
test.Logf("Starting MockEventServer [%s]", addr)
po.RegisterAtomicBroadcastServer(m.srv, m)
m.wg.Add(1)
go func() {
defer m.wg.Done()
if err := m.srv.Serve(lis); err != nil {
test.Logf("StartMockBroadcastServer failed [%s]", err)
}
}()
return addr
} | [
"func",
"(",
"m",
"*",
"MockBroadcastServer",
")",
"Start",
"(",
"address",
"string",
")",
"string",
"{",
"if",
"m",
".",
"srv",
"!=",
"nil",
"{",
"panic",
"(",
"\"MockBroadcastServer already started\"",
")",
"\n",
"}",
"\n",
"if",
"m",
".",
"Creds",
"!=",
"nil",
"{",
"m",
".",
"srv",
"=",
"grpc",
".",
"NewServer",
"(",
"grpc",
".",
"Creds",
"(",
"m",
".",
"Creds",
")",
")",
"\n",
"}",
"else",
"{",
"m",
".",
"srv",
"=",
"grpc",
".",
"NewServer",
"(",
")",
"\n",
"}",
"\n",
"lis",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"tcp\"",
",",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"Error starting BroadcastServer %s\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"addr",
":=",
"lis",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
"\n",
"test",
".",
"Logf",
"(",
"\"Starting MockEventServer [%s]\"",
",",
"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",
"(",
"\"StartMockBroadcastServer failed [%s]\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"addr",
"\n",
"}"
] | // Start the mock broadcast server | [
"Start",
"the",
"mock",
"broadcast",
"server"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockbroadcastserver.go#L160-L189 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/sorter/blockheightsorter/blockheightsorter.go | New | func New(opts ...coptions.Opt) options.PeerSorter {
params := defaultParams()
coptions.Apply(params, opts)
sorter := &sorter{
params: params,
}
return func(peers []fab.Peer) []fab.Peer {
return sorter.Sort(peers)
}
} | go | func New(opts ...coptions.Opt) options.PeerSorter {
params := defaultParams()
coptions.Apply(params, opts)
sorter := &sorter{
params: params,
}
return func(peers []fab.Peer) []fab.Peer {
return sorter.Sort(peers)
}
} | [
"func",
"New",
"(",
"opts",
"...",
"coptions",
".",
"Opt",
")",
"options",
".",
"PeerSorter",
"{",
"params",
":=",
"defaultParams",
"(",
")",
"\n",
"coptions",
".",
"Apply",
"(",
"params",
",",
"opts",
")",
"\n",
"sorter",
":=",
"&",
"sorter",
"{",
"params",
":",
"params",
",",
"}",
"\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. | [
"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",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/sorter/blockheightsorter/blockheightsorter.go#L26-L37 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/sorter/blockheightsorter/blockheightsorter.go | Sort | func (f *sorter) Sort(peers []fab.Peer) []fab.Peer {
if len(peers) <= 1 {
return peers
}
if f.blockHeightLagThreshold < 0 {
logger.Debugf("Returning all peers")
return f.balancer(peers)
}
maxHeight := getMaxBlockHeight(peers)
logger.Debugf("Max block height of peers: %d", maxHeight)
if maxHeight <= uint64(f.blockHeightLagThreshold) {
logger.Debugf("Max block height of peers is %d and lag threshold is %d so returning peers unsorted", maxHeight, f.blockHeightLagThreshold)
return f.balancer(peers)
}
cutoffHeight := maxHeight - uint64(f.blockHeightLagThreshold)
logger.Debugf("Choosing peers whose block heights are greater than the cutoff height %d ...", cutoffHeight)
// preferredPeers are all of the peers that have the same priority
var preferredPeers []fab.Peer
// otherPeers are peers that did not make the cutoff
var otherPeers []fab.Peer
for _, p := range peers {
peerState, ok := p.(fab.PeerState)
if !ok {
logger.Debugf("Accepting peer [%s] since it does not have state (may be a local peer)", p.URL())
preferredPeers = append(preferredPeers, p)
} else if peerState.BlockHeight() >= cutoffHeight {
logger.Debugf("Accepting peer [%s] at block height %d which is greater than or equal to the cutoff %d", p.URL(), peerState.BlockHeight(), cutoffHeight)
preferredPeers = append(preferredPeers, p)
} else {
logger.Debugf("Rejecting peer [%s] at block height %d which is less than the cutoff %d", p.URL(), peerState.BlockHeight(), cutoffHeight)
otherPeers = append(otherPeers, p)
}
}
// Apply the balancer on the prefferred peers
preferredPeers = f.balancer(preferredPeers)
// Sort the remaining peers in reverse order of block height
sort.Sort(sort.Reverse(&peerSorter{
peers: otherPeers,
}))
return append(preferredPeers, otherPeers...)
} | go | func (f *sorter) Sort(peers []fab.Peer) []fab.Peer {
if len(peers) <= 1 {
return peers
}
if f.blockHeightLagThreshold < 0 {
logger.Debugf("Returning all peers")
return f.balancer(peers)
}
maxHeight := getMaxBlockHeight(peers)
logger.Debugf("Max block height of peers: %d", maxHeight)
if maxHeight <= uint64(f.blockHeightLagThreshold) {
logger.Debugf("Max block height of peers is %d and lag threshold is %d so returning peers unsorted", maxHeight, f.blockHeightLagThreshold)
return f.balancer(peers)
}
cutoffHeight := maxHeight - uint64(f.blockHeightLagThreshold)
logger.Debugf("Choosing peers whose block heights are greater than the cutoff height %d ...", cutoffHeight)
// preferredPeers are all of the peers that have the same priority
var preferredPeers []fab.Peer
// otherPeers are peers that did not make the cutoff
var otherPeers []fab.Peer
for _, p := range peers {
peerState, ok := p.(fab.PeerState)
if !ok {
logger.Debugf("Accepting peer [%s] since it does not have state (may be a local peer)", p.URL())
preferredPeers = append(preferredPeers, p)
} else if peerState.BlockHeight() >= cutoffHeight {
logger.Debugf("Accepting peer [%s] at block height %d which is greater than or equal to the cutoff %d", p.URL(), peerState.BlockHeight(), cutoffHeight)
preferredPeers = append(preferredPeers, p)
} else {
logger.Debugf("Rejecting peer [%s] at block height %d which is less than the cutoff %d", p.URL(), peerState.BlockHeight(), cutoffHeight)
otherPeers = append(otherPeers, p)
}
}
// Apply the balancer on the prefferred peers
preferredPeers = f.balancer(preferredPeers)
// Sort the remaining peers in reverse order of block height
sort.Sort(sort.Reverse(&peerSorter{
peers: otherPeers,
}))
return append(preferredPeers, otherPeers...)
} | [
"func",
"(",
"f",
"*",
"sorter",
")",
"Sort",
"(",
"peers",
"[",
"]",
"fab",
".",
"Peer",
")",
"[",
"]",
"fab",
".",
"Peer",
"{",
"if",
"len",
"(",
"peers",
")",
"<=",
"1",
"{",
"return",
"peers",
"\n",
"}",
"\n",
"if",
"f",
".",
"blockHeightLagThreshold",
"<",
"0",
"{",
"logger",
".",
"Debugf",
"(",
"\"Returning all peers\"",
")",
"\n",
"return",
"f",
".",
"balancer",
"(",
"peers",
")",
"\n",
"}",
"\n",
"maxHeight",
":=",
"getMaxBlockHeight",
"(",
"peers",
")",
"\n",
"logger",
".",
"Debugf",
"(",
"\"Max block height of peers: %d\"",
",",
"maxHeight",
")",
"\n",
"if",
"maxHeight",
"<=",
"uint64",
"(",
"f",
".",
"blockHeightLagThreshold",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"Max block height of peers is %d and lag threshold is %d so returning peers unsorted\"",
",",
"maxHeight",
",",
"f",
".",
"blockHeightLagThreshold",
")",
"\n",
"return",
"f",
".",
"balancer",
"(",
"peers",
")",
"\n",
"}",
"\n",
"cutoffHeight",
":=",
"maxHeight",
"-",
"uint64",
"(",
"f",
".",
"blockHeightLagThreshold",
")",
"\n",
"logger",
".",
"Debugf",
"(",
"\"Choosing peers whose block heights are greater than the cutoff height %d ...\"",
",",
"cutoffHeight",
")",
"\n",
"var",
"preferredPeers",
"[",
"]",
"fab",
".",
"Peer",
"\n",
"var",
"otherPeers",
"[",
"]",
"fab",
".",
"Peer",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"peers",
"{",
"peerState",
",",
"ok",
":=",
"p",
".",
"(",
"fab",
".",
"PeerState",
")",
"\n",
"if",
"!",
"ok",
"{",
"logger",
".",
"Debugf",
"(",
"\"Accepting peer [%s] since it does not have state (may be a local peer)\"",
",",
"p",
".",
"URL",
"(",
")",
")",
"\n",
"preferredPeers",
"=",
"append",
"(",
"preferredPeers",
",",
"p",
")",
"\n",
"}",
"else",
"if",
"peerState",
".",
"BlockHeight",
"(",
")",
">=",
"cutoffHeight",
"{",
"logger",
".",
"Debugf",
"(",
"\"Accepting peer [%s] at block height %d which is greater than or equal to the cutoff %d\"",
",",
"p",
".",
"URL",
"(",
")",
",",
"peerState",
".",
"BlockHeight",
"(",
")",
",",
"cutoffHeight",
")",
"\n",
"preferredPeers",
"=",
"append",
"(",
"preferredPeers",
",",
"p",
")",
"\n",
"}",
"else",
"{",
"logger",
".",
"Debugf",
"(",
"\"Rejecting peer [%s] at block height %d which is less than the cutoff %d\"",
",",
"p",
".",
"URL",
"(",
")",
",",
"peerState",
".",
"BlockHeight",
"(",
")",
",",
"cutoffHeight",
")",
"\n",
"otherPeers",
"=",
"append",
"(",
"otherPeers",
",",
"p",
")",
"\n",
"}",
"\n",
"}",
"\n",
"preferredPeers",
"=",
"f",
".",
"balancer",
"(",
"preferredPeers",
")",
"\n",
"sort",
".",
"Sort",
"(",
"sort",
".",
"Reverse",
"(",
"&",
"peerSorter",
"{",
"peers",
":",
"otherPeers",
",",
"}",
")",
")",
"\n",
"return",
"append",
"(",
"preferredPeers",
",",
"otherPeers",
"...",
")",
"\n",
"}"
] | // Sort sorts the given peers according to block height and lag threshold. | [
"Sort",
"sorts",
"the",
"given",
"peers",
"according",
"to",
"block",
"height",
"and",
"lag",
"threshold",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/sorter/blockheightsorter/blockheightsorter.go#L44-L95 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockdiscovery.go | CreateLocalDiscoveryService | func (dp *MockStaticDiscoveryProvider) CreateLocalDiscoveryService(mspID string) (fab.DiscoveryService, error) {
if dp.customDiscoveryService != nil {
return dp.customDiscoveryService, nil
}
return NewMockDiscoveryService(dp.Error, dp.Peers...), nil
} | go | func (dp *MockStaticDiscoveryProvider) CreateLocalDiscoveryService(mspID string) (fab.DiscoveryService, error) {
if dp.customDiscoveryService != nil {
return dp.customDiscoveryService, nil
}
return NewMockDiscoveryService(dp.Error, dp.Peers...), nil
} | [
"func",
"(",
"dp",
"*",
"MockStaticDiscoveryProvider",
")",
"CreateLocalDiscoveryService",
"(",
"mspID",
"string",
")",
"(",
"fab",
".",
"DiscoveryService",
",",
"error",
")",
"{",
"if",
"dp",
".",
"customDiscoveryService",
"!=",
"nil",
"{",
"return",
"dp",
".",
"customDiscoveryService",
",",
"nil",
"\n",
"}",
"\n",
"return",
"NewMockDiscoveryService",
"(",
"dp",
".",
"Error",
",",
"dp",
".",
"Peers",
"...",
")",
",",
"nil",
"\n",
"}"
] | // CreateLocalDiscoveryService return local discovery service | [
"CreateLocalDiscoveryService",
"return",
"local",
"discovery",
"service"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockdiscovery.go#L36-L43 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockdiscovery.go | GetPeers | func (ds *MockStaticDiscoveryService) GetPeers() ([]fab.Peer, error) {
if ds.Error != nil {
return nil, ds.Error
}
if ds.Peers == nil {
mockPeer := MockPeer{MockName: "Peer1", MockURL: "http://peer1.com", MockRoles: []string{}, MockCert: nil, MockMSP: "Org1MSP"}
peers := make([]fab.Peer, 0)
peers = append(peers, &mockPeer)
ds.Peers = peers
}
return ds.Peers, nil
} | go | func (ds *MockStaticDiscoveryService) GetPeers() ([]fab.Peer, error) {
if ds.Error != nil {
return nil, ds.Error
}
if ds.Peers == nil {
mockPeer := MockPeer{MockName: "Peer1", MockURL: "http://peer1.com", MockRoles: []string{}, MockCert: nil, MockMSP: "Org1MSP"}
peers := make([]fab.Peer, 0)
peers = append(peers, &mockPeer)
ds.Peers = peers
}
return ds.Peers, nil
} | [
"func",
"(",
"ds",
"*",
"MockStaticDiscoveryService",
")",
"GetPeers",
"(",
")",
"(",
"[",
"]",
"fab",
".",
"Peer",
",",
"error",
")",
"{",
"if",
"ds",
".",
"Error",
"!=",
"nil",
"{",
"return",
"nil",
",",
"ds",
".",
"Error",
"\n",
"}",
"\n",
"if",
"ds",
".",
"Peers",
"==",
"nil",
"{",
"mockPeer",
":=",
"MockPeer",
"{",
"MockName",
":",
"\"Peer1\"",
",",
"MockURL",
":",
"\"http://peer1.com\"",
",",
"MockRoles",
":",
"[",
"]",
"string",
"{",
"}",
",",
"MockCert",
":",
"nil",
",",
"MockMSP",
":",
"\"Org1MSP\"",
"}",
"\n",
"peers",
":=",
"make",
"(",
"[",
"]",
"fab",
".",
"Peer",
",",
"0",
")",
"\n",
"peers",
"=",
"append",
"(",
"peers",
",",
"&",
"mockPeer",
")",
"\n",
"ds",
".",
"Peers",
"=",
"peers",
"\n",
"}",
"\n",
"return",
"ds",
".",
"Peers",
",",
"nil",
"\n",
"}"
] | // GetPeers is used to discover eligible peers for chaincode | [
"GetPeers",
"is",
"used",
"to",
"discover",
"eligible",
"peers",
"for",
"chaincode"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockdiscovery.go#L56-L71 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/membership/cache.go | NewRefCache | func NewRefCache(refresh time.Duration) *lazycache.Cache {
initializer := func(key lazycache.Key) (interface{}, error) {
ck, ok := key.(CacheKey)
if !ok {
return nil, errors.New("unexpected cache key")
}
return NewRef(refresh, ck.Context(), ck.ChConfigRef()), nil
}
return lazycache.New("Membership_Cache", initializer)
} | go | func NewRefCache(refresh time.Duration) *lazycache.Cache {
initializer := func(key lazycache.Key) (interface{}, error) {
ck, ok := key.(CacheKey)
if !ok {
return nil, errors.New("unexpected cache key")
}
return NewRef(refresh, ck.Context(), ck.ChConfigRef()), nil
}
return lazycache.New("Membership_Cache", initializer)
} | [
"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",
"(",
"\"unexpected cache key\"",
")",
"\n",
"}",
"\n",
"return",
"NewRef",
"(",
"refresh",
",",
"ck",
".",
"Context",
"(",
")",
",",
"ck",
".",
"ChConfigRef",
"(",
")",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"lazycache",
".",
"New",
"(",
"\"Membership_Cache\"",
",",
"initializer",
")",
"\n",
"}"
] | // NewRefCache a cache of membership references that refreshed with the
// given interval | [
"NewRefCache",
"a",
"cache",
"of",
"membership",
"references",
"that",
"refreshed",
"with",
"the",
"given",
"interval"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/membership/cache.go#L50-L60 | train |
hyperledger/fabric-sdk-go | pkg/fabsdk/fabsdk_perf.go | initMetrics | func (sdk *FabricSDK) initMetrics(configs *configs) {
if configs == nil {
return
}
if sdk.system == nil {
sdk.system = newOperationsSystem(configs)
err := sdk.system.Start()
if err != nil {
panic("metrics failed to start: " + err.Error())
}
// for now NewClientMetrics supports channel client. TODO: if other client types require metrics tracking, update this function
sdk.clientMetrics = metrics.NewClientMetrics(sdk.system.Provider)
}
} | go | func (sdk *FabricSDK) initMetrics(configs *configs) {
if configs == nil {
return
}
if sdk.system == nil {
sdk.system = newOperationsSystem(configs)
err := sdk.system.Start()
if err != nil {
panic("metrics failed to start: " + err.Error())
}
// for now NewClientMetrics supports channel client. TODO: if other client types require metrics tracking, update this function
sdk.clientMetrics = metrics.NewClientMetrics(sdk.system.Provider)
}
} | [
"func",
"(",
"sdk",
"*",
"FabricSDK",
")",
"initMetrics",
"(",
"configs",
"*",
"configs",
")",
"{",
"if",
"configs",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"sdk",
".",
"system",
"==",
"nil",
"{",
"sdk",
".",
"system",
"=",
"newOperationsSystem",
"(",
"configs",
")",
"\n",
"err",
":=",
"sdk",
".",
"system",
".",
"Start",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"\"metrics failed to start: \"",
"+",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"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. | [
"initMetrics",
"will",
"initialize",
"the",
"Go",
"SDK",
"s",
"metric",
"s",
"system",
"instance",
"to",
"allow",
"capturing",
"metrics",
"data",
"by",
"the",
"SDK",
"clients",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fabsdk/fabsdk_perf.go#L18-L33 | train |
hyperledger/fabric-sdk-go | pkg/fab/comm/connector.go | NewCachingConnector | 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,
}
// 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
return &cc
} | go | 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,
}
// 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
return &cc
} | [
"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",
"cc",
".",
"janitorClosed",
"<-",
"true",
"\n",
"return",
"&",
"cc",
"\n",
"}"
] | // NewCachingConnector creates a GRPC connection cache. The cache is governed by
// sweepTime and idleTime. | [
"NewCachingConnector",
"creates",
"a",
"GRPC",
"connection",
"cache",
".",
"The",
"cache",
"is",
"governed",
"by",
"sweepTime",
"and",
"idleTime",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connector.go#L56-L73 | train |
hyperledger/fabric-sdk-go | pkg/fab/comm/connector.go | Close | func (cc *CachingConnector) Close() {
cc.lock.RLock()
// 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()
logger.Warn("Trying to close connector after already closed")
return
}
cc.lock.RUnlock()
logger.Debug("closing caching GRPC connector")
select {
case <-cc.janitorClosed:
logger.Debug("janitor not running")
default:
logger.Debug("janitor running")
cc.janitorDone <- true
cc.waitgroup.Wait()
}
cc.lock.Lock()
defer cc.lock.Unlock()
if len(cc.index) > 0 {
logger.Debugf("flushing connection cache with open connections [%d]", len(cc.index))
} else {
logger.Debug("flushing connection cache")
}
cc.flush()
close(cc.janitorClosed)
close(cc.janitorDone)
cc.janitorDone = nil
} | go | func (cc *CachingConnector) Close() {
cc.lock.RLock()
// 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()
logger.Warn("Trying to close connector after already closed")
return
}
cc.lock.RUnlock()
logger.Debug("closing caching GRPC connector")
select {
case <-cc.janitorClosed:
logger.Debug("janitor not running")
default:
logger.Debug("janitor running")
cc.janitorDone <- true
cc.waitgroup.Wait()
}
cc.lock.Lock()
defer cc.lock.Unlock()
if len(cc.index) > 0 {
logger.Debugf("flushing connection cache with open connections [%d]", len(cc.index))
} else {
logger.Debug("flushing connection cache")
}
cc.flush()
close(cc.janitorClosed)
close(cc.janitorDone)
cc.janitorDone = nil
} | [
"func",
"(",
"cc",
"*",
"CachingConnector",
")",
"Close",
"(",
")",
"{",
"cc",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"if",
"cc",
".",
"janitorDone",
"==",
"nil",
"{",
"cc",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"logger",
".",
"Warn",
"(",
"\"Trying to close connector after already closed\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"cc",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"logger",
".",
"Debug",
"(",
"\"closing caching GRPC connector\"",
")",
"\n",
"select",
"{",
"case",
"<-",
"cc",
".",
"janitorClosed",
":",
"logger",
".",
"Debug",
"(",
"\"janitor not running\"",
")",
"\n",
"default",
":",
"logger",
".",
"Debug",
"(",
"\"janitor running\"",
")",
"\n",
"cc",
".",
"janitorDone",
"<-",
"true",
"\n",
"cc",
".",
"waitgroup",
".",
"Wait",
"(",
")",
"\n",
"}",
"\n",
"cc",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cc",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"len",
"(",
"cc",
".",
"index",
")",
">",
"0",
"{",
"logger",
".",
"Debugf",
"(",
"\"flushing connection cache with open connections [%d]\"",
",",
"len",
"(",
"cc",
".",
"index",
")",
")",
"\n",
"}",
"else",
"{",
"logger",
".",
"Debug",
"(",
"\"flushing connection cache\"",
")",
"\n",
"}",
"\n",
"cc",
".",
"flush",
"(",
")",
"\n",
"close",
"(",
"cc",
".",
"janitorClosed",
")",
"\n",
"close",
"(",
"cc",
".",
"janitorDone",
")",
"\n",
"cc",
".",
"janitorDone",
"=",
"nil",
"\n",
"}"
] | // Close cleans up cached connections. | [
"Close",
"cleans",
"up",
"cached",
"connections",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connector.go#L76-L110 | train |
hyperledger/fabric-sdk-go | pkg/fab/comm/connector.go | DialContext | func (cc *CachingConnector) DialContext(ctx context.Context, target string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
logger.Debugf("DialContext: %s", target)
cc.lock.Lock()
c, ok := cc.loadConn(target)
if !ok {
createdConn, err := cc.createConn(ctx, target, opts...)
if err != nil {
cc.lock.Unlock()
return nil, errors.WithMessage(err, "connection creation failed")
}
c = createdConn
}
cc.lock.Unlock()
if err := cc.openConn(ctx, c); err != nil {
cc.lock.Lock()
setClosed(c)
cc.lock.Unlock()
return nil, errors.Errorf("dialing connection timed out [%s]", target)
}
return c.conn, nil
} | go | func (cc *CachingConnector) DialContext(ctx context.Context, target string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
logger.Debugf("DialContext: %s", target)
cc.lock.Lock()
c, ok := cc.loadConn(target)
if !ok {
createdConn, err := cc.createConn(ctx, target, opts...)
if err != nil {
cc.lock.Unlock()
return nil, errors.WithMessage(err, "connection creation failed")
}
c = createdConn
}
cc.lock.Unlock()
if err := cc.openConn(ctx, c); err != nil {
cc.lock.Lock()
setClosed(c)
cc.lock.Unlock()
return nil, errors.Errorf("dialing connection timed out [%s]", target)
}
return c.conn, nil
} | [
"func",
"(",
"cc",
"*",
"CachingConnector",
")",
"DialContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"target",
"string",
",",
"opts",
"...",
"grpc",
".",
"DialOption",
")",
"(",
"*",
"grpc",
".",
"ClientConn",
",",
"error",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"DialContext: %s\"",
",",
"target",
")",
"\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",
",",
"\"connection creation failed\"",
")",
"\n",
"}",
"\n",
"c",
"=",
"createdConn",
"\n",
"}",
"\n",
"cc",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"err",
":=",
"cc",
".",
"openConn",
"(",
"ctx",
",",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"cc",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"setClosed",
"(",
"c",
")",
"\n",
"cc",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"dialing connection timed out [%s]\"",
",",
"target",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"conn",
",",
"nil",
"\n",
"}"
] | // DialContext is a wrapper for grpc.DialContext where connections are cached. | [
"DialContext",
"is",
"a",
"wrapper",
"for",
"grpc",
".",
"DialContext",
"where",
"connections",
"are",
"cached",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connector.go#L113-L136 | train |
hyperledger/fabric-sdk-go | pkg/fab/comm/connector.go | ReleaseConn | func (cc *CachingConnector) ReleaseConn(conn *grpc.ClientConn) {
cc.lock.Lock()
defer cc.lock.Unlock()
// 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("Trying to release connection after connector closed")
if conn.GetState() != connectivity.Shutdown {
logger.Warn("Connection is not shutdown, trying to close ...")
if err := conn.Close(); err != nil {
logger.Warnf("conn close failed err %s", err)
}
}
return
}
cconn, ok := cc.index[conn]
if !ok {
logger.Warnf("connection not found [%p]", conn)
return
}
logger.Debugf("ReleaseConn [%s]", cconn.target)
setClosed(cconn)
cc.ensureJanitorStarted()
} | go | func (cc *CachingConnector) ReleaseConn(conn *grpc.ClientConn) {
cc.lock.Lock()
defer cc.lock.Unlock()
// 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("Trying to release connection after connector closed")
if conn.GetState() != connectivity.Shutdown {
logger.Warn("Connection is not shutdown, trying to close ...")
if err := conn.Close(); err != nil {
logger.Warnf("conn close failed err %s", err)
}
}
return
}
cconn, ok := cc.index[conn]
if !ok {
logger.Warnf("connection not found [%p]", conn)
return
}
logger.Debugf("ReleaseConn [%s]", cconn.target)
setClosed(cconn)
cc.ensureJanitorStarted()
} | [
"func",
"(",
"cc",
"*",
"CachingConnector",
")",
"ReleaseConn",
"(",
"conn",
"*",
"grpc",
".",
"ClientConn",
")",
"{",
"cc",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cc",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"cc",
".",
"janitorDone",
"==",
"nil",
"{",
"logger",
".",
"Warn",
"(",
"\"Trying to release connection after connector closed\"",
")",
"\n",
"if",
"conn",
".",
"GetState",
"(",
")",
"!=",
"connectivity",
".",
"Shutdown",
"{",
"logger",
".",
"Warn",
"(",
"\"Connection is not shutdown, trying to close ...\"",
")",
"\n",
"if",
"err",
":=",
"conn",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warnf",
"(",
"\"conn close failed err %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"cconn",
",",
"ok",
":=",
"cc",
".",
"index",
"[",
"conn",
"]",
"\n",
"if",
"!",
"ok",
"{",
"logger",
".",
"Warnf",
"(",
"\"connection not found [%p]\"",
",",
"conn",
")",
"\n",
"return",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"ReleaseConn [%s]\"",
",",
"cconn",
".",
"target",
")",
"\n",
"setClosed",
"(",
"cconn",
")",
"\n",
"cc",
".",
"ensureJanitorStarted",
"(",
")",
"\n",
"}"
] | // ReleaseConn notifies the cache that the connection is no longer in use. | [
"ReleaseConn",
"notifies",
"the",
"cache",
"that",
"the",
"connection",
"is",
"no",
"longer",
"in",
"use",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connector.go#L139-L167 | train |
hyperledger/fabric-sdk-go | pkg/client/channel/invoke/selectendorsehandler.go | NewSelectAndEndorseHandler | func NewSelectAndEndorseHandler(next ...Handler) Handler {
return &SelectAndEndorseHandler{
EndorsementHandler: NewEndorsementHandler(),
next: getNext(next),
}
} | go | func NewSelectAndEndorseHandler(next ...Handler) Handler {
return &SelectAndEndorseHandler{
EndorsementHandler: NewEndorsementHandler(),
next: getNext(next),
}
} | [
"func",
"NewSelectAndEndorseHandler",
"(",
"next",
"...",
"Handler",
")",
"Handler",
"{",
"return",
"&",
"SelectAndEndorseHandler",
"{",
"EndorsementHandler",
":",
"NewEndorsementHandler",
"(",
")",
",",
"next",
":",
"getNext",
"(",
"next",
")",
",",
"}",
"\n",
"}"
] | // NewSelectAndEndorseHandler returns a new SelectAndEndorseHandler | [
"NewSelectAndEndorseHandler",
"returns",
"a",
"new",
"SelectAndEndorseHandler"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/selectendorsehandler.go#L39-L44 | train |
hyperledger/fabric-sdk-go | pkg/client/channel/invoke/selectendorsehandler.go | Handle | func (e *SelectAndEndorseHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
var ccCalls []*fab.ChaincodeCall
targets := requestContext.Opts.Targets
if len(targets) == 0 {
var err error
ccCalls, requestContext.Opts.Targets, err = getEndorsers(requestContext, clientContext)
if err != nil {
requestContext.Error = err
return
}
}
e.EndorsementHandler.Handle(requestContext, clientContext)
if requestContext.Error != nil {
return
}
if len(targets) == 0 && len(requestContext.Response.Responses) > 0 {
additionalEndorsers, err := getAdditionalEndorsers(requestContext, clientContext, ccCalls)
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("error getting additional endorsers: %s", err)
} else {
if len(additionalEndorsers) > 0 {
requestContext.Opts.Targets = additionalEndorsers
logger.Debugf("...getting additional endorsements from %d target(s)", len(additionalEndorsers))
additionalResponses, err := clientContext.Transactor.SendTransactionProposal(requestContext.Response.Proposal, peer.PeersToTxnProcessors(additionalEndorsers))
if err != nil {
requestContext.Error = errors.WithMessage(err, "error sending transaction proposal")
return
}
// Add the new endorsements to the list of responses
requestContext.Response.Responses = append(requestContext.Response.Responses, additionalResponses...)
} else {
logger.Debugf("...no additional endorsements are required.")
}
}
}
if e.next != nil {
e.next.Handle(requestContext, clientContext)
}
} | go | func (e *SelectAndEndorseHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
var ccCalls []*fab.ChaincodeCall
targets := requestContext.Opts.Targets
if len(targets) == 0 {
var err error
ccCalls, requestContext.Opts.Targets, err = getEndorsers(requestContext, clientContext)
if err != nil {
requestContext.Error = err
return
}
}
e.EndorsementHandler.Handle(requestContext, clientContext)
if requestContext.Error != nil {
return
}
if len(targets) == 0 && len(requestContext.Response.Responses) > 0 {
additionalEndorsers, err := getAdditionalEndorsers(requestContext, clientContext, ccCalls)
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("error getting additional endorsers: %s", err)
} else {
if len(additionalEndorsers) > 0 {
requestContext.Opts.Targets = additionalEndorsers
logger.Debugf("...getting additional endorsements from %d target(s)", len(additionalEndorsers))
additionalResponses, err := clientContext.Transactor.SendTransactionProposal(requestContext.Response.Proposal, peer.PeersToTxnProcessors(additionalEndorsers))
if err != nil {
requestContext.Error = errors.WithMessage(err, "error sending transaction proposal")
return
}
// Add the new endorsements to the list of responses
requestContext.Response.Responses = append(requestContext.Response.Responses, additionalResponses...)
} else {
logger.Debugf("...no additional endorsements are required.")
}
}
}
if e.next != nil {
e.next.Handle(requestContext, clientContext)
}
} | [
"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",
"e",
".",
"EndorsementHandler",
".",
"Handle",
"(",
"requestContext",
",",
"clientContext",
")",
"\n",
"if",
"requestContext",
".",
"Error",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"len",
"(",
"targets",
")",
"==",
"0",
"&&",
"len",
"(",
"requestContext",
".",
"Response",
".",
"Responses",
")",
">",
"0",
"{",
"additionalEndorsers",
",",
"err",
":=",
"getAdditionalEndorsers",
"(",
"requestContext",
",",
"clientContext",
",",
"ccCalls",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warnf",
"(",
"\"error getting additional endorsers: %s\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"if",
"len",
"(",
"additionalEndorsers",
")",
">",
"0",
"{",
"requestContext",
".",
"Opts",
".",
"Targets",
"=",
"additionalEndorsers",
"\n",
"logger",
".",
"Debugf",
"(",
"\"...getting additional endorsements from %d target(s)\"",
",",
"len",
"(",
"additionalEndorsers",
")",
")",
"\n",
"additionalResponses",
",",
"err",
":=",
"clientContext",
".",
"Transactor",
".",
"SendTransactionProposal",
"(",
"requestContext",
".",
"Response",
".",
"Proposal",
",",
"peer",
".",
"PeersToTxnProcessors",
"(",
"additionalEndorsers",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"requestContext",
".",
"Error",
"=",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"error sending transaction proposal\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"requestContext",
".",
"Response",
".",
"Responses",
"=",
"append",
"(",
"requestContext",
".",
"Response",
".",
"Responses",
",",
"additionalResponses",
"...",
")",
"\n",
"}",
"else",
"{",
"logger",
".",
"Debugf",
"(",
"\"...no additional endorsements are required.\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"e",
".",
"next",
"!=",
"nil",
"{",
"e",
".",
"next",
".",
"Handle",
"(",
"requestContext",
",",
"clientContext",
")",
"\n",
"}",
"\n",
"}"
] | // Handle selects endorsers and sends proposals to the endorsers | [
"Handle",
"selects",
"endorsers",
"and",
"sends",
"proposals",
"to",
"the",
"endorsers"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/selectendorsehandler.go#L47-L92 | train |
hyperledger/fabric-sdk-go | pkg/client/channel/invoke/selectendorsehandler.go | NewChainedCCFilter | func NewChainedCCFilter(filters ...CCFilter) CCFilter {
return func(ccID string) bool {
for _, filter := range filters {
if !filter(ccID) {
return false
}
}
return true
}
} | go | func NewChainedCCFilter(filters ...CCFilter) CCFilter {
return func(ccID string) bool {
for _, filter := range filters {
if !filter(ccID) {
return false
}
}
return true
}
} | [
"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. | [
"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",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/selectendorsehandler.go#L97-L106 | train |
hyperledger/fabric-sdk-go | pkg/client/channel/invoke/selectendorsehandler.go | getCCCall | func getCCCall(invocChain []*fab.ChaincodeCall, ccID string) (*fab.ChaincodeCall, bool) {
for _, ccCall := range invocChain {
if ccCall.ID == ccID {
return ccCall, true
}
}
return nil, false
} | go | func getCCCall(invocChain []*fab.ChaincodeCall, ccID string) (*fab.ChaincodeCall, bool) {
for _, ccCall := range invocChain {
if ccCall.ID == ccID {
return ccCall, true
}
}
return nil, 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. | [
"getCC",
"returns",
"the",
"ChaincodeCall",
"from",
"the",
"invocation",
"chain",
"that",
"matches",
"the",
"chaincode",
"ID",
"or",
"returns",
"nil",
"if",
"the",
"ChaincodeCall",
"is",
"not",
"found",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/selectendorsehandler.go#L264-L271 | train |
hyperledger/fabric-sdk-go | pkg/client/channel/invoke/selectendorsehandler.go | merge | func merge(c1 *fab.ChaincodeCall, c2 *fab.ChaincodeCall) (*fab.ChaincodeCall, bool) {
c := &fab.ChaincodeCall{ID: c1.ID, Collections: c1.Collections}
merged := false
for _, coll := range c2.Collections {
if !contains(c.Collections, coll) {
c.Collections = append(c.Collections, coll)
merged = true
}
}
return c, merged
} | go | func merge(c1 *fab.ChaincodeCall, c2 *fab.ChaincodeCall) (*fab.ChaincodeCall, bool) {
c := &fab.ChaincodeCall{ID: c1.ID, Collections: c1.Collections}
merged := false
for _, coll := range c2.Collections {
if !contains(c.Collections, coll) {
c.Collections = append(c.Collections, coll)
merged = true
}
}
return c, merged
} | [
"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. | [
"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",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/selectendorsehandler.go#L275-L285 | train |
hyperledger/fabric-sdk-go | pkg/client/channel/invoke/selectendorsehandler.go | prioritizePeers | func prioritizePeers(peers []fab.Peer) selectopts.PrioritySelector {
return func(peer1, peer2 fab.Peer) int {
hasPeer1 := containsPeer(peers, peer1)
hasPeer2 := containsPeer(peers, peer2)
if hasPeer1 && hasPeer2 {
return 0
}
if hasPeer1 {
return 1
}
if hasPeer2 {
return -1
}
return 0
}
} | go | func prioritizePeers(peers []fab.Peer) selectopts.PrioritySelector {
return func(peer1, peer2 fab.Peer) int {
hasPeer1 := containsPeer(peers, peer1)
hasPeer2 := containsPeer(peers, peer2)
if hasPeer1 && hasPeer2 {
return 0
}
if hasPeer1 {
return 1
}
if hasPeer2 {
return -1
}
return 0
}
} | [
"func",
"prioritizePeers",
"(",
"peers",
"[",
"]",
"fab",
".",
"Peer",
")",
"selectopts",
".",
"PrioritySelector",
"{",
"return",
"func",
"(",
"peer1",
",",
"peer2",
"fab",
".",
"Peer",
")",
"int",
"{",
"hasPeer1",
":=",
"containsPeer",
"(",
"peers",
",",
"peer1",
")",
"\n",
"hasPeer2",
":=",
"containsPeer",
"(",
"peers",
",",
"peer2",
")",
"\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 | [
"prioritizePeers",
"is",
"a",
"priority",
"selector",
"that",
"gives",
"priority",
"to",
"the",
"peers",
"that",
"are",
"in",
"the",
"given",
"set"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/selectendorsehandler.go#L297-L313 | train |
hyperledger/fabric-sdk-go | pkg/util/concurrent/lazyref/lazyref.go | New | func New(initializer Initializer, opts ...options.Opt) *Reference {
return NewWithData(func(interface{}) (interface{}, error) {
return initializer()
}, opts...)
} | go | func New(initializer Initializer, opts ...options.Opt) *Reference {
return NewWithData(func(interface{}) (interface{}, error) {
return initializer()
}, opts...)
} | [
"func",
"New",
"(",
"initializer",
"Initializer",
",",
"opts",
"...",
"options",
".",
"Opt",
")",
"*",
"Reference",
"{",
"return",
"NewWithData",
"(",
"func",
"(",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"initializer",
"(",
")",
"\n",
"}",
",",
"opts",
"...",
")",
"\n",
"}"
] | // New creates a new reference | [
"New",
"creates",
"a",
"new",
"reference"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/util/concurrent/lazyref/lazyref.go#L88-L92 | train |
hyperledger/fabric-sdk-go | pkg/util/concurrent/lazyref/lazyref.go | NewWithData | func NewWithData(initializer InitializerWithData, opts ...options.Opt) *Reference {
lazyRef := &Reference{
params: params{
initialInit: InitOnFirstAccess,
},
initializer: initializer,
}
options.Apply(lazyRef, opts)
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
initialExpiration := lazyRef.expirationProvider()
lazyRef.initializer = func(data interface{}) (interface{}, error) {
value, err := initializer(data)
if err == nil {
lazyRef.ensureTimerStarted(initialExpiration)
}
return value, err
}
lazyRef.closech = make(chan bool, 1)
if lazyRef.expirationHandler == nil {
if lazyRef.expiryType == Refreshing {
lazyRef.expirationHandler = lazyRef.refreshValue
} else {
lazyRef.expirationHandler = lazyRef.resetValue
}
}
if lazyRef.initialInit >= 0 {
lazyRef.ensureTimerStarted(lazyRef.initialInit)
}
}
return lazyRef
} | go | func NewWithData(initializer InitializerWithData, opts ...options.Opt) *Reference {
lazyRef := &Reference{
params: params{
initialInit: InitOnFirstAccess,
},
initializer: initializer,
}
options.Apply(lazyRef, opts)
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
initialExpiration := lazyRef.expirationProvider()
lazyRef.initializer = func(data interface{}) (interface{}, error) {
value, err := initializer(data)
if err == nil {
lazyRef.ensureTimerStarted(initialExpiration)
}
return value, err
}
lazyRef.closech = make(chan bool, 1)
if lazyRef.expirationHandler == nil {
if lazyRef.expiryType == Refreshing {
lazyRef.expirationHandler = lazyRef.refreshValue
} else {
lazyRef.expirationHandler = lazyRef.resetValue
}
}
if lazyRef.initialInit >= 0 {
lazyRef.ensureTimerStarted(lazyRef.initialInit)
}
}
return lazyRef
} | [
"func",
"NewWithData",
"(",
"initializer",
"InitializerWithData",
",",
"opts",
"...",
"options",
".",
"Opt",
")",
"*",
"Reference",
"{",
"lazyRef",
":=",
"&",
"Reference",
"{",
"params",
":",
"params",
"{",
"initialInit",
":",
"InitOnFirstAccess",
",",
"}",
",",
"initializer",
":",
"initializer",
",",
"}",
"\n",
"options",
".",
"Apply",
"(",
"lazyRef",
",",
"opts",
")",
"\n",
"if",
"lazyRef",
".",
"expirationProvider",
"!=",
"nil",
"{",
"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",
"lazyRef",
".",
"closech",
"=",
"make",
"(",
"chan",
"bool",
",",
"1",
")",
"\n",
"if",
"lazyRef",
".",
"expirationHandler",
"==",
"nil",
"{",
"if",
"lazyRef",
".",
"expiryType",
"==",
"Refreshing",
"{",
"lazyRef",
".",
"expirationHandler",
"=",
"lazyRef",
".",
"refreshValue",
"\n",
"}",
"else",
"{",
"lazyRef",
".",
"expirationHandler",
"=",
"lazyRef",
".",
"resetValue",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"lazyRef",
".",
"initialInit",
">=",
"0",
"{",
"lazyRef",
".",
"ensureTimerStarted",
"(",
"lazyRef",
".",
"initialInit",
")",
"\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. | [
"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",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/util/concurrent/lazyref/lazyref.go#L97-L136 | train |
hyperledger/fabric-sdk-go | pkg/util/concurrent/lazyref/lazyref.go | Get | func (r *Reference) Get(data ...interface{}) (interface{}, error) {
if r.IsClosed() {
return nil, errors.New("reference is already closed")
}
// Try outside of a lock
if value, ok := r.get(); ok {
return value, nil
}
r.lock.Lock()
defer r.lock.Unlock()
// Try again inside the lock
if value, ok := r.get(); ok {
return value, nil
}
// Value hasn't been set yet
value, err := r.initializer(first(data))
if err != nil {
return nil, err
}
r.set(value)
return value, nil
} | go | func (r *Reference) Get(data ...interface{}) (interface{}, error) {
if r.IsClosed() {
return nil, errors.New("reference is already closed")
}
// Try outside of a lock
if value, ok := r.get(); ok {
return value, nil
}
r.lock.Lock()
defer r.lock.Unlock()
// Try again inside the lock
if value, ok := r.get(); ok {
return value, nil
}
// Value hasn't been set yet
value, err := r.initializer(first(data))
if err != nil {
return nil, err
}
r.set(value)
return value, nil
} | [
"func",
"(",
"r",
"*",
"Reference",
")",
"Get",
"(",
"data",
"...",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"r",
".",
"IsClosed",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"reference is already closed\"",
")",
"\n",
"}",
"\n",
"if",
"value",
",",
"ok",
":=",
"r",
".",
"get",
"(",
")",
";",
"ok",
"{",
"return",
"value",
",",
"nil",
"\n",
"}",
"\n",
"r",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"value",
",",
"ok",
":=",
"r",
".",
"get",
"(",
")",
";",
"ok",
"{",
"return",
"value",
",",
"nil",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"r",
".",
"initializer",
"(",
"first",
"(",
"data",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"r",
".",
"set",
"(",
"value",
")",
"\n",
"return",
"value",
",",
"nil",
"\n",
"}"
] | // Get returns the value, or an error if the initialiser returned an error. | [
"Get",
"returns",
"the",
"value",
"or",
"an",
"error",
"if",
"the",
"initialiser",
"returned",
"an",
"error",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/util/concurrent/lazyref/lazyref.go#L144-L170 | train |
hyperledger/fabric-sdk-go | pkg/util/concurrent/lazyref/lazyref.go | MustGet | func (r *Reference) MustGet() interface{} {
value, err := r.Get()
if err != nil {
panic(fmt.Sprintf("error returned from Get: %s", err))
}
return value
} | go | func (r *Reference) MustGet() interface{} {
value, err := r.Get()
if err != nil {
panic(fmt.Sprintf("error returned from Get: %s", err))
}
return value
} | [
"func",
"(",
"r",
"*",
"Reference",
")",
"MustGet",
"(",
")",
"interface",
"{",
"}",
"{",
"value",
",",
"err",
":=",
"r",
".",
"Get",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"error returned from Get: %s\"",
",",
"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. | [
"MustGet",
"returns",
"the",
"value",
".",
"If",
"an",
"error",
"is",
"returned",
"during",
"initialization",
"of",
"the",
"value",
"then",
"this",
"function",
"will",
"panic",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/util/concurrent/lazyref/lazyref.go#L175-L181 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/metadata/level.go | GetLevel | func (l *ModuleLevels) GetLevel(module string) api.Level {
level, exists := l.levels[module]
if !exists {
level, exists = l.levels[""]
// no configuration exists, default to info
if !exists {
level = api.INFO
}
}
return level
} | go | func (l *ModuleLevels) GetLevel(module string) api.Level {
level, exists := l.levels[module]
if !exists {
level, exists = l.levels[""]
// no configuration exists, default to info
if !exists {
level = api.INFO
}
}
return level
} | [
"func",
"(",
"l",
"*",
"ModuleLevels",
")",
"GetLevel",
"(",
"module",
"string",
")",
"api",
".",
"Level",
"{",
"level",
",",
"exists",
":=",
"l",
".",
"levels",
"[",
"module",
"]",
"\n",
"if",
"!",
"exists",
"{",
"level",
",",
"exists",
"=",
"l",
".",
"levels",
"[",
"\"\"",
"]",
"\n",
"if",
"!",
"exists",
"{",
"level",
"=",
"api",
".",
"INFO",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"level",
"\n",
"}"
] | // GetLevel returns the log level for the given module. | [
"GetLevel",
"returns",
"the",
"log",
"level",
"for",
"the",
"given",
"module",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/metadata/level.go#L17-L27 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/metadata/level.go | SetLevel | func (l *ModuleLevels) SetLevel(module string, level api.Level) {
if l.levels == nil {
l.levels = make(map[string]api.Level)
}
l.levels[module] = level
} | go | func (l *ModuleLevels) SetLevel(module string, level api.Level) {
if l.levels == nil {
l.levels = make(map[string]api.Level)
}
l.levels[module] = level
} | [
"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. | [
"SetLevel",
"sets",
"the",
"log",
"level",
"for",
"the",
"given",
"module",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/metadata/level.go#L30-L35 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/metadata/level.go | IsEnabledFor | func (l *ModuleLevels) IsEnabledFor(module string, level api.Level) bool {
return level <= l.GetLevel(module)
} | go | func (l *ModuleLevels) IsEnabledFor(module string, level api.Level) bool {
return level <= l.GetLevel(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. | [
"IsEnabledFor",
"will",
"return",
"true",
"if",
"logging",
"is",
"enabled",
"for",
"the",
"given",
"module",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/metadata/level.go#L38-L40 | train |
hyperledger/fabric-sdk-go | pkg/fab/chconfig/reference.go | NewRef | func NewRef(ctx fab.ClientContext, pvdr Provider, channel string, opts ...options.Opt) *Ref {
params := newDefaultParams()
options.Apply(params, opts)
cfgRef := &Ref{
pvdr: pvdr,
ctx: ctx,
channelID: channel,
errHandler: params.errHandler,
}
cfgRef.Reference = lazyref.New(
cfgRef.initializer(),
lazyref.WithRefreshInterval(lazyref.InitImmediately, params.refreshInterval),
)
return cfgRef
} | go | func NewRef(ctx fab.ClientContext, pvdr Provider, channel string, opts ...options.Opt) *Ref {
params := newDefaultParams()
options.Apply(params, opts)
cfgRef := &Ref{
pvdr: pvdr,
ctx: ctx,
channelID: channel,
errHandler: params.errHandler,
}
cfgRef.Reference = lazyref.New(
cfgRef.initializer(),
lazyref.WithRefreshInterval(lazyref.InitImmediately, params.refreshInterval),
)
return cfgRef
} | [
"func",
"NewRef",
"(",
"ctx",
"fab",
".",
"ClientContext",
",",
"pvdr",
"Provider",
",",
"channel",
"string",
",",
"opts",
"...",
"options",
".",
"Opt",
")",
"*",
"Ref",
"{",
"params",
":=",
"newDefaultParams",
"(",
")",
"\n",
"options",
".",
"Apply",
"(",
"params",
",",
"opts",
")",
"\n",
"cfgRef",
":=",
"&",
"Ref",
"{",
"pvdr",
":",
"pvdr",
",",
"ctx",
":",
"ctx",
",",
"channelID",
":",
"channel",
",",
"errHandler",
":",
"params",
".",
"errHandler",
",",
"}",
"\n",
"cfgRef",
".",
"Reference",
"=",
"lazyref",
".",
"New",
"(",
"cfgRef",
".",
"initializer",
"(",
")",
",",
"lazyref",
".",
"WithRefreshInterval",
"(",
"lazyref",
".",
"InitImmediately",
",",
"params",
".",
"refreshInterval",
")",
",",
")",
"\n",
"return",
"cfgRef",
"\n",
"}"
] | // NewRef returns a new channel config reference | [
"NewRef",
"returns",
"a",
"new",
"channel",
"config",
"reference"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/chconfig/reference.go#L30-L47 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/client.go | New | func New(dispatcher eventservice.Dispatcher, opts ...options.Opt) *Client {
params := defaultParams()
options.Apply(params, opts)
return &Client{
Service: eventservice.New(dispatcher, opts...),
params: *params,
connectionState: int32(Disconnected),
}
} | go | func New(dispatcher eventservice.Dispatcher, opts ...options.Opt) *Client {
params := defaultParams()
options.Apply(params, opts)
return &Client{
Service: eventservice.New(dispatcher, opts...),
params: *params,
connectionState: int32(Disconnected),
}
} | [
"func",
"New",
"(",
"dispatcher",
"eventservice",
".",
"Dispatcher",
",",
"opts",
"...",
"options",
".",
"Opt",
")",
"*",
"Client",
"{",
"params",
":=",
"defaultParams",
"(",
")",
"\n",
"options",
".",
"Apply",
"(",
"params",
",",
"opts",
")",
"\n",
"return",
"&",
"Client",
"{",
"Service",
":",
"eventservice",
".",
"New",
"(",
"dispatcher",
",",
"opts",
"...",
")",
",",
"params",
":",
"*",
"params",
",",
"connectionState",
":",
"int32",
"(",
"Disconnected",
")",
",",
"}",
"\n",
"}"
] | // New returns a new event client | [
"New",
"returns",
"a",
"new",
"event",
"client"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/client.go#L55-L64 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.