repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
hyperledger/fabric-sdk-go | pkg/fabsdk/fabsdk.go | loadConfigs | func (sdk *FabricSDK) loadConfigs(configProvider core.ConfigProvider) (*configs, error) {
c := &configs{
identityConfig: sdk.opts.IdentityConfig,
endpointConfig: sdk.opts.endpointConfig,
cryptoSuiteConfig: sdk.opts.CryptoSuiteConfig,
metricsConfig: sdk.opts.metricsConfig,
}
var configBackend []core.ConfigBackend
var err error
if configProvider != nil {
configBackend, err = configProvider()
if err != nil {
return nil, errors.WithMessage(err, "unable to load config backend")
}
}
//configs passed through opts take priority over default ones
// load crypto suite config
c.cryptoSuiteConfig, err = sdk.loadCryptoConfig(configBackend...)
if err != nil {
return nil, errors.WithMessage(err, "unable to load crypto suite config")
}
//Initialize cryptosuite once crypto Suite config is available
err = sdk.initializeCryptoSuite(c.cryptoSuiteConfig)
if err != nil {
return nil, errors.WithMessage(err, "unable to initialize cryptosuite using crypto suite config")
}
// load endpoint config
c.endpointConfig, err = sdk.loadEndpointConfig(configBackend...)
if err != nil {
return nil, errors.WithMessage(err, "unable to load endpoint config")
}
// load identity config
c.identityConfig, err = sdk.loadIdentityConfig(configBackend...)
if err != nil {
return nil, errors.WithMessage(err, "unable to load identity config")
}
// load metrics config
c.metricsConfig, err = sdk.loadMetricsConfig(configBackend...)
if err != nil {
return nil, errors.WithMessage(err, "unable to load metrics config")
}
sdk.opts.ConfigBackend = configBackend
return c, nil
} | go | func (sdk *FabricSDK) loadConfigs(configProvider core.ConfigProvider) (*configs, error) {
c := &configs{
identityConfig: sdk.opts.IdentityConfig,
endpointConfig: sdk.opts.endpointConfig,
cryptoSuiteConfig: sdk.opts.CryptoSuiteConfig,
metricsConfig: sdk.opts.metricsConfig,
}
var configBackend []core.ConfigBackend
var err error
if configProvider != nil {
configBackend, err = configProvider()
if err != nil {
return nil, errors.WithMessage(err, "unable to load config backend")
}
}
//configs passed through opts take priority over default ones
// load crypto suite config
c.cryptoSuiteConfig, err = sdk.loadCryptoConfig(configBackend...)
if err != nil {
return nil, errors.WithMessage(err, "unable to load crypto suite config")
}
//Initialize cryptosuite once crypto Suite config is available
err = sdk.initializeCryptoSuite(c.cryptoSuiteConfig)
if err != nil {
return nil, errors.WithMessage(err, "unable to initialize cryptosuite using crypto suite config")
}
// load endpoint config
c.endpointConfig, err = sdk.loadEndpointConfig(configBackend...)
if err != nil {
return nil, errors.WithMessage(err, "unable to load endpoint config")
}
// load identity config
c.identityConfig, err = sdk.loadIdentityConfig(configBackend...)
if err != nil {
return nil, errors.WithMessage(err, "unable to load identity config")
}
// load metrics config
c.metricsConfig, err = sdk.loadMetricsConfig(configBackend...)
if err != nil {
return nil, errors.WithMessage(err, "unable to load metrics config")
}
sdk.opts.ConfigBackend = configBackend
return c, nil
} | [
"func",
"(",
"sdk",
"*",
"FabricSDK",
")",
"loadConfigs",
"(",
"configProvider",
"core",
".",
"ConfigProvider",
")",
"(",
"*",
"configs",
",",
"error",
")",
"{",
"c",
":=",
"&",
"configs",
"{",
"identityConfig",
":",
"sdk",
".",
"opts",
".",
"IdentityConfig",
",",
"endpointConfig",
":",
"sdk",
".",
"opts",
".",
"endpointConfig",
",",
"cryptoSuiteConfig",
":",
"sdk",
".",
"opts",
".",
"CryptoSuiteConfig",
",",
"metricsConfig",
":",
"sdk",
".",
"opts",
".",
"metricsConfig",
",",
"}",
"\n\n",
"var",
"configBackend",
"[",
"]",
"core",
".",
"ConfigBackend",
"\n",
"var",
"err",
"error",
"\n\n",
"if",
"configProvider",
"!=",
"nil",
"{",
"configBackend",
",",
"err",
"=",
"configProvider",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"//configs passed through opts take priority over default ones",
"// load crypto suite config",
"c",
".",
"cryptoSuiteConfig",
",",
"err",
"=",
"sdk",
".",
"loadCryptoConfig",
"(",
"configBackend",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"//Initialize cryptosuite once crypto Suite config is available",
"err",
"=",
"sdk",
".",
"initializeCryptoSuite",
"(",
"c",
".",
"cryptoSuiteConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// load endpoint config",
"c",
".",
"endpointConfig",
",",
"err",
"=",
"sdk",
".",
"loadEndpointConfig",
"(",
"configBackend",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// load identity config",
"c",
".",
"identityConfig",
",",
"err",
"=",
"sdk",
".",
"loadIdentityConfig",
"(",
"configBackend",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// load metrics config",
"c",
".",
"metricsConfig",
",",
"err",
"=",
"sdk",
".",
"loadMetricsConfig",
"(",
"configBackend",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"sdk",
".",
"opts",
".",
"ConfigBackend",
"=",
"configBackend",
"\n\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] | //loadConfigs load config from config backend when configs are not provided through opts | [
"loadConfigs",
"load",
"config",
"from",
"config",
"backend",
"when",
"configs",
"are",
"not",
"provided",
"through",
"opts"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fabsdk/fabsdk.go#L413-L465 | train |
hyperledger/fabric-sdk-go | pkg/fabsdk/fabsdk.go | loadEndpointConfig | func (sdk *FabricSDK) loadEndpointConfig(configBackend ...core.ConfigBackend) (fab.EndpointConfig, error) {
endpointConfigOpt, ok := sdk.opts.endpointConfig.(*fabImpl.EndpointConfigOptions)
// if optional endpoint was nil or not all of its sub interface functions were overridden,
// then get default endpoint config and override the functions that were not overridden by opts
if sdk.opts.endpointConfig == nil || (ok && !fabImpl.IsEndpointConfigFullyOverridden(endpointConfigOpt)) {
defEndpointConfig, err := fabImpl.ConfigFromBackend(configBackend...)
if err != nil {
return nil, errors.WithMessage(err, "failed to initialize endpoint config from config backend")
}
// if opts.endpointConfig was not provided during WithEndpointConfig(opts...) call, then return default endpointConfig
if sdk.opts.endpointConfig == nil {
return defEndpointConfig, nil
}
// else fill any empty interface from opts with defEndpointConfig interface (set default function for ones not provided by WithEndpointConfig() call) and return
return fabImpl.UpdateMissingOptsWithDefaultConfig(endpointConfigOpt, defEndpointConfig), nil
}
// if optional endpoint config was completely overridden but !ok, then return an error
if !ok {
return nil, errors.New("failed to retrieve config endpoint from opts")
}
return endpointConfigOpt, nil
} | go | func (sdk *FabricSDK) loadEndpointConfig(configBackend ...core.ConfigBackend) (fab.EndpointConfig, error) {
endpointConfigOpt, ok := sdk.opts.endpointConfig.(*fabImpl.EndpointConfigOptions)
// if optional endpoint was nil or not all of its sub interface functions were overridden,
// then get default endpoint config and override the functions that were not overridden by opts
if sdk.opts.endpointConfig == nil || (ok && !fabImpl.IsEndpointConfigFullyOverridden(endpointConfigOpt)) {
defEndpointConfig, err := fabImpl.ConfigFromBackend(configBackend...)
if err != nil {
return nil, errors.WithMessage(err, "failed to initialize endpoint config from config backend")
}
// if opts.endpointConfig was not provided during WithEndpointConfig(opts...) call, then return default endpointConfig
if sdk.opts.endpointConfig == nil {
return defEndpointConfig, nil
}
// else fill any empty interface from opts with defEndpointConfig interface (set default function for ones not provided by WithEndpointConfig() call) and return
return fabImpl.UpdateMissingOptsWithDefaultConfig(endpointConfigOpt, defEndpointConfig), nil
}
// if optional endpoint config was completely overridden but !ok, then return an error
if !ok {
return nil, errors.New("failed to retrieve config endpoint from opts")
}
return endpointConfigOpt, nil
} | [
"func",
"(",
"sdk",
"*",
"FabricSDK",
")",
"loadEndpointConfig",
"(",
"configBackend",
"...",
"core",
".",
"ConfigBackend",
")",
"(",
"fab",
".",
"EndpointConfig",
",",
"error",
")",
"{",
"endpointConfigOpt",
",",
"ok",
":=",
"sdk",
".",
"opts",
".",
"endpointConfig",
".",
"(",
"*",
"fabImpl",
".",
"EndpointConfigOptions",
")",
"\n\n",
"// if optional endpoint was nil or not all of its sub interface functions were overridden,",
"// then get default endpoint config and override the functions that were not overridden by opts",
"if",
"sdk",
".",
"opts",
".",
"endpointConfig",
"==",
"nil",
"||",
"(",
"ok",
"&&",
"!",
"fabImpl",
".",
"IsEndpointConfigFullyOverridden",
"(",
"endpointConfigOpt",
")",
")",
"{",
"defEndpointConfig",
",",
"err",
":=",
"fabImpl",
".",
"ConfigFromBackend",
"(",
"configBackend",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// if opts.endpointConfig was not provided during WithEndpointConfig(opts...) call, then return default endpointConfig",
"if",
"sdk",
".",
"opts",
".",
"endpointConfig",
"==",
"nil",
"{",
"return",
"defEndpointConfig",
",",
"nil",
"\n",
"}",
"\n",
"// else fill any empty interface from opts with defEndpointConfig interface (set default function for ones not provided by WithEndpointConfig() call) and return",
"return",
"fabImpl",
".",
"UpdateMissingOptsWithDefaultConfig",
"(",
"endpointConfigOpt",
",",
"defEndpointConfig",
")",
",",
"nil",
"\n",
"}",
"\n",
"// if optional endpoint config was completely overridden but !ok, then return an error",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"endpointConfigOpt",
",",
"nil",
"\n",
"}"
] | //loadEndpointConfig loads config from config backend when configs are not provided through opts or override missing interfaces from opts with config backend | [
"loadEndpointConfig",
"loads",
"config",
"from",
"config",
"backend",
"when",
"configs",
"are",
"not",
"provided",
"through",
"opts",
"or",
"override",
"missing",
"interfaces",
"from",
"opts",
"with",
"config",
"backend"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fabsdk/fabsdk.go#L468-L491 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/membership/reference.go | NewRef | func NewRef(refresh time.Duration, context Context, chConfigRef *lazyref.Reference) *Ref {
ref := &Ref{
chConfigRef: chConfigRef,
context: context,
}
ref.Reference = lazyref.New(
ref.initializer(),
lazyref.WithRefreshInterval(lazyref.InitImmediately, refresh),
)
return ref
} | go | func NewRef(refresh time.Duration, context Context, chConfigRef *lazyref.Reference) *Ref {
ref := &Ref{
chConfigRef: chConfigRef,
context: context,
}
ref.Reference = lazyref.New(
ref.initializer(),
lazyref.WithRefreshInterval(lazyref.InitImmediately, refresh),
)
return ref
} | [
"func",
"NewRef",
"(",
"refresh",
"time",
".",
"Duration",
",",
"context",
"Context",
",",
"chConfigRef",
"*",
"lazyref",
".",
"Reference",
")",
"*",
"Ref",
"{",
"ref",
":=",
"&",
"Ref",
"{",
"chConfigRef",
":",
"chConfigRef",
",",
"context",
":",
"context",
",",
"}",
"\n\n",
"ref",
".",
"Reference",
"=",
"lazyref",
".",
"New",
"(",
"ref",
".",
"initializer",
"(",
")",
",",
"lazyref",
".",
"WithRefreshInterval",
"(",
"lazyref",
".",
"InitImmediately",
",",
"refresh",
")",
",",
")",
"\n\n",
"return",
"ref",
"\n",
"}"
] | // NewRef returns a new membership reference | [
"NewRef",
"returns",
"a",
"new",
"membership",
"reference"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/membership/reference.go#L28-L40 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/membership/reference.go | Validate | func (ref *Ref) Validate(serializedID []byte) error {
membership, err := ref.get()
if err != nil {
return err
}
return membership.Validate(serializedID)
} | go | func (ref *Ref) Validate(serializedID []byte) error {
membership, err := ref.get()
if err != nil {
return err
}
return membership.Validate(serializedID)
} | [
"func",
"(",
"ref",
"*",
"Ref",
")",
"Validate",
"(",
"serializedID",
"[",
"]",
"byte",
")",
"error",
"{",
"membership",
",",
"err",
":=",
"ref",
".",
"get",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"membership",
".",
"Validate",
"(",
"serializedID",
")",
"\n",
"}"
] | // Validate calls validate on the underlying reference | [
"Validate",
"calls",
"validate",
"on",
"the",
"underlying",
"reference"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/membership/reference.go#L43-L49 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/membership/reference.go | Verify | func (ref *Ref) Verify(serializedID []byte, msg []byte, sig []byte) error {
membership, err := ref.get()
if err != nil {
return err
}
return membership.Verify(serializedID, msg, sig)
} | go | func (ref *Ref) Verify(serializedID []byte, msg []byte, sig []byte) error {
membership, err := ref.get()
if err != nil {
return err
}
return membership.Verify(serializedID, msg, sig)
} | [
"func",
"(",
"ref",
"*",
"Ref",
")",
"Verify",
"(",
"serializedID",
"[",
"]",
"byte",
",",
"msg",
"[",
"]",
"byte",
",",
"sig",
"[",
"]",
"byte",
")",
"error",
"{",
"membership",
",",
"err",
":=",
"ref",
".",
"get",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"membership",
".",
"Verify",
"(",
"serializedID",
",",
"msg",
",",
"sig",
")",
"\n",
"}"
] | // Verify calls validate on the underlying reference | [
"Verify",
"calls",
"validate",
"on",
"the",
"underlying",
"reference"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/membership/reference.go#L52-L58 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/membership/reference.go | ContainsMSP | func (ref *Ref) ContainsMSP(msp string) bool {
membership, err := ref.get()
if err != nil {
logger.Debugf("Failed to check ContainsMSP, err: %s", err)
return false
}
return membership.ContainsMSP(msp)
} | go | func (ref *Ref) ContainsMSP(msp string) bool {
membership, err := ref.get()
if err != nil {
logger.Debugf("Failed to check ContainsMSP, err: %s", err)
return false
}
return membership.ContainsMSP(msp)
} | [
"func",
"(",
"ref",
"*",
"Ref",
")",
"ContainsMSP",
"(",
"msp",
"string",
")",
"bool",
"{",
"membership",
",",
"err",
":=",
"ref",
".",
"get",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"return",
"membership",
".",
"ContainsMSP",
"(",
"msp",
")",
"\n",
"}"
] | // ContainsMSP checks if given MSP is available in the underlying reference | [
"ContainsMSP",
"checks",
"if",
"given",
"MSP",
"is",
"available",
"in",
"the",
"underlying",
"reference"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/membership/reference.go#L61-L68 | train |
hyperledger/fabric-sdk-go | pkg/fab/txn/proposal.go | CreateChaincodeInvokeProposal | func CreateChaincodeInvokeProposal(txh fab.TransactionHeader, request fab.ChaincodeInvokeRequest) (*fab.TransactionProposal, error) {
if request.ChaincodeID == "" {
return nil, errors.New("ChaincodeID is required")
}
if request.Fcn == "" {
return nil, errors.New("Fcn is required")
}
// Add function name to arguments
argsArray := make([][]byte, len(request.Args)+1)
argsArray[0] = []byte(request.Fcn)
for i, arg := range request.Args {
argsArray[i+1] = arg
}
// create invocation spec to target a chaincode with arguments
ccis := &pb.ChaincodeInvocationSpec{ChaincodeSpec: &pb.ChaincodeSpec{
Type: pb.ChaincodeSpec_GOLANG, ChaincodeId: &pb.ChaincodeID{Name: request.ChaincodeID},
Input: &pb.ChaincodeInput{Args: argsArray}}}
proposal, _, err := protoutil.CreateChaincodeProposalWithTxIDNonceAndTransient(string(txh.TransactionID()), common.HeaderType_ENDORSER_TRANSACTION, txh.ChannelID(), ccis, txh.Nonce(), txh.Creator(), request.TransientMap)
if err != nil {
return nil, errors.Wrap(err, "failed to create chaincode proposal")
}
tp := fab.TransactionProposal{
TxnID: txh.TransactionID(),
Proposal: proposal,
}
return &tp, nil
} | go | func CreateChaincodeInvokeProposal(txh fab.TransactionHeader, request fab.ChaincodeInvokeRequest) (*fab.TransactionProposal, error) {
if request.ChaincodeID == "" {
return nil, errors.New("ChaincodeID is required")
}
if request.Fcn == "" {
return nil, errors.New("Fcn is required")
}
// Add function name to arguments
argsArray := make([][]byte, len(request.Args)+1)
argsArray[0] = []byte(request.Fcn)
for i, arg := range request.Args {
argsArray[i+1] = arg
}
// create invocation spec to target a chaincode with arguments
ccis := &pb.ChaincodeInvocationSpec{ChaincodeSpec: &pb.ChaincodeSpec{
Type: pb.ChaincodeSpec_GOLANG, ChaincodeId: &pb.ChaincodeID{Name: request.ChaincodeID},
Input: &pb.ChaincodeInput{Args: argsArray}}}
proposal, _, err := protoutil.CreateChaincodeProposalWithTxIDNonceAndTransient(string(txh.TransactionID()), common.HeaderType_ENDORSER_TRANSACTION, txh.ChannelID(), ccis, txh.Nonce(), txh.Creator(), request.TransientMap)
if err != nil {
return nil, errors.Wrap(err, "failed to create chaincode proposal")
}
tp := fab.TransactionProposal{
TxnID: txh.TransactionID(),
Proposal: proposal,
}
return &tp, nil
} | [
"func",
"CreateChaincodeInvokeProposal",
"(",
"txh",
"fab",
".",
"TransactionHeader",
",",
"request",
"fab",
".",
"ChaincodeInvokeRequest",
")",
"(",
"*",
"fab",
".",
"TransactionProposal",
",",
"error",
")",
"{",
"if",
"request",
".",
"ChaincodeID",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"request",
".",
"Fcn",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Add function name to arguments",
"argsArray",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"len",
"(",
"request",
".",
"Args",
")",
"+",
"1",
")",
"\n",
"argsArray",
"[",
"0",
"]",
"=",
"[",
"]",
"byte",
"(",
"request",
".",
"Fcn",
")",
"\n",
"for",
"i",
",",
"arg",
":=",
"range",
"request",
".",
"Args",
"{",
"argsArray",
"[",
"i",
"+",
"1",
"]",
"=",
"arg",
"\n",
"}",
"\n\n",
"// create invocation spec to target a chaincode with arguments",
"ccis",
":=",
"&",
"pb",
".",
"ChaincodeInvocationSpec",
"{",
"ChaincodeSpec",
":",
"&",
"pb",
".",
"ChaincodeSpec",
"{",
"Type",
":",
"pb",
".",
"ChaincodeSpec_GOLANG",
",",
"ChaincodeId",
":",
"&",
"pb",
".",
"ChaincodeID",
"{",
"Name",
":",
"request",
".",
"ChaincodeID",
"}",
",",
"Input",
":",
"&",
"pb",
".",
"ChaincodeInput",
"{",
"Args",
":",
"argsArray",
"}",
"}",
"}",
"\n\n",
"proposal",
",",
"_",
",",
"err",
":=",
"protoutil",
".",
"CreateChaincodeProposalWithTxIDNonceAndTransient",
"(",
"string",
"(",
"txh",
".",
"TransactionID",
"(",
")",
")",
",",
"common",
".",
"HeaderType_ENDORSER_TRANSACTION",
",",
"txh",
".",
"ChannelID",
"(",
")",
",",
"ccis",
",",
"txh",
".",
"Nonce",
"(",
")",
",",
"txh",
".",
"Creator",
"(",
")",
",",
"request",
".",
"TransientMap",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"tp",
":=",
"fab",
".",
"TransactionProposal",
"{",
"TxnID",
":",
"txh",
".",
"TransactionID",
"(",
")",
",",
"Proposal",
":",
"proposal",
",",
"}",
"\n\n",
"return",
"&",
"tp",
",",
"nil",
"\n",
"}"
] | // CreateChaincodeInvokeProposal creates a proposal for transaction. | [
"CreateChaincodeInvokeProposal",
"creates",
"a",
"proposal",
"for",
"transaction",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/txn/proposal.go#L26-L58 | train |
hyperledger/fabric-sdk-go | pkg/fab/txn/proposal.go | signProposal | func signProposal(ctx contextApi.Client, proposal *pb.Proposal) (*pb.SignedProposal, error) {
proposalBytes, err := proto.Marshal(proposal)
if err != nil {
return nil, errors.Wrap(err, "mashal proposal failed")
}
signingMgr := ctx.SigningManager()
if signingMgr == nil {
return nil, errors.New("signing manager is nil")
}
signature, err := signingMgr.Sign(proposalBytes, ctx.PrivateKey())
if err != nil {
return nil, errors.WithMessage(err, "sign failed")
}
return &pb.SignedProposal{ProposalBytes: proposalBytes, Signature: signature}, nil
} | go | func signProposal(ctx contextApi.Client, proposal *pb.Proposal) (*pb.SignedProposal, error) {
proposalBytes, err := proto.Marshal(proposal)
if err != nil {
return nil, errors.Wrap(err, "mashal proposal failed")
}
signingMgr := ctx.SigningManager()
if signingMgr == nil {
return nil, errors.New("signing manager is nil")
}
signature, err := signingMgr.Sign(proposalBytes, ctx.PrivateKey())
if err != nil {
return nil, errors.WithMessage(err, "sign failed")
}
return &pb.SignedProposal{ProposalBytes: proposalBytes, Signature: signature}, nil
} | [
"func",
"signProposal",
"(",
"ctx",
"contextApi",
".",
"Client",
",",
"proposal",
"*",
"pb",
".",
"Proposal",
")",
"(",
"*",
"pb",
".",
"SignedProposal",
",",
"error",
")",
"{",
"proposalBytes",
",",
"err",
":=",
"proto",
".",
"Marshal",
"(",
"proposal",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"signingMgr",
":=",
"ctx",
".",
"SigningManager",
"(",
")",
"\n",
"if",
"signingMgr",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"signature",
",",
"err",
":=",
"signingMgr",
".",
"Sign",
"(",
"proposalBytes",
",",
"ctx",
".",
"PrivateKey",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"pb",
".",
"SignedProposal",
"{",
"ProposalBytes",
":",
"proposalBytes",
",",
"Signature",
":",
"signature",
"}",
",",
"nil",
"\n",
"}"
] | // signProposal creates a SignedProposal based on the current context. | [
"signProposal",
"creates",
"a",
"SignedProposal",
"based",
"on",
"the",
"current",
"context",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/txn/proposal.go#L61-L78 | train |
hyperledger/fabric-sdk-go | pkg/fab/txn/proposal.go | SendProposal | func SendProposal(reqCtx reqContext.Context, proposal *fab.TransactionProposal, targets []fab.ProposalProcessor) ([]*fab.TransactionProposalResponse, error) {
if proposal == nil {
return nil, errors.New("proposal is required")
}
if len(targets) < 1 {
return nil, errors.New("targets is required")
}
for _, p := range targets {
if p == nil {
return nil, errors.New("target is nil")
}
}
targets = getTargetsWithoutDuplicates(targets)
ctx, ok := context.RequestClientContext(reqCtx)
if !ok {
return nil, errors.New("failed get client context from reqContext for signProposal")
}
signedProposal, err := signProposal(ctx, proposal.Proposal)
if err != nil {
return nil, errors.WithMessage(err, "sign proposal failed")
}
request := fab.ProcessProposalRequest{SignedProposal: signedProposal}
var responseMtx sync.Mutex
var transactionProposalResponses []*fab.TransactionProposalResponse
var wg sync.WaitGroup
errs := multi.Errors{}
for _, p := range targets {
wg.Add(1)
go func(processor fab.ProposalProcessor) {
defer wg.Done()
// TODO: The RPC should be timed-out.
//resp, err := processor.ProcessTransactionProposal(context.NewRequestOLD(ctx), request)
resp, err := processor.ProcessTransactionProposal(reqCtx, request)
if err != nil {
logger.Debugf("Received error response from txn proposal processing: %s", err)
responseMtx.Lock()
errs = append(errs, err)
responseMtx.Unlock()
return
}
responseMtx.Lock()
transactionProposalResponses = append(transactionProposalResponses, resp)
responseMtx.Unlock()
}(p)
}
wg.Wait()
return transactionProposalResponses, errs.ToError()
} | go | func SendProposal(reqCtx reqContext.Context, proposal *fab.TransactionProposal, targets []fab.ProposalProcessor) ([]*fab.TransactionProposalResponse, error) {
if proposal == nil {
return nil, errors.New("proposal is required")
}
if len(targets) < 1 {
return nil, errors.New("targets is required")
}
for _, p := range targets {
if p == nil {
return nil, errors.New("target is nil")
}
}
targets = getTargetsWithoutDuplicates(targets)
ctx, ok := context.RequestClientContext(reqCtx)
if !ok {
return nil, errors.New("failed get client context from reqContext for signProposal")
}
signedProposal, err := signProposal(ctx, proposal.Proposal)
if err != nil {
return nil, errors.WithMessage(err, "sign proposal failed")
}
request := fab.ProcessProposalRequest{SignedProposal: signedProposal}
var responseMtx sync.Mutex
var transactionProposalResponses []*fab.TransactionProposalResponse
var wg sync.WaitGroup
errs := multi.Errors{}
for _, p := range targets {
wg.Add(1)
go func(processor fab.ProposalProcessor) {
defer wg.Done()
// TODO: The RPC should be timed-out.
//resp, err := processor.ProcessTransactionProposal(context.NewRequestOLD(ctx), request)
resp, err := processor.ProcessTransactionProposal(reqCtx, request)
if err != nil {
logger.Debugf("Received error response from txn proposal processing: %s", err)
responseMtx.Lock()
errs = append(errs, err)
responseMtx.Unlock()
return
}
responseMtx.Lock()
transactionProposalResponses = append(transactionProposalResponses, resp)
responseMtx.Unlock()
}(p)
}
wg.Wait()
return transactionProposalResponses, errs.ToError()
} | [
"func",
"SendProposal",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"proposal",
"*",
"fab",
".",
"TransactionProposal",
",",
"targets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
")",
"(",
"[",
"]",
"*",
"fab",
".",
"TransactionProposalResponse",
",",
"error",
")",
"{",
"if",
"proposal",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"targets",
")",
"<",
"1",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"p",
":=",
"range",
"targets",
"{",
"if",
"p",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"targets",
"=",
"getTargetsWithoutDuplicates",
"(",
"targets",
")",
"\n\n",
"ctx",
",",
"ok",
":=",
"context",
".",
"RequestClientContext",
"(",
"reqCtx",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"signedProposal",
",",
"err",
":=",
"signProposal",
"(",
"ctx",
",",
"proposal",
".",
"Proposal",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"request",
":=",
"fab",
".",
"ProcessProposalRequest",
"{",
"SignedProposal",
":",
"signedProposal",
"}",
"\n\n",
"var",
"responseMtx",
"sync",
".",
"Mutex",
"\n",
"var",
"transactionProposalResponses",
"[",
"]",
"*",
"fab",
".",
"TransactionProposalResponse",
"\n",
"var",
"wg",
"sync",
".",
"WaitGroup",
"\n",
"errs",
":=",
"multi",
".",
"Errors",
"{",
"}",
"\n\n",
"for",
"_",
",",
"p",
":=",
"range",
"targets",
"{",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
"processor",
"fab",
".",
"ProposalProcessor",
")",
"{",
"defer",
"wg",
".",
"Done",
"(",
")",
"\n\n",
"// TODO: The RPC should be timed-out.",
"//resp, err := processor.ProcessTransactionProposal(context.NewRequestOLD(ctx), request)",
"resp",
",",
"err",
":=",
"processor",
".",
"ProcessTransactionProposal",
"(",
"reqCtx",
",",
"request",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"responseMtx",
".",
"Lock",
"(",
")",
"\n",
"errs",
"=",
"append",
"(",
"errs",
",",
"err",
")",
"\n",
"responseMtx",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"responseMtx",
".",
"Lock",
"(",
")",
"\n",
"transactionProposalResponses",
"=",
"append",
"(",
"transactionProposalResponses",
",",
"resp",
")",
"\n",
"responseMtx",
".",
"Unlock",
"(",
")",
"\n",
"}",
"(",
"p",
")",
"\n",
"}",
"\n",
"wg",
".",
"Wait",
"(",
")",
"\n\n",
"return",
"transactionProposalResponses",
",",
"errs",
".",
"ToError",
"(",
")",
"\n",
"}"
] | // SendProposal sends a TransactionProposal to ProposalProcessor. | [
"SendProposal",
"sends",
"a",
"TransactionProposal",
"to",
"ProposalProcessor",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/txn/proposal.go#L81-L139 | train |
hyperledger/fabric-sdk-go | pkg/fab/txn/proposal.go | getTargetsWithoutDuplicates | func getTargetsWithoutDuplicates(targets []fab.ProposalProcessor) []fab.ProposalProcessor {
peerUrlsToTargets := map[string]fab.ProposalProcessor{}
var uniqueTargets []fab.ProposalProcessor
for i := range targets {
peer, ok := targets[i].(fab.Peer)
if !ok {
// ProposalProcessor is not a fab.Peer... cannot remove duplicates
return targets
}
if _, present := peerUrlsToTargets[peer.URL()]; !present {
uniqueTargets = append(uniqueTargets, targets[i])
peerUrlsToTargets[peer.URL()] = targets[i]
}
}
if len(uniqueTargets) != len(targets) {
logger.Warn("Duplicate target peers in configuration")
}
return uniqueTargets
} | go | func getTargetsWithoutDuplicates(targets []fab.ProposalProcessor) []fab.ProposalProcessor {
peerUrlsToTargets := map[string]fab.ProposalProcessor{}
var uniqueTargets []fab.ProposalProcessor
for i := range targets {
peer, ok := targets[i].(fab.Peer)
if !ok {
// ProposalProcessor is not a fab.Peer... cannot remove duplicates
return targets
}
if _, present := peerUrlsToTargets[peer.URL()]; !present {
uniqueTargets = append(uniqueTargets, targets[i])
peerUrlsToTargets[peer.URL()] = targets[i]
}
}
if len(uniqueTargets) != len(targets) {
logger.Warn("Duplicate target peers in configuration")
}
return uniqueTargets
} | [
"func",
"getTargetsWithoutDuplicates",
"(",
"targets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
")",
"[",
"]",
"fab",
".",
"ProposalProcessor",
"{",
"peerUrlsToTargets",
":=",
"map",
"[",
"string",
"]",
"fab",
".",
"ProposalProcessor",
"{",
"}",
"\n",
"var",
"uniqueTargets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
"\n\n",
"for",
"i",
":=",
"range",
"targets",
"{",
"peer",
",",
"ok",
":=",
"targets",
"[",
"i",
"]",
".",
"(",
"fab",
".",
"Peer",
")",
"\n",
"if",
"!",
"ok",
"{",
"// ProposalProcessor is not a fab.Peer... cannot remove duplicates",
"return",
"targets",
"\n",
"}",
"\n",
"if",
"_",
",",
"present",
":=",
"peerUrlsToTargets",
"[",
"peer",
".",
"URL",
"(",
")",
"]",
";",
"!",
"present",
"{",
"uniqueTargets",
"=",
"append",
"(",
"uniqueTargets",
",",
"targets",
"[",
"i",
"]",
")",
"\n",
"peerUrlsToTargets",
"[",
"peer",
".",
"URL",
"(",
")",
"]",
"=",
"targets",
"[",
"i",
"]",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"uniqueTargets",
")",
"!=",
"len",
"(",
"targets",
")",
"{",
"logger",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"uniqueTargets",
"\n",
"}"
] | // getTargetsWithoutDuplicates returns a list of targets without duplicates | [
"getTargetsWithoutDuplicates",
"returns",
"a",
"list",
"of",
"targets",
"without",
"duplicates"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/txn/proposal.go#L142-L163 | train |
hyperledger/fabric-sdk-go | pkg/core/config/endpoint/endpoint.go | IsTLSEnabled | func IsTLSEnabled(url string) bool {
tlsURL := strings.ToLower(url)
if strings.HasPrefix(tlsURL, "https://") || strings.HasPrefix(tlsURL, "grpcs://") {
return true
}
return false
} | go | func IsTLSEnabled(url string) bool {
tlsURL := strings.ToLower(url)
if strings.HasPrefix(tlsURL, "https://") || strings.HasPrefix(tlsURL, "grpcs://") {
return true
}
return false
} | [
"func",
"IsTLSEnabled",
"(",
"url",
"string",
")",
"bool",
"{",
"tlsURL",
":=",
"strings",
".",
"ToLower",
"(",
"url",
")",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"tlsURL",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"HasPrefix",
"(",
"tlsURL",
",",
"\"",
"\"",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsTLSEnabled is a generic function that expects a URL and verifies if it has
// a prefix HTTPS or GRPCS to return true for TLS Enabled URLs or false otherwise | [
"IsTLSEnabled",
"is",
"a",
"generic",
"function",
"that",
"expects",
"a",
"URL",
"and",
"verifies",
"if",
"it",
"has",
"a",
"prefix",
"HTTPS",
"or",
"GRPCS",
"to",
"return",
"true",
"for",
"TLS",
"Enabled",
"URLs",
"or",
"false",
"otherwise"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/config/endpoint/endpoint.go#L22-L28 | train |
hyperledger/fabric-sdk-go | pkg/core/config/endpoint/endpoint.go | ToAddress | func ToAddress(url string) string {
if strings.HasPrefix(url, "grpc://") {
return strings.TrimPrefix(url, "grpc://")
}
if strings.HasPrefix(url, "grpcs://") {
return strings.TrimPrefix(url, "grpcs://")
}
return url
} | go | func ToAddress(url string) string {
if strings.HasPrefix(url, "grpc://") {
return strings.TrimPrefix(url, "grpc://")
}
if strings.HasPrefix(url, "grpcs://") {
return strings.TrimPrefix(url, "grpcs://")
}
return url
} | [
"func",
"ToAddress",
"(",
"url",
"string",
")",
"string",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"url",
",",
"\"",
"\"",
")",
"{",
"return",
"strings",
".",
"TrimPrefix",
"(",
"url",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"url",
",",
"\"",
"\"",
")",
"{",
"return",
"strings",
".",
"TrimPrefix",
"(",
"url",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"url",
"\n",
"}"
] | // ToAddress is a utility function to trim the GRPC protocol prefix as it is not needed by GO
// if the GRPC protocol is not found, the url is returned unchanged | [
"ToAddress",
"is",
"a",
"utility",
"function",
"to",
"trim",
"the",
"GRPC",
"protocol",
"prefix",
"as",
"it",
"is",
"not",
"needed",
"by",
"GO",
"if",
"the",
"GRPC",
"protocol",
"is",
"not",
"found",
"the",
"url",
"is",
"returned",
"unchanged"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/config/endpoint/endpoint.go#L32-L40 | train |
hyperledger/fabric-sdk-go | pkg/core/config/endpoint/endpoint.go | AttemptSecured | func AttemptSecured(url string, allowInSecure bool) bool {
ok, err := regexp.MatchString(".*(?i)s://", url)
if ok && err == nil {
return true
} else if strings.Contains(url, "://") {
return false
} else {
return !allowInSecure
}
} | go | func AttemptSecured(url string, allowInSecure bool) bool {
ok, err := regexp.MatchString(".*(?i)s://", url)
if ok && err == nil {
return true
} else if strings.Contains(url, "://") {
return false
} else {
return !allowInSecure
}
} | [
"func",
"AttemptSecured",
"(",
"url",
"string",
",",
"allowInSecure",
"bool",
")",
"bool",
"{",
"ok",
",",
"err",
":=",
"regexp",
".",
"MatchString",
"(",
"\"",
"\"",
",",
"url",
")",
"\n",
"if",
"ok",
"&&",
"err",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"else",
"if",
"strings",
".",
"Contains",
"(",
"url",
",",
"\"",
"\"",
")",
"{",
"return",
"false",
"\n",
"}",
"else",
"{",
"return",
"!",
"allowInSecure",
"\n",
"}",
"\n",
"}"
] | //AttemptSecured is a utility function which verifies URL and returns if secured connections needs to established
// for protocol 'grpcs' in URL returns true
// for protocol 'grpc' in URL returns false
// for no protocol mentioned, returns !allowInSecure | [
"AttemptSecured",
"is",
"a",
"utility",
"function",
"which",
"verifies",
"URL",
"and",
"returns",
"if",
"secured",
"connections",
"needs",
"to",
"established",
"for",
"protocol",
"grpcs",
"in",
"URL",
"returns",
"true",
"for",
"protocol",
"grpc",
"in",
"URL",
"returns",
"false",
"for",
"no",
"protocol",
"mentioned",
"returns",
"!allowInSecure"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/config/endpoint/endpoint.go#L46-L55 | train |
hyperledger/fabric-sdk-go | pkg/client/msp/client.go | WithCA | func WithCA(caname string) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
o.CA = caname
return nil
}
} | go | func WithCA(caname string) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
o.CA = caname
return nil
}
} | [
"func",
"WithCA",
"(",
"caname",
"string",
")",
"RequestOption",
"{",
"return",
"func",
"(",
"ctx",
"context",
".",
"Client",
",",
"o",
"*",
"requestOptions",
")",
"error",
"{",
"o",
".",
"CA",
"=",
"caname",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithCA allows for specifying optional CA name | [
"WithCA",
"allows",
"for",
"specifying",
"optional",
"CA",
"name"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/msp/client.go#L57-L62 | train |
hyperledger/fabric-sdk-go | pkg/client/msp/client.go | New | func New(clientProvider context.ClientProvider, opts ...ClientOption) (*Client, error) {
ctx, err := clientProvider()
if err != nil {
return nil, errors.WithMessage(err, "failed to create Client")
}
msp := Client{
ctx: ctx,
}
for _, param := range opts {
err := param(&msp)
if err != nil {
return nil, errors.WithMessage(err, "failed to create Client")
}
}
if msp.orgName == "" {
msp.orgName = ctx.IdentityConfig().Client().Organization
}
if msp.orgName == "" {
return nil, errors.New("organization is not provided")
}
caConfig, ok := ctx.IdentityConfig().CAConfig(msp.orgName)
if ok {
msp.caName = caConfig.CAName
}
networkConfig := ctx.EndpointConfig().NetworkConfig()
_, ok = networkConfig.Organizations[strings.ToLower(msp.orgName)]
if !ok {
return nil, fmt.Errorf("non-existent organization: '%s'", msp.orgName)
}
return &msp, nil
} | go | func New(clientProvider context.ClientProvider, opts ...ClientOption) (*Client, error) {
ctx, err := clientProvider()
if err != nil {
return nil, errors.WithMessage(err, "failed to create Client")
}
msp := Client{
ctx: ctx,
}
for _, param := range opts {
err := param(&msp)
if err != nil {
return nil, errors.WithMessage(err, "failed to create Client")
}
}
if msp.orgName == "" {
msp.orgName = ctx.IdentityConfig().Client().Organization
}
if msp.orgName == "" {
return nil, errors.New("organization is not provided")
}
caConfig, ok := ctx.IdentityConfig().CAConfig(msp.orgName)
if ok {
msp.caName = caConfig.CAName
}
networkConfig := ctx.EndpointConfig().NetworkConfig()
_, ok = networkConfig.Organizations[strings.ToLower(msp.orgName)]
if !ok {
return nil, fmt.Errorf("non-existent organization: '%s'", msp.orgName)
}
return &msp, nil
} | [
"func",
"New",
"(",
"clientProvider",
"context",
".",
"ClientProvider",
",",
"opts",
"...",
"ClientOption",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"ctx",
",",
"err",
":=",
"clientProvider",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"msp",
":=",
"Client",
"{",
"ctx",
":",
"ctx",
",",
"}",
"\n\n",
"for",
"_",
",",
"param",
":=",
"range",
"opts",
"{",
"err",
":=",
"param",
"(",
"&",
"msp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"msp",
".",
"orgName",
"==",
"\"",
"\"",
"{",
"msp",
".",
"orgName",
"=",
"ctx",
".",
"IdentityConfig",
"(",
")",
".",
"Client",
"(",
")",
".",
"Organization",
"\n",
"}",
"\n",
"if",
"msp",
".",
"orgName",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"caConfig",
",",
"ok",
":=",
"ctx",
".",
"IdentityConfig",
"(",
")",
".",
"CAConfig",
"(",
"msp",
".",
"orgName",
")",
"\n",
"if",
"ok",
"{",
"msp",
".",
"caName",
"=",
"caConfig",
".",
"CAName",
"\n",
"}",
"\n\n",
"networkConfig",
":=",
"ctx",
".",
"EndpointConfig",
"(",
")",
".",
"NetworkConfig",
"(",
")",
"\n",
"_",
",",
"ok",
"=",
"networkConfig",
".",
"Organizations",
"[",
"strings",
".",
"ToLower",
"(",
"msp",
".",
"orgName",
")",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"msp",
".",
"orgName",
")",
"\n",
"}",
"\n",
"return",
"&",
"msp",
",",
"nil",
"\n",
"}"
] | // New creates a new Client instance | [
"New",
"creates",
"a",
"new",
"Client",
"instance"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/msp/client.go#L65-L101 | train |
hyperledger/fabric-sdk-go | pkg/client/msp/client.go | WithSecret | func WithSecret(secret string) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.secret = secret
return nil
}
} | go | func WithSecret(secret string) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.secret = secret
return nil
}
} | [
"func",
"WithSecret",
"(",
"secret",
"string",
")",
"EnrollmentOption",
"{",
"return",
"func",
"(",
"o",
"*",
"enrollmentOptions",
")",
"error",
"{",
"o",
".",
"secret",
"=",
"secret",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithSecret enrollment option | [
"WithSecret",
"enrollment",
"option"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/msp/client.go#L126-L131 | train |
hyperledger/fabric-sdk-go | pkg/client/msp/client.go | WithProfile | func WithProfile(profile string) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.profile = profile
return nil
}
} | go | func WithProfile(profile string) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.profile = profile
return nil
}
} | [
"func",
"WithProfile",
"(",
"profile",
"string",
")",
"EnrollmentOption",
"{",
"return",
"func",
"(",
"o",
"*",
"enrollmentOptions",
")",
"error",
"{",
"o",
".",
"profile",
"=",
"profile",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithProfile enrollment option | [
"WithProfile",
"enrollment",
"option"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/msp/client.go#L134-L139 | train |
hyperledger/fabric-sdk-go | pkg/client/msp/client.go | WithType | func WithType(typ string) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.typ = typ
return nil
}
} | go | func WithType(typ string) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.typ = typ
return nil
}
} | [
"func",
"WithType",
"(",
"typ",
"string",
")",
"EnrollmentOption",
"{",
"return",
"func",
"(",
"o",
"*",
"enrollmentOptions",
")",
"error",
"{",
"o",
".",
"typ",
"=",
"typ",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithType enrollment option | [
"WithType",
"enrollment",
"option"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/msp/client.go#L142-L147 | train |
hyperledger/fabric-sdk-go | pkg/client/msp/client.go | WithLabel | func WithLabel(label string) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.label = label
return nil
}
} | go | func WithLabel(label string) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.label = label
return nil
}
} | [
"func",
"WithLabel",
"(",
"label",
"string",
")",
"EnrollmentOption",
"{",
"return",
"func",
"(",
"o",
"*",
"enrollmentOptions",
")",
"error",
"{",
"o",
".",
"label",
"=",
"label",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithLabel enrollment option | [
"WithLabel",
"enrollment",
"option"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/msp/client.go#L150-L155 | train |
hyperledger/fabric-sdk-go | pkg/client/msp/client.go | WithAttributeRequests | func WithAttributeRequests(attrReqs []*AttributeRequest) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.attrReqs = attrReqs
return nil
}
} | go | func WithAttributeRequests(attrReqs []*AttributeRequest) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.attrReqs = attrReqs
return nil
}
} | [
"func",
"WithAttributeRequests",
"(",
"attrReqs",
"[",
"]",
"*",
"AttributeRequest",
")",
"EnrollmentOption",
"{",
"return",
"func",
"(",
"o",
"*",
"enrollmentOptions",
")",
"error",
"{",
"o",
".",
"attrReqs",
"=",
"attrReqs",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithAttributeRequests enrollment option | [
"WithAttributeRequests",
"enrollment",
"option"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/msp/client.go#L158-L163 | train |
hyperledger/fabric-sdk-go | pkg/client/msp/client.go | prepareOptsFromOptions | func (c *Client) prepareOptsFromOptions(ctx context.Client, options ...RequestOption) (requestOptions, error) {
opts := requestOptions{}
for _, option := range options {
err := option(ctx, &opts)
if err != nil {
return opts, errors.WithMessage(err, "Failed to read opts")
}
}
return opts, nil
} | go | func (c *Client) prepareOptsFromOptions(ctx context.Client, options ...RequestOption) (requestOptions, error) {
opts := requestOptions{}
for _, option := range options {
err := option(ctx, &opts)
if err != nil {
return opts, errors.WithMessage(err, "Failed to read opts")
}
}
return opts, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"prepareOptsFromOptions",
"(",
"ctx",
"context",
".",
"Client",
",",
"options",
"...",
"RequestOption",
")",
"(",
"requestOptions",
",",
"error",
")",
"{",
"opts",
":=",
"requestOptions",
"{",
"}",
"\n",
"for",
"_",
",",
"option",
":=",
"range",
"options",
"{",
"err",
":=",
"option",
"(",
"ctx",
",",
"&",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"opts",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"opts",
",",
"nil",
"\n",
"}"
] | //prepareOptsFromOptions reads request options from Option array | [
"prepareOptsFromOptions",
"reads",
"request",
"options",
"from",
"Option",
"array"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/msp/client.go#L530-L539 | train |
hyperledger/fabric-sdk-go | pkg/client/msp/client.go | ModifyAffiliation | func (c *Client) ModifyAffiliation(request *ModifyAffiliationRequest) (*AffiliationResponse, error) {
ca, err := newCAClient(c.ctx, c.orgName)
if err != nil {
return nil, err
}
req := &mspapi.ModifyAffiliationRequest{
NewName: request.NewName,
AffiliationRequest: mspapi.AffiliationRequest{
Name: request.Name,
Force: request.Force,
CAName: request.CAName,
},
}
r, err := ca.ModifyAffiliation(req)
if err != nil {
return nil, err
}
resp := &AffiliationResponse{CAName: r.CAName, AffiliationInfo: AffiliationInfo{}}
err = fillAffiliationInfo(&resp.AffiliationInfo, r.Name, r.Affiliations, r.Identities)
return resp, err
} | go | func (c *Client) ModifyAffiliation(request *ModifyAffiliationRequest) (*AffiliationResponse, error) {
ca, err := newCAClient(c.ctx, c.orgName)
if err != nil {
return nil, err
}
req := &mspapi.ModifyAffiliationRequest{
NewName: request.NewName,
AffiliationRequest: mspapi.AffiliationRequest{
Name: request.Name,
Force: request.Force,
CAName: request.CAName,
},
}
r, err := ca.ModifyAffiliation(req)
if err != nil {
return nil, err
}
resp := &AffiliationResponse{CAName: r.CAName, AffiliationInfo: AffiliationInfo{}}
err = fillAffiliationInfo(&resp.AffiliationInfo, r.Name, r.Affiliations, r.Identities)
return resp, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ModifyAffiliation",
"(",
"request",
"*",
"ModifyAffiliationRequest",
")",
"(",
"*",
"AffiliationResponse",
",",
"error",
")",
"{",
"ca",
",",
"err",
":=",
"newCAClient",
"(",
"c",
".",
"ctx",
",",
"c",
".",
"orgName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
":=",
"&",
"mspapi",
".",
"ModifyAffiliationRequest",
"{",
"NewName",
":",
"request",
".",
"NewName",
",",
"AffiliationRequest",
":",
"mspapi",
".",
"AffiliationRequest",
"{",
"Name",
":",
"request",
".",
"Name",
",",
"Force",
":",
"request",
".",
"Force",
",",
"CAName",
":",
"request",
".",
"CAName",
",",
"}",
",",
"}",
"\n\n",
"r",
",",
"err",
":=",
"ca",
".",
"ModifyAffiliation",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"resp",
":=",
"&",
"AffiliationResponse",
"{",
"CAName",
":",
"r",
".",
"CAName",
",",
"AffiliationInfo",
":",
"AffiliationInfo",
"{",
"}",
"}",
"\n",
"err",
"=",
"fillAffiliationInfo",
"(",
"&",
"resp",
".",
"AffiliationInfo",
",",
"r",
".",
"Name",
",",
"r",
".",
"Affiliations",
",",
"r",
".",
"Identities",
")",
"\n\n",
"return",
"resp",
",",
"err",
"\n",
"}"
] | // ModifyAffiliation renames an existing affiliation on the server | [
"ModifyAffiliation",
"renames",
"an",
"existing",
"affiliation",
"on",
"the",
"server"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/msp/client.go#L614-L638 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/deliverclient/opts.go | WithSeekType | func WithSeekType(value seek.Type) options.Opt {
return func(p options.Params) {
if setter, ok := p.(seekTypeSetter); ok {
setter.SetSeekType(value)
}
}
} | go | func WithSeekType(value seek.Type) options.Opt {
return func(p options.Params) {
if setter, ok := p.(seekTypeSetter); ok {
setter.SetSeekType(value)
}
}
} | [
"func",
"WithSeekType",
"(",
"value",
"seek",
".",
"Type",
")",
"options",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"options",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"seekTypeSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetSeekType",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithSeekType specifies the point from which block events are to be received. | [
"WithSeekType",
"specifies",
"the",
"point",
"from",
"which",
"block",
"events",
"are",
"to",
"be",
"received",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/deliverclient/opts.go#L33-L39 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/deliverclient/opts.go | WithBlockNum | func WithBlockNum(value uint64) options.Opt {
return func(p options.Params) {
if setter, ok := p.(fromBlockSetter); ok {
setter.SetFromBlock(value)
}
}
} | go | func WithBlockNum(value uint64) options.Opt {
return func(p options.Params) {
if setter, ok := p.(fromBlockSetter); ok {
setter.SetFromBlock(value)
}
}
} | [
"func",
"WithBlockNum",
"(",
"value",
"uint64",
")",
"options",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"options",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"fromBlockSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetFromBlock",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithBlockNum specifies the block number from which events are to be received.
// Note that this option is only valid if SeekType is set to SeekFrom. | [
"WithBlockNum",
"specifies",
"the",
"block",
"number",
"from",
"which",
"events",
"are",
"to",
"be",
"received",
".",
"Note",
"that",
"this",
"option",
"is",
"only",
"valid",
"if",
"SeekType",
"is",
"set",
"to",
"SeekFrom",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/deliverclient/opts.go#L43-L49 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/deliverclient/opts.go | SetConnectionProvider | func (p *params) SetConnectionProvider(connProvider api.ConnectionProvider) {
logger.Debugf("ConnectionProvider: %#v", connProvider)
p.connProvider = connProvider
} | go | func (p *params) SetConnectionProvider(connProvider api.ConnectionProvider) {
logger.Debugf("ConnectionProvider: %#v", connProvider)
p.connProvider = connProvider
} | [
"func",
"(",
"p",
"*",
"params",
")",
"SetConnectionProvider",
"(",
"connProvider",
"api",
".",
"ConnectionProvider",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"connProvider",
")",
"\n",
"p",
".",
"connProvider",
"=",
"connProvider",
"\n",
"}"
] | // SetConnectionProvider is only used in unit tests | [
"SetConnectionProvider",
"is",
"only",
"used",
"in",
"unit",
"tests"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/deliverclient/opts.go#L65-L68 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockledger.go | NewMockLedger | func NewMockLedger(eventFactory EventFactory, sourceURL string) *MockLedger {
return &MockLedger{
eventFactory: eventFactory,
blockProducer: NewBlockProducer(),
sourceURL: sourceURL,
}
} | go | func NewMockLedger(eventFactory EventFactory, sourceURL string) *MockLedger {
return &MockLedger{
eventFactory: eventFactory,
blockProducer: NewBlockProducer(),
sourceURL: sourceURL,
}
} | [
"func",
"NewMockLedger",
"(",
"eventFactory",
"EventFactory",
",",
"sourceURL",
"string",
")",
"*",
"MockLedger",
"{",
"return",
"&",
"MockLedger",
"{",
"eventFactory",
":",
"eventFactory",
",",
"blockProducer",
":",
"NewBlockProducer",
"(",
")",
",",
"sourceURL",
":",
"sourceURL",
",",
"}",
"\n",
"}"
] | // NewMockLedger creates a new MockLedger | [
"NewMockLedger",
"creates",
"a",
"new",
"MockLedger"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockledger.go#L62-L68 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockledger.go | Register | func (l *MockLedger) Register(consumer Consumer) {
l.Lock()
defer l.Unlock()
l.consumers = append(l.consumers, consumer)
} | go | func (l *MockLedger) Register(consumer Consumer) {
l.Lock()
defer l.Unlock()
l.consumers = append(l.consumers, consumer)
} | [
"func",
"(",
"l",
"*",
"MockLedger",
")",
"Register",
"(",
"consumer",
"Consumer",
")",
"{",
"l",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"Unlock",
"(",
")",
"\n",
"l",
".",
"consumers",
"=",
"append",
"(",
"l",
".",
"consumers",
",",
"consumer",
")",
"\n",
"}"
] | // Register registers an event consumer | [
"Register",
"registers",
"an",
"event",
"consumer"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockledger.go#L76-L80 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockledger.go | Unregister | func (l *MockLedger) Unregister(Consumer Consumer) {
l.Lock()
defer l.Unlock()
for i, p := range l.consumers {
if p == Consumer {
if i != 0 {
l.consumers = l.consumers[1:]
}
l.consumers = l.consumers[1:]
break
}
}
} | go | func (l *MockLedger) Unregister(Consumer Consumer) {
l.Lock()
defer l.Unlock()
for i, p := range l.consumers {
if p == Consumer {
if i != 0 {
l.consumers = l.consumers[1:]
}
l.consumers = l.consumers[1:]
break
}
}
} | [
"func",
"(",
"l",
"*",
"MockLedger",
")",
"Unregister",
"(",
"Consumer",
"Consumer",
")",
"{",
"l",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"i",
",",
"p",
":=",
"range",
"l",
".",
"consumers",
"{",
"if",
"p",
"==",
"Consumer",
"{",
"if",
"i",
"!=",
"0",
"{",
"l",
".",
"consumers",
"=",
"l",
".",
"consumers",
"[",
"1",
":",
"]",
"\n",
"}",
"\n",
"l",
".",
"consumers",
"=",
"l",
".",
"consumers",
"[",
"1",
":",
"]",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Unregister unregisters the given consumer | [
"Unregister",
"unregisters",
"the",
"given",
"consumer"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockledger.go#L83-L96 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockledger.go | NewBlock | func (l *MockLedger) NewBlock(channelID string, transactions ...*TxInfo) Block {
l.Lock()
defer l.Unlock()
block := NewBlockWrapper(l.blockProducer.NewBlock(channelID, transactions...))
l.Store(block)
return block
} | go | func (l *MockLedger) NewBlock(channelID string, transactions ...*TxInfo) Block {
l.Lock()
defer l.Unlock()
block := NewBlockWrapper(l.blockProducer.NewBlock(channelID, transactions...))
l.Store(block)
return block
} | [
"func",
"(",
"l",
"*",
"MockLedger",
")",
"NewBlock",
"(",
"channelID",
"string",
",",
"transactions",
"...",
"*",
"TxInfo",
")",
"Block",
"{",
"l",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"Unlock",
"(",
")",
"\n",
"block",
":=",
"NewBlockWrapper",
"(",
"l",
".",
"blockProducer",
".",
"NewBlock",
"(",
"channelID",
",",
"transactions",
"...",
")",
")",
"\n",
"l",
".",
"Store",
"(",
"block",
")",
"\n",
"return",
"block",
"\n",
"}"
] | // NewBlock stores a new block on the ledger | [
"NewBlock",
"stores",
"a",
"new",
"block",
"on",
"the",
"ledger"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockledger.go#L99-L105 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockledger.go | NewFilteredBlock | func (l *MockLedger) NewFilteredBlock(channelID string, filteredTx ...*pb.FilteredTransaction) {
l.Lock()
defer l.Unlock()
l.Store(NewFilteredBlockWrapper(l.blockProducer.NewFilteredBlock(channelID, filteredTx...)))
} | go | func (l *MockLedger) NewFilteredBlock(channelID string, filteredTx ...*pb.FilteredTransaction) {
l.Lock()
defer l.Unlock()
l.Store(NewFilteredBlockWrapper(l.blockProducer.NewFilteredBlock(channelID, filteredTx...)))
} | [
"func",
"(",
"l",
"*",
"MockLedger",
")",
"NewFilteredBlock",
"(",
"channelID",
"string",
",",
"filteredTx",
"...",
"*",
"pb",
".",
"FilteredTransaction",
")",
"{",
"l",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"Unlock",
"(",
")",
"\n",
"l",
".",
"Store",
"(",
"NewFilteredBlockWrapper",
"(",
"l",
".",
"blockProducer",
".",
"NewFilteredBlock",
"(",
"channelID",
",",
"filteredTx",
"...",
")",
")",
")",
"\n",
"}"
] | // NewFilteredBlock stores a new filtered block on the ledger | [
"NewFilteredBlock",
"stores",
"a",
"new",
"filtered",
"block",
"on",
"the",
"ledger"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockledger.go#L108-L112 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockledger.go | Store | func (l *MockLedger) Store(block Block) {
l.blocks = append(l.blocks, block)
for _, p := range l.consumers {
blockEvent := l.eventFactory(block, l.sourceURL)
p <- blockEvent
}
} | go | func (l *MockLedger) Store(block Block) {
l.blocks = append(l.blocks, block)
for _, p := range l.consumers {
blockEvent := l.eventFactory(block, l.sourceURL)
p <- blockEvent
}
} | [
"func",
"(",
"l",
"*",
"MockLedger",
")",
"Store",
"(",
"block",
"Block",
")",
"{",
"l",
".",
"blocks",
"=",
"append",
"(",
"l",
".",
"blocks",
",",
"block",
")",
"\n\n",
"for",
"_",
",",
"p",
":=",
"range",
"l",
".",
"consumers",
"{",
"blockEvent",
":=",
"l",
".",
"eventFactory",
"(",
"block",
",",
"l",
".",
"sourceURL",
")",
"\n",
"p",
"<-",
"blockEvent",
"\n",
"}",
"\n",
"}"
] | // Store stores the given block to the ledger | [
"Store",
"stores",
"the",
"given",
"block",
"to",
"the",
"ledger"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockledger.go#L115-L122 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/mocks/mockledger.go | SendFrom | func (l *MockLedger) SendFrom(blockNum uint64) {
l.RLock()
defer l.RUnlock()
if blockNum >= uint64(len(l.blocks)) {
return
}
for _, block := range l.blocks[blockNum:] {
for _, p := range l.consumers {
p <- l.eventFactory(block, l.sourceURL)
}
}
} | go | func (l *MockLedger) SendFrom(blockNum uint64) {
l.RLock()
defer l.RUnlock()
if blockNum >= uint64(len(l.blocks)) {
return
}
for _, block := range l.blocks[blockNum:] {
for _, p := range l.consumers {
p <- l.eventFactory(block, l.sourceURL)
}
}
} | [
"func",
"(",
"l",
"*",
"MockLedger",
")",
"SendFrom",
"(",
"blockNum",
"uint64",
")",
"{",
"l",
".",
"RLock",
"(",
")",
"\n",
"defer",
"l",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"blockNum",
">=",
"uint64",
"(",
"len",
"(",
"l",
".",
"blocks",
")",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"block",
":=",
"range",
"l",
".",
"blocks",
"[",
"blockNum",
":",
"]",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"l",
".",
"consumers",
"{",
"p",
"<-",
"l",
".",
"eventFactory",
"(",
"block",
",",
"l",
".",
"sourceURL",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // SendFrom sends block events to all registered consumers from the
// given block number | [
"SendFrom",
"sends",
"block",
"events",
"to",
"all",
"registered",
"consumers",
"from",
"the",
"given",
"block",
"number"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockledger.go#L126-L139 | train |
hyperledger/fabric-sdk-go | pkg/client/common/discovery/dynamicdiscovery/localservice.go | newLocalService | func newLocalService(config fab.EndpointConfig, mspID string, opts ...coptions.Opt) *LocalService {
logger.Debug("Creating new local discovery service")
s := &LocalService{mspID: mspID}
s.service = newService(config, s.queryPeers, opts...)
return s
} | go | func newLocalService(config fab.EndpointConfig, mspID string, opts ...coptions.Opt) *LocalService {
logger.Debug("Creating new local discovery service")
s := &LocalService{mspID: mspID}
s.service = newService(config, s.queryPeers, opts...)
return s
} | [
"func",
"newLocalService",
"(",
"config",
"fab",
".",
"EndpointConfig",
",",
"mspID",
"string",
",",
"opts",
"...",
"coptions",
".",
"Opt",
")",
"*",
"LocalService",
"{",
"logger",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"s",
":=",
"&",
"LocalService",
"{",
"mspID",
":",
"mspID",
"}",
"\n",
"s",
".",
"service",
"=",
"newService",
"(",
"config",
",",
"s",
".",
"queryPeers",
",",
"opts",
"...",
")",
"\n",
"return",
"s",
"\n",
"}"
] | // newLocalService creates a Local Discovery Service to query the list of member peers in the local MSP. | [
"newLocalService",
"creates",
"a",
"Local",
"Discovery",
"Service",
"to",
"query",
"the",
"list",
"of",
"member",
"peers",
"in",
"the",
"local",
"MSP",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/discovery/dynamicdiscovery/localservice.go#L26-L32 | train |
hyperledger/fabric-sdk-go | pkg/client/common/discovery/dynamicdiscovery/localservice.go | Initialize | func (s *LocalService) Initialize(ctx contextAPI.Local) error {
if ctx.Identifier().MSPID != s.mspID {
return errors.Errorf("expecting context for MSP [%s] but got [%s]", s.mspID, ctx.Identifier().MSPID)
}
return s.service.initialize(ctx)
} | go | func (s *LocalService) Initialize(ctx contextAPI.Local) error {
if ctx.Identifier().MSPID != s.mspID {
return errors.Errorf("expecting context for MSP [%s] but got [%s]", s.mspID, ctx.Identifier().MSPID)
}
return s.service.initialize(ctx)
} | [
"func",
"(",
"s",
"*",
"LocalService",
")",
"Initialize",
"(",
"ctx",
"contextAPI",
".",
"Local",
")",
"error",
"{",
"if",
"ctx",
".",
"Identifier",
"(",
")",
".",
"MSPID",
"!=",
"s",
".",
"mspID",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"mspID",
",",
"ctx",
".",
"Identifier",
"(",
")",
".",
"MSPID",
")",
"\n",
"}",
"\n",
"return",
"s",
".",
"service",
".",
"initialize",
"(",
"ctx",
")",
"\n",
"}"
] | // Initialize initializes the service with local context | [
"Initialize",
"initializes",
"the",
"service",
"with",
"local",
"context"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/discovery/dynamicdiscovery/localservice.go#L35-L40 | train |
hyperledger/fabric-sdk-go | pkg/client/common/discovery/dynamicdiscovery/localservice.go | filterLocalMSP | func (s *LocalService) filterLocalMSP(peers []fab.Peer) []fab.Peer {
localMSPID := s.ctx.Identifier().MSPID
var filteredPeers []fab.Peer
for _, p := range peers {
if p.MSPID() != localMSPID {
logger.Debugf("Peer [%s] is not part of the local MSP [%s] but in MSP [%s]", p.URL(), localMSPID, p.MSPID())
} else {
filteredPeers = append(filteredPeers, p)
}
}
return filteredPeers
} | go | func (s *LocalService) filterLocalMSP(peers []fab.Peer) []fab.Peer {
localMSPID := s.ctx.Identifier().MSPID
var filteredPeers []fab.Peer
for _, p := range peers {
if p.MSPID() != localMSPID {
logger.Debugf("Peer [%s] is not part of the local MSP [%s] but in MSP [%s]", p.URL(), localMSPID, p.MSPID())
} else {
filteredPeers = append(filteredPeers, p)
}
}
return filteredPeers
} | [
"func",
"(",
"s",
"*",
"LocalService",
")",
"filterLocalMSP",
"(",
"peers",
"[",
"]",
"fab",
".",
"Peer",
")",
"[",
"]",
"fab",
".",
"Peer",
"{",
"localMSPID",
":=",
"s",
".",
"ctx",
".",
"Identifier",
"(",
")",
".",
"MSPID",
"\n",
"var",
"filteredPeers",
"[",
"]",
"fab",
".",
"Peer",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"peers",
"{",
"if",
"p",
".",
"MSPID",
"(",
")",
"!=",
"localMSPID",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"p",
".",
"URL",
"(",
")",
",",
"localMSPID",
",",
"p",
".",
"MSPID",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"filteredPeers",
"=",
"append",
"(",
"filteredPeers",
",",
"p",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"filteredPeers",
"\n",
"}"
] | // Even though the local peer query should only return peers in the local
// MSP, this function double checks and logs a warning if this is not the case. | [
"Even",
"though",
"the",
"local",
"peer",
"query",
"should",
"only",
"return",
"peers",
"in",
"the",
"local",
"MSP",
"this",
"function",
"double",
"checks",
"and",
"logs",
"a",
"warning",
"if",
"this",
"is",
"not",
"the",
"case",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/discovery/dynamicdiscovery/localservice.go#L111-L122 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/transactor.go | NewTransactor | func NewTransactor(reqCtx reqContext.Context, cfg fab.ChannelCfg) (*Transactor, error) {
ctx, ok := contextImpl.RequestClientContext(reqCtx)
if !ok {
return nil, errors.New("failed get client context from reqContext for create new transactor")
}
orderers, err := orderersFromChannelCfg(ctx, cfg)
if err != nil {
return nil, errors.WithMessage(err, "reading orderers from channel config failed")
}
// TODO: adjust integration tests to always have valid orderers (even when doing only queries)
//if len(orderers) == 0 {
// return nil, errors.New("orderers are not configured")
//}
t := Transactor{
reqCtx: reqCtx,
ChannelID: cfg.ID(),
orderers: orderers,
}
return &t, nil
} | go | func NewTransactor(reqCtx reqContext.Context, cfg fab.ChannelCfg) (*Transactor, error) {
ctx, ok := contextImpl.RequestClientContext(reqCtx)
if !ok {
return nil, errors.New("failed get client context from reqContext for create new transactor")
}
orderers, err := orderersFromChannelCfg(ctx, cfg)
if err != nil {
return nil, errors.WithMessage(err, "reading orderers from channel config failed")
}
// TODO: adjust integration tests to always have valid orderers (even when doing only queries)
//if len(orderers) == 0 {
// return nil, errors.New("orderers are not configured")
//}
t := Transactor{
reqCtx: reqCtx,
ChannelID: cfg.ID(),
orderers: orderers,
}
return &t, nil
} | [
"func",
"NewTransactor",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"cfg",
"fab",
".",
"ChannelCfg",
")",
"(",
"*",
"Transactor",
",",
"error",
")",
"{",
"ctx",
",",
"ok",
":=",
"contextImpl",
".",
"RequestClientContext",
"(",
"reqCtx",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"orderers",
",",
"err",
":=",
"orderersFromChannelCfg",
"(",
"ctx",
",",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"// TODO: adjust integration tests to always have valid orderers (even when doing only queries)",
"//if len(orderers) == 0 {",
"//\treturn nil, errors.New(\"orderers are not configured\")",
"//}",
"t",
":=",
"Transactor",
"{",
"reqCtx",
":",
"reqCtx",
",",
"ChannelID",
":",
"cfg",
".",
"ID",
"(",
")",
",",
"orderers",
":",
"orderers",
",",
"}",
"\n",
"return",
"&",
"t",
",",
"nil",
"\n",
"}"
] | // NewTransactor returns a Transactor for the current context and channel config. | [
"NewTransactor",
"returns",
"a",
"Transactor",
"for",
"the",
"current",
"context",
"and",
"channel",
"config",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/transactor.go#L30-L52 | train |
hyperledger/fabric-sdk-go | pkg/fab/channel/transactor.go | orderersFromChannel | func orderersFromChannel(ctx context.Client, channelID string) ([]fab.Orderer, error) {
chNetworkConfig := ctx.EndpointConfig().ChannelConfig(channelID)
orderers := []fab.Orderer{}
for _, chOrderer := range chNetworkConfig.Orderers {
ordererConfig, found := ctx.EndpointConfig().OrdererConfig(chOrderer)
if !found {
//continue if given channel orderer not found in endpoint config
continue
}
orderer, err := ctx.InfraProvider().CreateOrdererFromConfig(ordererConfig)
if err != nil {
return nil, errors.WithMessage(err, "failed to create orderer from config")
}
orderers = append(orderers, orderer)
}
return orderers, nil
} | go | func orderersFromChannel(ctx context.Client, channelID string) ([]fab.Orderer, error) {
chNetworkConfig := ctx.EndpointConfig().ChannelConfig(channelID)
orderers := []fab.Orderer{}
for _, chOrderer := range chNetworkConfig.Orderers {
ordererConfig, found := ctx.EndpointConfig().OrdererConfig(chOrderer)
if !found {
//continue if given channel orderer not found in endpoint config
continue
}
orderer, err := ctx.InfraProvider().CreateOrdererFromConfig(ordererConfig)
if err != nil {
return nil, errors.WithMessage(err, "failed to create orderer from config")
}
orderers = append(orderers, orderer)
}
return orderers, nil
} | [
"func",
"orderersFromChannel",
"(",
"ctx",
"context",
".",
"Client",
",",
"channelID",
"string",
")",
"(",
"[",
"]",
"fab",
".",
"Orderer",
",",
"error",
")",
"{",
"chNetworkConfig",
":=",
"ctx",
".",
"EndpointConfig",
"(",
")",
".",
"ChannelConfig",
"(",
"channelID",
")",
"\n",
"orderers",
":=",
"[",
"]",
"fab",
".",
"Orderer",
"{",
"}",
"\n",
"for",
"_",
",",
"chOrderer",
":=",
"range",
"chNetworkConfig",
".",
"Orderers",
"{",
"ordererConfig",
",",
"found",
":=",
"ctx",
".",
"EndpointConfig",
"(",
")",
".",
"OrdererConfig",
"(",
"chOrderer",
")",
"\n",
"if",
"!",
"found",
"{",
"//continue if given channel orderer not found in endpoint config",
"continue",
"\n",
"}",
"\n\n",
"orderer",
",",
"err",
":=",
"ctx",
".",
"InfraProvider",
"(",
")",
".",
"CreateOrdererFromConfig",
"(",
"ordererConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"orderers",
"=",
"append",
"(",
"orderers",
",",
"orderer",
")",
"\n",
"}",
"\n",
"return",
"orderers",
",",
"nil",
"\n",
"}"
] | //deprecated
//orderersFromChannel returns list of fab.Orderer by channel id
//will return empty list when orderers are not found in endpoint config | [
"deprecated",
"orderersFromChannel",
"returns",
"list",
"of",
"fab",
".",
"Orderer",
"by",
"channel",
"id",
"will",
"return",
"empty",
"list",
"when",
"orderers",
"are",
"not",
"found",
"in",
"endpoint",
"config"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/transactor.go#L109-L129 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/options/opts.go | NewParams | func NewParams(opts []copts.Opt) *Params {
params := &Params{}
copts.Apply(params, opts)
return params
} | go | func NewParams(opts []copts.Opt) *Params {
params := &Params{}
copts.Apply(params, opts)
return params
} | [
"func",
"NewParams",
"(",
"opts",
"[",
"]",
"copts",
".",
"Opt",
")",
"*",
"Params",
"{",
"params",
":=",
"&",
"Params",
"{",
"}",
"\n",
"copts",
".",
"Apply",
"(",
"params",
",",
"opts",
")",
"\n",
"return",
"params",
"\n",
"}"
] | // NewParams creates new parameters based on the provided options | [
"NewParams",
"creates",
"new",
"parameters",
"based",
"on",
"the",
"provided",
"options"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/options/opts.go#L41-L45 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/options/opts.go | WithPeerFilter | func WithPeerFilter(value PeerFilter) copts.Opt {
return func(p copts.Params) {
logger.Debugf("Checking PeerFilter: %#+v", value)
if setter, ok := p.(peerFilterSetter); ok {
setter.SetPeerFilter(value)
}
}
} | go | func WithPeerFilter(value PeerFilter) copts.Opt {
return func(p copts.Params) {
logger.Debugf("Checking PeerFilter: %#+v", value)
if setter, ok := p.(peerFilterSetter); ok {
setter.SetPeerFilter(value)
}
}
} | [
"func",
"WithPeerFilter",
"(",
"value",
"PeerFilter",
")",
"copts",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"copts",
".",
"Params",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"value",
")",
"\n",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"peerFilterSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetPeerFilter",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithPeerFilter sets a peer filter which provides per-request filtering of peers | [
"WithPeerFilter",
"sets",
"a",
"peer",
"filter",
"which",
"provides",
"per",
"-",
"request",
"filtering",
"of",
"peers"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/options/opts.go#L48-L55 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/options/opts.go | WithPeerSorter | func WithPeerSorter(value PeerSorter) copts.Opt {
return func(p copts.Params) {
if setter, ok := p.(peerSorterSetter); ok {
setter.SetPeerSorter(value)
}
}
} | go | func WithPeerSorter(value PeerSorter) copts.Opt {
return func(p copts.Params) {
if setter, ok := p.(peerSorterSetter); ok {
setter.SetPeerSorter(value)
}
}
} | [
"func",
"WithPeerSorter",
"(",
"value",
"PeerSorter",
")",
"copts",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"copts",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"peerSorterSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetPeerSorter",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithPeerSorter sets a peer sorter function which provides per-request
// sorting of peers | [
"WithPeerSorter",
"sets",
"a",
"peer",
"sorter",
"function",
"which",
"provides",
"per",
"-",
"request",
"sorting",
"of",
"peers"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/options/opts.go#L59-L65 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/options/opts.go | WithPrioritySelector | func WithPrioritySelector(value PrioritySelector) copts.Opt {
return WithPeerSorter(func(peers []fab.Peer) []fab.Peer {
return sortPeers(peers, value)
})
} | go | func WithPrioritySelector(value PrioritySelector) copts.Opt {
return WithPeerSorter(func(peers []fab.Peer) []fab.Peer {
return sortPeers(peers, value)
})
} | [
"func",
"WithPrioritySelector",
"(",
"value",
"PrioritySelector",
")",
"copts",
".",
"Opt",
"{",
"return",
"WithPeerSorter",
"(",
"func",
"(",
"peers",
"[",
"]",
"fab",
".",
"Peer",
")",
"[",
"]",
"fab",
".",
"Peer",
"{",
"return",
"sortPeers",
"(",
"peers",
",",
"value",
")",
"\n",
"}",
")",
"\n",
"}"
] | // WithPrioritySelector sets a priority selector function which provides per-request
// prioritization of peers | [
"WithPrioritySelector",
"sets",
"a",
"priority",
"selector",
"function",
"which",
"provides",
"per",
"-",
"request",
"prioritization",
"of",
"peers"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/options/opts.go#L69-L73 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/options/opts.go | WithRetryOpts | func WithRetryOpts(value retry.Opts) copts.Opt {
return func(p copts.Params) {
if setter, ok := p.(retryOptsSetter); ok {
setter.SetRetryOpts(value)
}
}
} | go | func WithRetryOpts(value retry.Opts) copts.Opt {
return func(p copts.Params) {
if setter, ok := p.(retryOptsSetter); ok {
setter.SetRetryOpts(value)
}
}
} | [
"func",
"WithRetryOpts",
"(",
"value",
"retry",
".",
"Opts",
")",
"copts",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"copts",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"retryOptsSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetRetryOpts",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithRetryOpts sets the retry options | [
"WithRetryOpts",
"sets",
"the",
"retry",
"options"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/options/opts.go#L76-L82 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/options/opts.go | SetPeerFilter | func (p *Params) SetPeerFilter(value PeerFilter) {
logger.Debugf("PeerFilter: %#+v", value)
p.PeerFilter = value
} | go | func (p *Params) SetPeerFilter(value PeerFilter) {
logger.Debugf("PeerFilter: %#+v", value)
p.PeerFilter = value
} | [
"func",
"(",
"p",
"*",
"Params",
")",
"SetPeerFilter",
"(",
"value",
"PeerFilter",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"value",
")",
"\n",
"p",
".",
"PeerFilter",
"=",
"value",
"\n",
"}"
] | // SetPeerFilter sets the peer filter | [
"SetPeerFilter",
"sets",
"the",
"peer",
"filter"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/options/opts.go#L89-L92 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/options/opts.go | SetPeerSorter | func (p *Params) SetPeerSorter(value PeerSorter) {
logger.Debugf("PeerSorter: %#+v", value)
p.PeerSorter = value
} | go | func (p *Params) SetPeerSorter(value PeerSorter) {
logger.Debugf("PeerSorter: %#+v", value)
p.PeerSorter = value
} | [
"func",
"(",
"p",
"*",
"Params",
")",
"SetPeerSorter",
"(",
"value",
"PeerSorter",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"value",
")",
"\n",
"p",
".",
"PeerSorter",
"=",
"value",
"\n",
"}"
] | // SetPeerSorter sets the priority selector | [
"SetPeerSorter",
"sets",
"the",
"priority",
"selector"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/options/opts.go#L99-L102 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/options/opts.go | SetRetryOpts | func (p *Params) SetRetryOpts(value retry.Opts) {
logger.Debugf("RetryOpts: %#+v", value)
p.RetryOpts = value
} | go | func (p *Params) SetRetryOpts(value retry.Opts) {
logger.Debugf("RetryOpts: %#+v", value)
p.RetryOpts = value
} | [
"func",
"(",
"p",
"*",
"Params",
")",
"SetRetryOpts",
"(",
"value",
"retry",
".",
"Opts",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"value",
")",
"\n",
"p",
".",
"RetryOpts",
"=",
"value",
"\n",
"}"
] | // SetRetryOpts sets the priority selector | [
"SetRetryOpts",
"sets",
"the",
"priority",
"selector"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/options/opts.go#L109-L112 | train |
hyperledger/fabric-sdk-go | pkg/common/errors/retry/invoker.go | NewInvoker | func NewInvoker(handler Handler, opts ...InvokerOpt) *RetryableInvoker {
invoker := &RetryableInvoker{
handler: handler,
}
for _, opt := range opts {
opt(invoker)
}
return invoker
} | go | func NewInvoker(handler Handler, opts ...InvokerOpt) *RetryableInvoker {
invoker := &RetryableInvoker{
handler: handler,
}
for _, opt := range opts {
opt(invoker)
}
return invoker
} | [
"func",
"NewInvoker",
"(",
"handler",
"Handler",
",",
"opts",
"...",
"InvokerOpt",
")",
"*",
"RetryableInvoker",
"{",
"invoker",
":=",
"&",
"RetryableInvoker",
"{",
"handler",
":",
"handler",
",",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"invoker",
")",
"\n",
"}",
"\n",
"return",
"invoker",
"\n",
"}"
] | // NewInvoker creates a new RetryableInvoker | [
"NewInvoker",
"creates",
"a",
"new",
"RetryableInvoker"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/common/errors/retry/invoker.go#L41-L49 | train |
hyperledger/fabric-sdk-go | pkg/common/errors/retry/invoker.go | Invoke | func (ri *RetryableInvoker) Invoke(invocation Invocation) (interface{}, error) {
attemptNum := 0
var lastErr error
for {
attemptNum++
if attemptNum > 1 {
logger.Debugf("Retry attempt #%d on error [%s]", attemptNum, lastErr)
}
retval, err := invocation()
if err == nil {
if attemptNum > 1 {
logger.Debugf("Success on attempt #%d after error [%s]", attemptNum, lastErr)
}
return retval, nil
}
logger.Debugf("Failed with err [%s] on attempt #%d. Checking if retry is warranted...", err, attemptNum)
if !ri.resolveRetry(err) {
if lastErr != nil && lastErr.Error() != err.Error() {
logger.Debugf("... retry for err [%s] is NOT warranted after %d attempt(s). Previous error [%s]", err, attemptNum, lastErr)
} else {
logger.Debugf("... retry for err [%s] is NOT warranted after %d attempt(s).", err, attemptNum)
}
return nil, err
}
logger.Debugf("... retry for err [%s] is warranted", err)
lastErr = err
}
} | go | func (ri *RetryableInvoker) Invoke(invocation Invocation) (interface{}, error) {
attemptNum := 0
var lastErr error
for {
attemptNum++
if attemptNum > 1 {
logger.Debugf("Retry attempt #%d on error [%s]", attemptNum, lastErr)
}
retval, err := invocation()
if err == nil {
if attemptNum > 1 {
logger.Debugf("Success on attempt #%d after error [%s]", attemptNum, lastErr)
}
return retval, nil
}
logger.Debugf("Failed with err [%s] on attempt #%d. Checking if retry is warranted...", err, attemptNum)
if !ri.resolveRetry(err) {
if lastErr != nil && lastErr.Error() != err.Error() {
logger.Debugf("... retry for err [%s] is NOT warranted after %d attempt(s). Previous error [%s]", err, attemptNum, lastErr)
} else {
logger.Debugf("... retry for err [%s] is NOT warranted after %d attempt(s).", err, attemptNum)
}
return nil, err
}
logger.Debugf("... retry for err [%s] is warranted", err)
lastErr = err
}
} | [
"func",
"(",
"ri",
"*",
"RetryableInvoker",
")",
"Invoke",
"(",
"invocation",
"Invocation",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"attemptNum",
":=",
"0",
"\n",
"var",
"lastErr",
"error",
"\n\n",
"for",
"{",
"attemptNum",
"++",
"\n",
"if",
"attemptNum",
">",
"1",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"attemptNum",
",",
"lastErr",
")",
"\n",
"}",
"\n\n",
"retval",
",",
"err",
":=",
"invocation",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"attemptNum",
">",
"1",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"attemptNum",
",",
"lastErr",
")",
"\n",
"}",
"\n",
"return",
"retval",
",",
"nil",
"\n",
"}",
"\n\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"err",
",",
"attemptNum",
")",
"\n",
"if",
"!",
"ri",
".",
"resolveRetry",
"(",
"err",
")",
"{",
"if",
"lastErr",
"!=",
"nil",
"&&",
"lastErr",
".",
"Error",
"(",
")",
"!=",
"err",
".",
"Error",
"(",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"err",
",",
"attemptNum",
",",
"lastErr",
")",
"\n",
"}",
"else",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"err",
",",
"attemptNum",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"lastErr",
"=",
"err",
"\n",
"}",
"\n",
"}"
] | // Invoke invokes the given function and performs retries according
// to the retry options. | [
"Invoke",
"invokes",
"the",
"given",
"function",
"and",
"performs",
"retries",
"according",
"to",
"the",
"retry",
"options",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/common/errors/retry/invoker.go#L53-L83 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | GetLogger | func (p *Provider) GetLogger(module string) api.Logger {
newDefLogger := log.New(os.Stdout, fmt.Sprintf(logPrefixFormatter, module), log.Ldate|log.Ltime|log.LUTC)
return &Log{deflogger: newDefLogger, module: module}
} | go | func (p *Provider) GetLogger(module string) api.Logger {
newDefLogger := log.New(os.Stdout, fmt.Sprintf(logPrefixFormatter, module), log.Ldate|log.Ltime|log.LUTC)
return &Log{deflogger: newDefLogger, module: module}
} | [
"func",
"(",
"p",
"*",
"Provider",
")",
"GetLogger",
"(",
"module",
"string",
")",
"api",
".",
"Logger",
"{",
"newDefLogger",
":=",
"log",
".",
"New",
"(",
"os",
".",
"Stdout",
",",
"fmt",
".",
"Sprintf",
"(",
"logPrefixFormatter",
",",
"module",
")",
",",
"log",
".",
"Ldate",
"|",
"log",
".",
"Ltime",
"|",
"log",
".",
"LUTC",
")",
"\n",
"return",
"&",
"Log",
"{",
"deflogger",
":",
"newDefLogger",
",",
"module",
":",
"module",
"}",
"\n",
"}"
] | //GetLogger returns SDK logger implementation | [
"GetLogger",
"returns",
"SDK",
"logger",
"implementation"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L38-L41 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | InitLogger | func InitLogger(l api.LoggerProvider) {
loggerProviderOnce.Do(func() {
loggerProviderInstance = l
atomic.StoreInt32(&useCustomLogger, 1)
})
} | go | func InitLogger(l api.LoggerProvider) {
loggerProviderOnce.Do(func() {
loggerProviderInstance = l
atomic.StoreInt32(&useCustomLogger, 1)
})
} | [
"func",
"InitLogger",
"(",
"l",
"api",
".",
"LoggerProvider",
")",
"{",
"loggerProviderOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"loggerProviderInstance",
"=",
"l",
"\n",
"atomic",
".",
"StoreInt32",
"(",
"&",
"useCustomLogger",
",",
"1",
")",
"\n",
"}",
")",
"\n",
"}"
] | //InitLogger sets custom logger which will be used over deflogger.
//It is required to call this function before making any loggings. | [
"InitLogger",
"sets",
"custom",
"logger",
"which",
"will",
"be",
"used",
"over",
"deflogger",
".",
"It",
"is",
"required",
"to",
"call",
"this",
"function",
"before",
"making",
"any",
"loggings",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L50-L55 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | SetLevel | func SetLevel(module string, level api.Level) {
rwmutex.Lock()
defer rwmutex.Unlock()
moduleLevels.SetLevel(module, level)
} | go | func SetLevel(module string, level api.Level) {
rwmutex.Lock()
defer rwmutex.Unlock()
moduleLevels.SetLevel(module, level)
} | [
"func",
"SetLevel",
"(",
"module",
"string",
",",
"level",
"api",
".",
"Level",
")",
"{",
"rwmutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rwmutex",
".",
"Unlock",
"(",
")",
"\n",
"moduleLevels",
".",
"SetLevel",
"(",
"module",
",",
"level",
")",
"\n",
"}"
] | //SetLevel - setting log level for given module | [
"SetLevel",
"-",
"setting",
"log",
"level",
"for",
"given",
"module"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L79-L83 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | GetLevel | func GetLevel(module string) api.Level {
rwmutex.RLock()
defer rwmutex.RUnlock()
return moduleLevels.GetLevel(module)
} | go | func GetLevel(module string) api.Level {
rwmutex.RLock()
defer rwmutex.RUnlock()
return moduleLevels.GetLevel(module)
} | [
"func",
"GetLevel",
"(",
"module",
"string",
")",
"api",
".",
"Level",
"{",
"rwmutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"rwmutex",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"moduleLevels",
".",
"GetLevel",
"(",
"module",
")",
"\n",
"}"
] | //GetLevel - getting log level for given module | [
"GetLevel",
"-",
"getting",
"log",
"level",
"for",
"given",
"module"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L86-L90 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | IsEnabledFor | func IsEnabledFor(module string, level api.Level) bool {
rwmutex.RLock()
defer rwmutex.RUnlock()
return moduleLevels.IsEnabledFor(module, level)
} | go | func IsEnabledFor(module string, level api.Level) bool {
rwmutex.RLock()
defer rwmutex.RUnlock()
return moduleLevels.IsEnabledFor(module, level)
} | [
"func",
"IsEnabledFor",
"(",
"module",
"string",
",",
"level",
"api",
".",
"Level",
")",
"bool",
"{",
"rwmutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"rwmutex",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"moduleLevels",
".",
"IsEnabledFor",
"(",
"module",
",",
"level",
")",
"\n",
"}"
] | //IsEnabledFor - Check if given log level is enabled for given module | [
"IsEnabledFor",
"-",
"Check",
"if",
"given",
"log",
"level",
"is",
"enabled",
"for",
"given",
"module"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L93-L97 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | HideCallerInfo | func HideCallerInfo(module string, level api.Level) {
rwmutex.Lock()
defer rwmutex.Unlock()
callerInfos.HideCallerInfo(module, level)
} | go | func HideCallerInfo(module string, level api.Level) {
rwmutex.Lock()
defer rwmutex.Unlock()
callerInfos.HideCallerInfo(module, level)
} | [
"func",
"HideCallerInfo",
"(",
"module",
"string",
",",
"level",
"api",
".",
"Level",
")",
"{",
"rwmutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rwmutex",
".",
"Unlock",
"(",
")",
"\n",
"callerInfos",
".",
"HideCallerInfo",
"(",
"module",
",",
"level",
")",
"\n",
"}"
] | //HideCallerInfo - Do not show caller info in log lines for given log level | [
"HideCallerInfo",
"-",
"Do",
"not",
"show",
"caller",
"info",
"in",
"log",
"lines",
"for",
"given",
"log",
"level"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L107-L111 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | getLoggerOpts | func getLoggerOpts(module string, level api.Level) *loggerOpts {
rwmutex.RLock()
defer rwmutex.RUnlock()
return &loggerOpts{
levelEnabled: moduleLevels.IsEnabledFor(module, level),
callerInfoEnabled: callerInfos.IsCallerInfoEnabled(module, level),
}
} | go | func getLoggerOpts(module string, level api.Level) *loggerOpts {
rwmutex.RLock()
defer rwmutex.RUnlock()
return &loggerOpts{
levelEnabled: moduleLevels.IsEnabledFor(module, level),
callerInfoEnabled: callerInfos.IsCallerInfoEnabled(module, level),
}
} | [
"func",
"getLoggerOpts",
"(",
"module",
"string",
",",
"level",
"api",
".",
"Level",
")",
"*",
"loggerOpts",
"{",
"rwmutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"rwmutex",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"&",
"loggerOpts",
"{",
"levelEnabled",
":",
"moduleLevels",
".",
"IsEnabledFor",
"(",
"module",
",",
"level",
")",
",",
"callerInfoEnabled",
":",
"callerInfos",
".",
"IsCallerInfoEnabled",
"(",
"module",
",",
"level",
")",
",",
"}",
"\n",
"}"
] | //getLoggerOpts - returns LoggerOpts which can be used for customization | [
"getLoggerOpts",
"-",
"returns",
"LoggerOpts",
"which",
"can",
"be",
"used",
"for",
"customization"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L114-L121 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Print | func (l *Log) Print(args ...interface{}) {
if l.loadCustomLogger() {
l.customLogger.Print(args...)
return
}
l.deflogger.Print(args...)
} | go | func (l *Log) Print(args ...interface{}) {
if l.loadCustomLogger() {
l.customLogger.Print(args...)
return
}
l.deflogger.Print(args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Print",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Print",
"(",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"deflogger",
".",
"Print",
"(",
"args",
"...",
")",
"\n",
"}"
] | // Print calls go log.Output.
// Arguments are handled in the manner of fmt.Print. | [
"Print",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Print",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L191-L197 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Printf | func (l *Log) Printf(format string, args ...interface{}) {
if l.loadCustomLogger() {
l.customLogger.Printf(format, args...)
return
}
l.deflogger.Printf(format, args...)
} | go | func (l *Log) Printf(format string, args ...interface{}) {
if l.loadCustomLogger() {
l.customLogger.Printf(format, args...)
return
}
l.deflogger.Printf(format, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Printf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Printf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"deflogger",
".",
"Printf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"}"
] | // Printf calls go log.Output.
// Arguments are handled in the manner of fmt.Printf. | [
"Printf",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Printf",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L201-L207 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Println | func (l *Log) Println(args ...interface{}) {
if l.loadCustomLogger() {
l.customLogger.Println(args...)
return
}
l.deflogger.Println(args...)
} | go | func (l *Log) Println(args ...interface{}) {
if l.loadCustomLogger() {
l.customLogger.Println(args...)
return
}
l.deflogger.Println(args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Println",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Println",
"(",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"deflogger",
".",
"Println",
"(",
"args",
"...",
")",
"\n",
"}"
] | // Println calls go log.Output.
// Arguments are handled in the manner of fmt.Println. | [
"Println",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Println",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L211-L217 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Debug | func (l *Log) Debug(args ...interface{}) {
opts := getLoggerOpts(l.module, api.DEBUG)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Debug(args...)
return
}
l.log(opts, api.DEBUG, args...)
} | go | func (l *Log) Debug(args ...interface{}) {
opts := getLoggerOpts(l.module, api.DEBUG)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Debug(args...)
return
}
l.log(opts, api.DEBUG, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Debug",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"opts",
":=",
"getLoggerOpts",
"(",
"l",
".",
"module",
",",
"api",
".",
"DEBUG",
")",
"\n",
"if",
"!",
"opts",
".",
"levelEnabled",
"{",
"return",
"\n",
"}",
"\n",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Debug",
"(",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"log",
"(",
"opts",
",",
"api",
".",
"DEBUG",
",",
"args",
"...",
")",
"\n",
"}"
] | // Debug calls go log.Output.
// Arguments are handled in the manner of fmt.Print. | [
"Debug",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Print",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L221-L231 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Debugf | func (l *Log) Debugf(format string, args ...interface{}) {
opts := getLoggerOpts(l.module, api.DEBUG)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Debugf(format, args...)
return
}
l.logf(opts, api.DEBUG, format, args...)
} | go | func (l *Log) Debugf(format string, args ...interface{}) {
opts := getLoggerOpts(l.module, api.DEBUG)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Debugf(format, args...)
return
}
l.logf(opts, api.DEBUG, format, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Debugf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"opts",
":=",
"getLoggerOpts",
"(",
"l",
".",
"module",
",",
"api",
".",
"DEBUG",
")",
"\n",
"if",
"!",
"opts",
".",
"levelEnabled",
"{",
"return",
"\n",
"}",
"\n",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Debugf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"logf",
"(",
"opts",
",",
"api",
".",
"DEBUG",
",",
"format",
",",
"args",
"...",
")",
"\n",
"}"
] | // Debugf calls go log.Output.
// Arguments are handled in the manner of fmt.Printf. | [
"Debugf",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Printf",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L235-L245 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Debugln | func (l *Log) Debugln(args ...interface{}) {
opts := getLoggerOpts(l.module, api.DEBUG)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Debugln(args...)
return
}
l.logln(opts, api.DEBUG, args...)
} | go | func (l *Log) Debugln(args ...interface{}) {
opts := getLoggerOpts(l.module, api.DEBUG)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Debugln(args...)
return
}
l.logln(opts, api.DEBUG, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Debugln",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"opts",
":=",
"getLoggerOpts",
"(",
"l",
".",
"module",
",",
"api",
".",
"DEBUG",
")",
"\n",
"if",
"!",
"opts",
".",
"levelEnabled",
"{",
"return",
"\n",
"}",
"\n",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Debugln",
"(",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"logln",
"(",
"opts",
",",
"api",
".",
"DEBUG",
",",
"args",
"...",
")",
"\n",
"}"
] | // Debugln calls go log.Output.
// Arguments are handled in the manner of fmt.Println. | [
"Debugln",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Println",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L249-L259 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Info | func (l *Log) Info(args ...interface{}) {
opts := getLoggerOpts(l.module, api.INFO)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Info(args...)
return
}
l.log(opts, api.INFO, args...)
} | go | func (l *Log) Info(args ...interface{}) {
opts := getLoggerOpts(l.module, api.INFO)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Info(args...)
return
}
l.log(opts, api.INFO, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Info",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"opts",
":=",
"getLoggerOpts",
"(",
"l",
".",
"module",
",",
"api",
".",
"INFO",
")",
"\n",
"if",
"!",
"opts",
".",
"levelEnabled",
"{",
"return",
"\n",
"}",
"\n",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Info",
"(",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"log",
"(",
"opts",
",",
"api",
".",
"INFO",
",",
"args",
"...",
")",
"\n",
"}"
] | // Info calls go log.Output.
// Arguments are handled in the manner of fmt.Print. | [
"Info",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Print",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L263-L273 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Infof | func (l *Log) Infof(format string, args ...interface{}) {
opts := getLoggerOpts(l.module, api.INFO)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Infof(format, args...)
return
}
l.logf(opts, api.INFO, format, args...)
} | go | func (l *Log) Infof(format string, args ...interface{}) {
opts := getLoggerOpts(l.module, api.INFO)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Infof(format, args...)
return
}
l.logf(opts, api.INFO, format, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Infof",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"opts",
":=",
"getLoggerOpts",
"(",
"l",
".",
"module",
",",
"api",
".",
"INFO",
")",
"\n",
"if",
"!",
"opts",
".",
"levelEnabled",
"{",
"return",
"\n",
"}",
"\n",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Infof",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"logf",
"(",
"opts",
",",
"api",
".",
"INFO",
",",
"format",
",",
"args",
"...",
")",
"\n",
"}"
] | // Infof calls go log.Output.
// Arguments are handled in the manner of fmt.Printf. | [
"Infof",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Printf",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L277-L287 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Infoln | func (l *Log) Infoln(args ...interface{}) {
opts := getLoggerOpts(l.module, api.INFO)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Infoln(args...)
return
}
l.logln(opts, api.INFO, args...)
} | go | func (l *Log) Infoln(args ...interface{}) {
opts := getLoggerOpts(l.module, api.INFO)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Infoln(args...)
return
}
l.logln(opts, api.INFO, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Infoln",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"opts",
":=",
"getLoggerOpts",
"(",
"l",
".",
"module",
",",
"api",
".",
"INFO",
")",
"\n",
"if",
"!",
"opts",
".",
"levelEnabled",
"{",
"return",
"\n",
"}",
"\n",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Infoln",
"(",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"logln",
"(",
"opts",
",",
"api",
".",
"INFO",
",",
"args",
"...",
")",
"\n",
"}"
] | // Infoln calls go log.Output.
// Arguments are handled in the manner of fmt.Println. | [
"Infoln",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Println",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L291-L301 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Warn | func (l *Log) Warn(args ...interface{}) {
opts := getLoggerOpts(l.module, api.WARNING)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Warn(args...)
return
}
l.log(opts, api.WARNING, args...)
} | go | func (l *Log) Warn(args ...interface{}) {
opts := getLoggerOpts(l.module, api.WARNING)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Warn(args...)
return
}
l.log(opts, api.WARNING, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Warn",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"opts",
":=",
"getLoggerOpts",
"(",
"l",
".",
"module",
",",
"api",
".",
"WARNING",
")",
"\n",
"if",
"!",
"opts",
".",
"levelEnabled",
"{",
"return",
"\n",
"}",
"\n",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Warn",
"(",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"log",
"(",
"opts",
",",
"api",
".",
"WARNING",
",",
"args",
"...",
")",
"\n",
"}"
] | // Warn calls go log.Output.
// Arguments are handled in the manner of fmt.Print. | [
"Warn",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Print",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L305-L315 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Warnf | func (l *Log) Warnf(format string, args ...interface{}) {
opts := getLoggerOpts(l.module, api.WARNING)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Warnf(format, args...)
return
}
l.logf(opts, api.WARNING, format, args...)
} | go | func (l *Log) Warnf(format string, args ...interface{}) {
opts := getLoggerOpts(l.module, api.WARNING)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Warnf(format, args...)
return
}
l.logf(opts, api.WARNING, format, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Warnf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"opts",
":=",
"getLoggerOpts",
"(",
"l",
".",
"module",
",",
"api",
".",
"WARNING",
")",
"\n",
"if",
"!",
"opts",
".",
"levelEnabled",
"{",
"return",
"\n",
"}",
"\n",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Warnf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"logf",
"(",
"opts",
",",
"api",
".",
"WARNING",
",",
"format",
",",
"args",
"...",
")",
"\n",
"}"
] | // Warnf calls go log.Output.
// Arguments are handled in the manner of fmt.Printf. | [
"Warnf",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Printf",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L319-L329 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Warnln | func (l *Log) Warnln(args ...interface{}) {
opts := getLoggerOpts(l.module, api.WARNING)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Warnln(args...)
return
}
l.logln(opts, api.WARNING, args...)
} | go | func (l *Log) Warnln(args ...interface{}) {
opts := getLoggerOpts(l.module, api.WARNING)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Warnln(args...)
return
}
l.logln(opts, api.WARNING, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Warnln",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"opts",
":=",
"getLoggerOpts",
"(",
"l",
".",
"module",
",",
"api",
".",
"WARNING",
")",
"\n",
"if",
"!",
"opts",
".",
"levelEnabled",
"{",
"return",
"\n",
"}",
"\n",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Warnln",
"(",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"logln",
"(",
"opts",
",",
"api",
".",
"WARNING",
",",
"args",
"...",
")",
"\n",
"}"
] | // Warnln calls go log.Output.
// Arguments are handled in the manner of fmt.Println. | [
"Warnln",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Println",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L333-L343 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Error | func (l *Log) Error(args ...interface{}) {
opts := getLoggerOpts(l.module, api.ERROR)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Error(args...)
return
}
l.log(opts, api.ERROR, args...)
} | go | func (l *Log) Error(args ...interface{}) {
opts := getLoggerOpts(l.module, api.ERROR)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Error(args...)
return
}
l.log(opts, api.ERROR, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Error",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"opts",
":=",
"getLoggerOpts",
"(",
"l",
".",
"module",
",",
"api",
".",
"ERROR",
")",
"\n",
"if",
"!",
"opts",
".",
"levelEnabled",
"{",
"return",
"\n",
"}",
"\n",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Error",
"(",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"log",
"(",
"opts",
",",
"api",
".",
"ERROR",
",",
"args",
"...",
")",
"\n",
"}"
] | // Error calls go log.Output.
// Arguments are handled in the manner of fmt.Print. | [
"Error",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Print",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L347-L357 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Errorf | func (l *Log) Errorf(format string, args ...interface{}) {
opts := getLoggerOpts(l.module, api.ERROR)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Errorf(format, args...)
return
}
l.logf(opts, api.ERROR, format, args...)
} | go | func (l *Log) Errorf(format string, args ...interface{}) {
opts := getLoggerOpts(l.module, api.ERROR)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Errorf(format, args...)
return
}
l.logf(opts, api.ERROR, format, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Errorf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"opts",
":=",
"getLoggerOpts",
"(",
"l",
".",
"module",
",",
"api",
".",
"ERROR",
")",
"\n",
"if",
"!",
"opts",
".",
"levelEnabled",
"{",
"return",
"\n",
"}",
"\n",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Errorf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"logf",
"(",
"opts",
",",
"api",
".",
"ERROR",
",",
"format",
",",
"args",
"...",
")",
"\n",
"}"
] | // Errorf calls go log.Output.
// Arguments are handled in the manner of fmt.Printf. | [
"Errorf",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Printf",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L361-L371 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | Errorln | func (l *Log) Errorln(args ...interface{}) {
opts := getLoggerOpts(l.module, api.ERROR)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Errorln(args...)
return
}
l.logln(opts, api.ERROR, args...)
} | go | func (l *Log) Errorln(args ...interface{}) {
opts := getLoggerOpts(l.module, api.ERROR)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Errorln(args...)
return
}
l.logln(opts, api.ERROR, args...)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"Errorln",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"opts",
":=",
"getLoggerOpts",
"(",
"l",
".",
"module",
",",
"api",
".",
"ERROR",
")",
"\n",
"if",
"!",
"opts",
".",
"levelEnabled",
"{",
"return",
"\n",
"}",
"\n",
"if",
"l",
".",
"loadCustomLogger",
"(",
")",
"{",
"l",
".",
"customLogger",
".",
"Errorln",
"(",
"args",
"...",
")",
"\n",
"return",
"\n",
"}",
"\n",
"l",
".",
"logln",
"(",
"opts",
",",
"api",
".",
"ERROR",
",",
"args",
"...",
")",
"\n",
"}"
] | // Errorln calls go log.Output.
// Arguments are handled in the manner of fmt.Println. | [
"Errorln",
"calls",
"go",
"log",
".",
"Output",
".",
"Arguments",
"are",
"handled",
"in",
"the",
"manner",
"of",
"fmt",
".",
"Println",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L375-L385 | train |
hyperledger/fabric-sdk-go | pkg/core/logging/modlog/modlog.go | ChangeOutput | func (l *Log) ChangeOutput(output io.Writer) {
l.deflogger.SetOutput(output)
} | go | func (l *Log) ChangeOutput(output io.Writer) {
l.deflogger.SetOutput(output)
} | [
"func",
"(",
"l",
"*",
"Log",
")",
"ChangeOutput",
"(",
"output",
"io",
".",
"Writer",
")",
"{",
"l",
".",
"deflogger",
".",
"SetOutput",
"(",
"output",
")",
"\n",
"}"
] | //ChangeOutput for changing output destination for the logger. | [
"ChangeOutput",
"for",
"changing",
"output",
"destination",
"for",
"the",
"logger",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/modlog/modlog.go#L388-L390 | train |
hyperledger/fabric-sdk-go | pkg/client/common/discovery/greylist/greylist.go | Accept | func (b *Filter) Accept(peer fab.Peer) bool {
peerAddress := endpoint.ToAddress(peer.URL())
value, ok := b.greylistURLs.Load(peerAddress)
if ok {
timeAdded, ok := value.(time.Time)
if ok && timeAdded.Add(b.expiryInterval).After(time.Now()) {
logger.Infof("Rejecting peer %s", peer.URL())
return false
}
b.greylistURLs.Delete(peerAddress)
}
return true
} | go | func (b *Filter) Accept(peer fab.Peer) bool {
peerAddress := endpoint.ToAddress(peer.URL())
value, ok := b.greylistURLs.Load(peerAddress)
if ok {
timeAdded, ok := value.(time.Time)
if ok && timeAdded.Add(b.expiryInterval).After(time.Now()) {
logger.Infof("Rejecting peer %s", peer.URL())
return false
}
b.greylistURLs.Delete(peerAddress)
}
return true
} | [
"func",
"(",
"b",
"*",
"Filter",
")",
"Accept",
"(",
"peer",
"fab",
".",
"Peer",
")",
"bool",
"{",
"peerAddress",
":=",
"endpoint",
".",
"ToAddress",
"(",
"peer",
".",
"URL",
"(",
")",
")",
"\n",
"value",
",",
"ok",
":=",
"b",
".",
"greylistURLs",
".",
"Load",
"(",
"peerAddress",
")",
"\n",
"if",
"ok",
"{",
"timeAdded",
",",
"ok",
":=",
"value",
".",
"(",
"time",
".",
"Time",
")",
"\n",
"if",
"ok",
"&&",
"timeAdded",
".",
"Add",
"(",
"b",
".",
"expiryInterval",
")",
".",
"After",
"(",
"time",
".",
"Now",
"(",
")",
")",
"{",
"logger",
".",
"Infof",
"(",
"\"",
"\"",
",",
"peer",
".",
"URL",
"(",
")",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"b",
".",
"greylistURLs",
".",
"Delete",
"(",
"peerAddress",
")",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] | // Accept returns whether or not to Accept a peer as a canditate for endorsement | [
"Accept",
"returns",
"whether",
"or",
"not",
"to",
"Accept",
"a",
"peer",
"as",
"a",
"canditate",
"for",
"endorsement"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/discovery/greylist/greylist.go#L36-L49 | train |
hyperledger/fabric-sdk-go | pkg/client/common/discovery/greylist/greylist.go | Greylist | func (b *Filter) Greylist(err error) {
s, ok := status.FromError(err)
if !ok {
return
}
if ok, peerURL := required(s); ok && peerURL != "" {
logger.Infof("Greylisting peer %s", peerURL)
b.greylistURLs.Store(peerURL, time.Now())
}
} | go | func (b *Filter) Greylist(err error) {
s, ok := status.FromError(err)
if !ok {
return
}
if ok, peerURL := required(s); ok && peerURL != "" {
logger.Infof("Greylisting peer %s", peerURL)
b.greylistURLs.Store(peerURL, time.Now())
}
} | [
"func",
"(",
"b",
"*",
"Filter",
")",
"Greylist",
"(",
"err",
"error",
")",
"{",
"s",
",",
"ok",
":=",
"status",
".",
"FromError",
"(",
"err",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"if",
"ok",
",",
"peerURL",
":=",
"required",
"(",
"s",
")",
";",
"ok",
"&&",
"peerURL",
"!=",
"\"",
"\"",
"{",
"logger",
".",
"Infof",
"(",
"\"",
"\"",
",",
"peerURL",
")",
"\n",
"b",
".",
"greylistURLs",
".",
"Store",
"(",
"peerURL",
",",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // Greylist the given peer URL | [
"Greylist",
"the",
"given",
"peer",
"URL"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/discovery/greylist/greylist.go#L52-L61 | train |
hyperledger/fabric-sdk-go | pkg/client/common/discovery/greylist/greylist.go | required | func required(s *status.Status) (bool, string) {
if s.Group == status.EndorserClientStatus && s.Code == status.ConnectionFailed.ToInt32() {
return true, peerURLFromConnectionFailedStatus(s.Details)
}
return false, ""
} | go | func required(s *status.Status) (bool, string) {
if s.Group == status.EndorserClientStatus && s.Code == status.ConnectionFailed.ToInt32() {
return true, peerURLFromConnectionFailedStatus(s.Details)
}
return false, ""
} | [
"func",
"required",
"(",
"s",
"*",
"status",
".",
"Status",
")",
"(",
"bool",
",",
"string",
")",
"{",
"if",
"s",
".",
"Group",
"==",
"status",
".",
"EndorserClientStatus",
"&&",
"s",
".",
"Code",
"==",
"status",
".",
"ConnectionFailed",
".",
"ToInt32",
"(",
")",
"{",
"return",
"true",
",",
"peerURLFromConnectionFailedStatus",
"(",
"s",
".",
"Details",
")",
"\n",
"}",
"\n",
"return",
"false",
",",
"\"",
"\"",
"\n",
"}"
] | // required decides whether the given status error warrants a greylist
// on the peer causing the error | [
"required",
"decides",
"whether",
"the",
"given",
"status",
"error",
"warrants",
"a",
"greylist",
"on",
"the",
"peer",
"causing",
"the",
"error"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/discovery/greylist/greylist.go#L65-L70 | train |
hyperledger/fabric-sdk-go | pkg/client/common/discovery/greylist/greylist.go | peerURLFromConnectionFailedStatus | func peerURLFromConnectionFailedStatus(details []interface{}) string {
if len(details) != 0 {
url, ok := details[0].(string)
if ok {
return endpoint.ToAddress(url)
}
}
return ""
} | go | func peerURLFromConnectionFailedStatus(details []interface{}) string {
if len(details) != 0 {
url, ok := details[0].(string)
if ok {
return endpoint.ToAddress(url)
}
}
return ""
} | [
"func",
"peerURLFromConnectionFailedStatus",
"(",
"details",
"[",
"]",
"interface",
"{",
"}",
")",
"string",
"{",
"if",
"len",
"(",
"details",
")",
"!=",
"0",
"{",
"url",
",",
"ok",
":=",
"details",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"if",
"ok",
"{",
"return",
"endpoint",
".",
"ToAddress",
"(",
"url",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // peerURLFromConnectionFailedStatus extracts the peer url from the status error
// details | [
"peerURLFromConnectionFailedStatus",
"extracts",
"the",
"peer",
"url",
"from",
"the",
"status",
"error",
"details"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/discovery/greylist/greylist.go#L74-L82 | train |
hyperledger/fabric-sdk-go | pkg/client/common/discovery/dynamicdiscovery/service.go | initialize | func (s *service) initialize(ctx contextAPI.Client) error {
s.lock.Lock()
defer s.lock.Unlock()
if s.ctx != nil {
// Already initialized
logger.Debugf("Already initialized with context: %#v", s.ctx)
return nil
}
discoveryClient, err := clientProvider(ctx)
if err != nil {
return errors.Wrap(err, "error creating discover client")
}
logger.Debugf("Initializing with context: %#v", ctx)
s.ctx = ctx
s.discClient = discoveryClient
return nil
} | go | func (s *service) initialize(ctx contextAPI.Client) error {
s.lock.Lock()
defer s.lock.Unlock()
if s.ctx != nil {
// Already initialized
logger.Debugf("Already initialized with context: %#v", s.ctx)
return nil
}
discoveryClient, err := clientProvider(ctx)
if err != nil {
return errors.Wrap(err, "error creating discover client")
}
logger.Debugf("Initializing with context: %#v", ctx)
s.ctx = ctx
s.discClient = discoveryClient
return nil
} | [
"func",
"(",
"s",
"*",
"service",
")",
"initialize",
"(",
"ctx",
"contextAPI",
".",
"Client",
")",
"error",
"{",
"s",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"s",
".",
"ctx",
"!=",
"nil",
"{",
"// Already initialized",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"s",
".",
"ctx",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"discoveryClient",
",",
"err",
":=",
"clientProvider",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"ctx",
")",
"\n",
"s",
".",
"ctx",
"=",
"ctx",
"\n",
"s",
".",
"discClient",
"=",
"discoveryClient",
"\n",
"return",
"nil",
"\n",
"}"
] | // initialize initializes the service with client context | [
"initialize",
"initializes",
"the",
"service",
"with",
"client",
"context"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/discovery/dynamicdiscovery/service.go#L83-L102 | train |
hyperledger/fabric-sdk-go | pkg/client/common/discovery/dynamicdiscovery/service.go | GetPeers | func (s *service) GetPeers() ([]fab.Peer, error) {
if s.peersRef.IsClosed() {
return nil, errors.Errorf("Discovery client has been closed")
}
refValue, err := s.peersRef.Get()
if err != nil {
return nil, err
}
peers, ok := refValue.([]fab.Peer)
if !ok {
return nil, errors.New("get peersRef didn't return Peer type")
}
return peers, nil
} | go | func (s *service) GetPeers() ([]fab.Peer, error) {
if s.peersRef.IsClosed() {
return nil, errors.Errorf("Discovery client has been closed")
}
refValue, err := s.peersRef.Get()
if err != nil {
return nil, err
}
peers, ok := refValue.([]fab.Peer)
if !ok {
return nil, errors.New("get peersRef didn't return Peer type")
}
return peers, nil
} | [
"func",
"(",
"s",
"*",
"service",
")",
"GetPeers",
"(",
")",
"(",
"[",
"]",
"fab",
".",
"Peer",
",",
"error",
")",
"{",
"if",
"s",
".",
"peersRef",
".",
"IsClosed",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"refValue",
",",
"err",
":=",
"s",
".",
"peersRef",
".",
"Get",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"peers",
",",
"ok",
":=",
"refValue",
".",
"(",
"[",
"]",
"fab",
".",
"Peer",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"peers",
",",
"nil",
"\n",
"}"
] | // GetPeers returns the available peers | [
"GetPeers",
"returns",
"the",
"available",
"peers"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/discovery/dynamicdiscovery/service.go#L111-L125 | train |
hyperledger/fabric-sdk-go | pkg/client/resmgmt/lscc.go | createChaincodeDeployProposal | func createChaincodeDeployProposal(txh fab.TransactionHeader, deploy chaincodeProposalType, channelID string, chaincode chaincodeDeployRequest) (*fab.TransactionProposal, error) {
// Generate arguments for deploy (channel, marshaled CCDS, marshaled chaincode policy, marshaled collection policy)
args := [][]byte{}
args = append(args, []byte(channelID))
ccds := &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{
Type: pb.ChaincodeSpec_GOLANG, ChaincodeId: &pb.ChaincodeID{Name: chaincode.Name, Path: chaincode.Path, Version: chaincode.Version},
Input: &pb.ChaincodeInput{Args: chaincode.Args}}}
ccdsBytes, err := protoutil.Marshal(ccds)
if err != nil {
return nil, errors.WithMessage(err, "marshal of chaincode deployment spec failed")
}
args = append(args, ccdsBytes)
chaincodePolicyBytes, err := protoutil.Marshal(chaincode.Policy)
if err != nil {
return nil, errors.WithMessage(err, "marshal of chaincode policy failed")
}
args = append(args, chaincodePolicyBytes)
args = append(args, []byte(escc))
args = append(args, []byte(vscc))
if chaincode.CollConfig != nil {
collConfigBytes, err := proto.Marshal(&common.CollectionConfigPackage{Config: chaincode.CollConfig})
if err != nil {
return nil, errors.WithMessage(err, "marshal of collection policy failed")
}
args = append(args, collConfigBytes)
}
// Fcn is deploy or upgrade
fcn := ""
switch deploy {
case InstantiateChaincode:
fcn = lsccDeploy
case UpgradeChaincode:
fcn = lsccUpgrade
default:
return nil, errors.New("chaincode deployment type unknown")
}
cir := fab.ChaincodeInvokeRequest{
ChaincodeID: lscc,
Fcn: fcn,
Args: args,
}
return txn.CreateChaincodeInvokeProposal(txh, cir)
} | go | func createChaincodeDeployProposal(txh fab.TransactionHeader, deploy chaincodeProposalType, channelID string, chaincode chaincodeDeployRequest) (*fab.TransactionProposal, error) {
// Generate arguments for deploy (channel, marshaled CCDS, marshaled chaincode policy, marshaled collection policy)
args := [][]byte{}
args = append(args, []byte(channelID))
ccds := &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{
Type: pb.ChaincodeSpec_GOLANG, ChaincodeId: &pb.ChaincodeID{Name: chaincode.Name, Path: chaincode.Path, Version: chaincode.Version},
Input: &pb.ChaincodeInput{Args: chaincode.Args}}}
ccdsBytes, err := protoutil.Marshal(ccds)
if err != nil {
return nil, errors.WithMessage(err, "marshal of chaincode deployment spec failed")
}
args = append(args, ccdsBytes)
chaincodePolicyBytes, err := protoutil.Marshal(chaincode.Policy)
if err != nil {
return nil, errors.WithMessage(err, "marshal of chaincode policy failed")
}
args = append(args, chaincodePolicyBytes)
args = append(args, []byte(escc))
args = append(args, []byte(vscc))
if chaincode.CollConfig != nil {
collConfigBytes, err := proto.Marshal(&common.CollectionConfigPackage{Config: chaincode.CollConfig})
if err != nil {
return nil, errors.WithMessage(err, "marshal of collection policy failed")
}
args = append(args, collConfigBytes)
}
// Fcn is deploy or upgrade
fcn := ""
switch deploy {
case InstantiateChaincode:
fcn = lsccDeploy
case UpgradeChaincode:
fcn = lsccUpgrade
default:
return nil, errors.New("chaincode deployment type unknown")
}
cir := fab.ChaincodeInvokeRequest{
ChaincodeID: lscc,
Fcn: fcn,
Args: args,
}
return txn.CreateChaincodeInvokeProposal(txh, cir)
} | [
"func",
"createChaincodeDeployProposal",
"(",
"txh",
"fab",
".",
"TransactionHeader",
",",
"deploy",
"chaincodeProposalType",
",",
"channelID",
"string",
",",
"chaincode",
"chaincodeDeployRequest",
")",
"(",
"*",
"fab",
".",
"TransactionProposal",
",",
"error",
")",
"{",
"// Generate arguments for deploy (channel, marshaled CCDS, marshaled chaincode policy, marshaled collection policy)",
"args",
":=",
"[",
"]",
"[",
"]",
"byte",
"{",
"}",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"[",
"]",
"byte",
"(",
"channelID",
")",
")",
"\n\n",
"ccds",
":=",
"&",
"pb",
".",
"ChaincodeDeploymentSpec",
"{",
"ChaincodeSpec",
":",
"&",
"pb",
".",
"ChaincodeSpec",
"{",
"Type",
":",
"pb",
".",
"ChaincodeSpec_GOLANG",
",",
"ChaincodeId",
":",
"&",
"pb",
".",
"ChaincodeID",
"{",
"Name",
":",
"chaincode",
".",
"Name",
",",
"Path",
":",
"chaincode",
".",
"Path",
",",
"Version",
":",
"chaincode",
".",
"Version",
"}",
",",
"Input",
":",
"&",
"pb",
".",
"ChaincodeInput",
"{",
"Args",
":",
"chaincode",
".",
"Args",
"}",
"}",
"}",
"\n",
"ccdsBytes",
",",
"err",
":=",
"protoutil",
".",
"Marshal",
"(",
"ccds",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"ccdsBytes",
")",
"\n\n",
"chaincodePolicyBytes",
",",
"err",
":=",
"protoutil",
".",
"Marshal",
"(",
"chaincode",
".",
"Policy",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"chaincodePolicyBytes",
")",
"\n\n",
"args",
"=",
"append",
"(",
"args",
",",
"[",
"]",
"byte",
"(",
"escc",
")",
")",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"[",
"]",
"byte",
"(",
"vscc",
")",
")",
"\n\n",
"if",
"chaincode",
".",
"CollConfig",
"!=",
"nil",
"{",
"collConfigBytes",
",",
"err",
":=",
"proto",
".",
"Marshal",
"(",
"&",
"common",
".",
"CollectionConfigPackage",
"{",
"Config",
":",
"chaincode",
".",
"CollConfig",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"collConfigBytes",
")",
"\n",
"}",
"\n\n",
"// Fcn is deploy or upgrade",
"fcn",
":=",
"\"",
"\"",
"\n",
"switch",
"deploy",
"{",
"case",
"InstantiateChaincode",
":",
"fcn",
"=",
"lsccDeploy",
"\n",
"case",
"UpgradeChaincode",
":",
"fcn",
"=",
"lsccUpgrade",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cir",
":=",
"fab",
".",
"ChaincodeInvokeRequest",
"{",
"ChaincodeID",
":",
"lscc",
",",
"Fcn",
":",
"fcn",
",",
"Args",
":",
"args",
",",
"}",
"\n",
"return",
"txn",
".",
"CreateChaincodeInvokeProposal",
"(",
"txh",
",",
"cir",
")",
"\n",
"}"
] | // createChaincodeDeployProposal creates an instantiate or upgrade chaincode proposal. | [
"createChaincodeDeployProposal",
"creates",
"an",
"instantiate",
"or",
"upgrade",
"chaincode",
"proposal",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/resmgmt/lscc.go#L48-L97 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockchannel.go | NewMockChannel | func NewMockChannel(channelID string) (*Channel, error) {
ctx := &mockClientContext{
Providers: NewMockProviderContext(),
SigningIdentity: mspmocks.NewMockSigningIdentity("user", "Org1MSP"),
}
// Set up mock channel service
chProvider, err := NewMockChannelProvider(ctx)
if err != nil {
return nil, errors.WithMessage(err, "new mock channel provider failed")
}
channelService, err := chProvider.ChannelService(ctx, channelID)
if err != nil {
return nil, errors.WithMessage(err, "failed to create mock channel service")
}
peer := NewMockPeer("Peer1", "example.com")
channelService.(*MockChannelService).SetDiscovery(NewMockDiscoveryService(nil, peer))
channelService.(*MockChannelService).SetSelection(NewMockSelectionService(nil, peer))
channel := &Channel{
Client: ctx,
channelService: channelService,
channelID: channelID,
}
return channel, nil
} | go | func NewMockChannel(channelID string) (*Channel, error) {
ctx := &mockClientContext{
Providers: NewMockProviderContext(),
SigningIdentity: mspmocks.NewMockSigningIdentity("user", "Org1MSP"),
}
// Set up mock channel service
chProvider, err := NewMockChannelProvider(ctx)
if err != nil {
return nil, errors.WithMessage(err, "new mock channel provider failed")
}
channelService, err := chProvider.ChannelService(ctx, channelID)
if err != nil {
return nil, errors.WithMessage(err, "failed to create mock channel service")
}
peer := NewMockPeer("Peer1", "example.com")
channelService.(*MockChannelService).SetDiscovery(NewMockDiscoveryService(nil, peer))
channelService.(*MockChannelService).SetSelection(NewMockSelectionService(nil, peer))
channel := &Channel{
Client: ctx,
channelService: channelService,
channelID: channelID,
}
return channel, nil
} | [
"func",
"NewMockChannel",
"(",
"channelID",
"string",
")",
"(",
"*",
"Channel",
",",
"error",
")",
"{",
"ctx",
":=",
"&",
"mockClientContext",
"{",
"Providers",
":",
"NewMockProviderContext",
"(",
")",
",",
"SigningIdentity",
":",
"mspmocks",
".",
"NewMockSigningIdentity",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"}",
"\n\n",
"// Set up mock channel service",
"chProvider",
",",
"err",
":=",
"NewMockChannelProvider",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"channelService",
",",
"err",
":=",
"chProvider",
".",
"ChannelService",
"(",
"ctx",
",",
"channelID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"peer",
":=",
"NewMockPeer",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"channelService",
".",
"(",
"*",
"MockChannelService",
")",
".",
"SetDiscovery",
"(",
"NewMockDiscoveryService",
"(",
"nil",
",",
"peer",
")",
")",
"\n",
"channelService",
".",
"(",
"*",
"MockChannelService",
")",
".",
"SetSelection",
"(",
"NewMockSelectionService",
"(",
"nil",
",",
"peer",
")",
")",
"\n\n",
"channel",
":=",
"&",
"Channel",
"{",
"Client",
":",
"ctx",
",",
"channelService",
":",
"channelService",
",",
"channelID",
":",
"channelID",
",",
"}",
"\n\n",
"return",
"channel",
",",
"nil",
"\n",
"}"
] | //NewMockChannel creates new mock channel | [
"NewMockChannel",
"creates",
"new",
"mock",
"channel"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockchannel.go#L46-L75 | train |
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",
"//Set default suite",
"logger",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"// Use SW as the default cryptosuite when not initialized properly - should be for testing only",
"s",
",",
"err",
":=",
"sw",
".",
"GetSuiteWithDefaultEphemeral",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Panicf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"initSuite",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Panicf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\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",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"signingUser",
":=",
"signer",
"\n",
"// If signing user is not provided default to client's user context",
"if",
"signingUser",
"==",
"nil",
"{",
"signingUser",
"=",
"ctx",
"\n",
"}",
"\n\n",
"if",
"signingUser",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"sigCtx",
":=",
"fabCtx",
"{",
"Providers",
":",
"ctx",
",",
"SigningIdentity",
":",
"signingUser",
",",
"}",
"\n\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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"request",
".",
"Name",
"==",
"\"",
"\"",
"{",
"return",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"request",
".",
"Envelope",
"!=",
"nil",
"{",
"return",
"createChannelFromEnvelope",
"(",
"reqCtx",
",",
"request",
")",
"\n",
"}",
"\n\n",
"if",
"request",
".",
"Config",
"==",
"nil",
"{",
"return",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"request",
".",
"Signatures",
"==",
"nil",
"{",
"return",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"ctx",
",",
"ok",
":=",
"contextImpl",
".",
"RequestClientContext",
"(",
"reqCtx",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"txh",
",",
"err",
":=",
"txn",
".",
"NewHeader",
"(",
"ctx",
",",
"request",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"optionsValue",
":=",
"getOpts",
"(",
"opts",
"...",
")",
"\n\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",
"(",
"\"",
"\"",
",",
"channelName",
")",
"\n\n",
"optionsValue",
":=",
"getOpts",
"(",
"opts",
"...",
")",
"\n\n",
"// Get the newest block",
"block",
",",
"err",
":=",
"retrieveBlock",
"(",
"reqCtx",
",",
"[",
"]",
"fab",
".",
"Orderer",
"{",
"orderer",
"}",
",",
"channelName",
",",
"newNewestSeekPosition",
"(",
")",
",",
"optionsValue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\\n",
"\"",
",",
"block",
".",
"Header",
".",
"Number",
")",
"\n\n",
"// Get the index of the last config block",
"lastConfig",
",",
"err",
":=",
"GetLastConfigFromBlock",
"(",
"block",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\\n",
"\"",
",",
"lastConfig",
".",
"Index",
")",
"\n\n",
"// Get the last config block",
"block",
",",
"err",
"=",
"retrieveBlock",
"(",
"reqCtx",
",",
"[",
"]",
"fab",
".",
"Orderer",
"{",
"orderer",
"}",
",",
"channelName",
",",
"newSpecificSeekPosition",
"(",
"lastConfig",
".",
"Index",
")",
",",
"optionsValue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"block",
".",
"Header",
".",
"Number",
",",
"len",
"(",
"block",
".",
"Data",
".",
"Data",
")",
")",
"\n\n",
"if",
"len",
"(",
"block",
".",
"Data",
".",
"Data",
")",
"!=",
"1",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"block",
",",
"nil",
"\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",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"ctx",
",",
"ok",
":=",
"contextImpl",
".",
"RequestClientContext",
"(",
"reqCtx",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"hash",
",",
"err",
":=",
"ccomm",
".",
"TLSCertHash",
"(",
"ctx",
".",
"EndpointConfig",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\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",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"payload",
",",
"err",
":=",
"txn",
".",
"CreatePayload",
"(",
"txh",
",",
"channelHeader",
",",
"configUpdateEnvelopeBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"txn",
".",
"BroadcastPayload",
"(",
"reqCtx",
",",
"payload",
",",
"[",
"]",
"fab",
".",
"Orderer",
"{",
"request",
".",
"Orderer",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"optionsValue",
":=",
"getOpts",
"(",
"opts",
"...",
")",
"\n\n",
"cir",
":=",
"createChannelsInvokeRequest",
"(",
")",
"\n",
"payload",
",",
"err",
":=",
"queryChaincodeWithTarget",
"(",
"reqCtx",
",",
"cir",
",",
"peer",
",",
"optionsValue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"response",
":=",
"new",
"(",
"pb",
".",
"ChannelQueryResponse",
")",
"\n",
"err",
"=",
"proto",
".",
"Unmarshal",
"(",
"payload",
",",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"Path",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"Version",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"Package",
"==",
"nil",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"propReq",
":=",
"ChaincodeInstallRequest",
"{",
"Name",
":",
"req",
".",
"Name",
",",
"Path",
":",
"req",
".",
"Path",
",",
"Version",
":",
"req",
".",
"Version",
",",
"Package",
":",
"&",
"ChaincodePackage",
"{",
"Type",
":",
"req",
".",
"Package",
".",
"Type",
",",
"Code",
":",
"req",
".",
"Package",
".",
"Code",
",",
"}",
",",
"}",
"\n\n",
"ctx",
",",
"ok",
":=",
"contextImpl",
".",
"RequestClientContext",
"(",
"reqCtx",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"txh",
",",
"err",
":=",
"txn",
".",
"NewHeader",
"(",
"ctx",
",",
"fab",
".",
"SystemChannel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"prop",
",",
"err",
":=",
"CreateChaincodeInstallProposal",
"(",
"txh",
",",
"propReq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fab",
".",
"EmptyTransactionID",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"optionsValue",
":=",
"getOpts",
"(",
"opts",
"...",
")",
"\n\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\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\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\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"preferredPeers",
")",
"\n\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",
"{",
"// At least one of our preferred peers is suitable. Use the default balancer to balance between them.",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"r",
".",
"loadBalancePolicy",
".",
"Choose",
"(",
"preferredPeers",
")",
"\n",
"}",
"\n\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"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",
")",
"{",
"// We're not connected to a preferred peer. Check if we can connect back to one.",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"connectedPeer",
".",
"URL",
"(",
")",
",",
"r",
".",
"preferredPeers",
")",
"\n\n",
"if",
"len",
"(",
"r",
".",
"getPreferredPeers",
"(",
"r",
".",
"minBlockHeightResolver",
".",
"Filter",
"(",
"peers",
")",
")",
")",
">",
"0",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"connectedPeer",
".",
"URL",
"(",
")",
")",
"\n",
"return",
"true",
"\n",
"}",
"\n\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"connectedPeer",
".",
"URL",
"(",
")",
")",
"\n",
"}",
"\n\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.