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
list | docstring
stringlengths 6
2.61k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/dispatcher/opts.go
|
WithPeerResolver
|
func WithPeerResolver(value peerresolver.Provider) options.Opt {
return func(p options.Params) {
if setter, ok := p.(peerResolverSetter); ok {
setter.SetPeerResolver(value)
}
}
}
|
go
|
func WithPeerResolver(value peerresolver.Provider) options.Opt {
return func(p options.Params) {
if setter, ok := p.(peerResolverSetter); ok {
setter.SetPeerResolver(value)
}
}
}
|
[
"func",
"WithPeerResolver",
"(",
"value",
"peerresolver",
".",
"Provider",
")",
"options",
".",
"Opt",
"{",
"return",
"func",
"(",
"p",
"options",
".",
"Params",
")",
"{",
"if",
"setter",
",",
"ok",
":=",
"p",
".",
"(",
"peerResolverSetter",
")",
";",
"ok",
"{",
"setter",
".",
"SetPeerResolver",
"(",
"value",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// WithPeerResolver sets the peer resolver that chooses the peer from a discovered list of peers.
|
[
"WithPeerResolver",
"sets",
"the",
"peer",
"resolver",
"that",
"chooses",
"the",
"peer",
"from",
"a",
"discovered",
"list",
"of",
"peers",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/dispatcher/opts.go#L72-L78
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/common/selection/dynamicselection/pgresolver/mocks.go
|
NewPrincipal
|
func NewPrincipal(name string, classification mb.MSPPrincipal_Classification) (*mb.MSPPrincipal, error) {
member1Role, err := proto.Marshal(&mb.MSPRole{Role: mb.MSPRole_MEMBER, MspIdentifier: name})
if err != nil {
return nil, errors.WithMessage(err, "Error marshal MSPRole")
}
return &mb.MSPPrincipal{
PrincipalClassification: classification,
Principal: member1Role}, nil
}
|
go
|
func NewPrincipal(name string, classification mb.MSPPrincipal_Classification) (*mb.MSPPrincipal, error) {
member1Role, err := proto.Marshal(&mb.MSPRole{Role: mb.MSPRole_MEMBER, MspIdentifier: name})
if err != nil {
return nil, errors.WithMessage(err, "Error marshal MSPRole")
}
return &mb.MSPPrincipal{
PrincipalClassification: classification,
Principal: member1Role}, nil
}
|
[
"func",
"NewPrincipal",
"(",
"name",
"string",
",",
"classification",
"mb",
".",
"MSPPrincipal_Classification",
")",
"(",
"*",
"mb",
".",
"MSPPrincipal",
",",
"error",
")",
"{",
"member1Role",
",",
"err",
":=",
"proto",
".",
"Marshal",
"(",
"&",
"mb",
".",
"MSPRole",
"{",
"Role",
":",
"mb",
".",
"MSPRole_MEMBER",
",",
"MspIdentifier",
":",
"name",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"mb",
".",
"MSPPrincipal",
"{",
"PrincipalClassification",
":",
"classification",
",",
"Principal",
":",
"member1Role",
"}",
",",
"nil",
"\n",
"}"
] |
// NewPrincipal creates a new MSPPrincipal
|
[
"NewPrincipal",
"creates",
"a",
"new",
"MSPPrincipal"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/dynamicselection/pgresolver/mocks.go#L17-L25
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/common/selection/dynamicselection/pgresolver/mocks.go
|
NewSignedByPolicy
|
func NewSignedByPolicy(index int32) *common.SignaturePolicy {
return &common.SignaturePolicy{
Type: &common.SignaturePolicy_SignedBy{
SignedBy: index,
}}
}
|
go
|
func NewSignedByPolicy(index int32) *common.SignaturePolicy {
return &common.SignaturePolicy{
Type: &common.SignaturePolicy_SignedBy{
SignedBy: index,
}}
}
|
[
"func",
"NewSignedByPolicy",
"(",
"index",
"int32",
")",
"*",
"common",
".",
"SignaturePolicy",
"{",
"return",
"&",
"common",
".",
"SignaturePolicy",
"{",
"Type",
":",
"&",
"common",
".",
"SignaturePolicy_SignedBy",
"{",
"SignedBy",
":",
"index",
",",
"}",
"}",
"\n",
"}"
] |
// NewSignedByPolicy creates a SignaturePolicy at the given index
|
[
"NewSignedByPolicy",
"creates",
"a",
"SignaturePolicy",
"at",
"the",
"given",
"index"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/dynamicselection/pgresolver/mocks.go#L28-L33
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/common/selection/dynamicselection/pgresolver/mocks.go
|
NewNOutOfPolicy
|
func NewNOutOfPolicy(n int32, signedBy ...*common.SignaturePolicy) *common.SignaturePolicy {
return &common.SignaturePolicy{
Type: &common.SignaturePolicy_NOutOf_{
NOutOf: &common.SignaturePolicy_NOutOf{
N: n,
Rules: signedBy,
}}}
}
|
go
|
func NewNOutOfPolicy(n int32, signedBy ...*common.SignaturePolicy) *common.SignaturePolicy {
return &common.SignaturePolicy{
Type: &common.SignaturePolicy_NOutOf_{
NOutOf: &common.SignaturePolicy_NOutOf{
N: n,
Rules: signedBy,
}}}
}
|
[
"func",
"NewNOutOfPolicy",
"(",
"n",
"int32",
",",
"signedBy",
"...",
"*",
"common",
".",
"SignaturePolicy",
")",
"*",
"common",
".",
"SignaturePolicy",
"{",
"return",
"&",
"common",
".",
"SignaturePolicy",
"{",
"Type",
":",
"&",
"common",
".",
"SignaturePolicy_NOutOf_",
"{",
"NOutOf",
":",
"&",
"common",
".",
"SignaturePolicy_NOutOf",
"{",
"N",
":",
"n",
",",
"Rules",
":",
"signedBy",
",",
"}",
"}",
"}",
"\n",
"}"
] |
// NewNOutOfPolicy creates an NOutOf signature policy
|
[
"NewNOutOfPolicy",
"creates",
"an",
"NOutOf",
"signature",
"policy"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/dynamicselection/pgresolver/mocks.go#L36-L43
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/common/selection/dynamicselection/pgresolver/mocks.go
|
GetPolicies
|
func GetPolicies(mspIDs ...string) (signedBy []*common.SignaturePolicy, identities []*mb.MSPPrincipal, err error) {
for i, mspID := range mspIDs {
signedBy = append(signedBy, NewSignedByPolicy(int32(i)))
principal, err := NewPrincipal(mspID, mb.MSPPrincipal_ROLE)
if err != nil {
return nil, nil, err
}
identities = append(identities, principal)
}
return
}
|
go
|
func GetPolicies(mspIDs ...string) (signedBy []*common.SignaturePolicy, identities []*mb.MSPPrincipal, err error) {
for i, mspID := range mspIDs {
signedBy = append(signedBy, NewSignedByPolicy(int32(i)))
principal, err := NewPrincipal(mspID, mb.MSPPrincipal_ROLE)
if err != nil {
return nil, nil, err
}
identities = append(identities, principal)
}
return
}
|
[
"func",
"GetPolicies",
"(",
"mspIDs",
"...",
"string",
")",
"(",
"signedBy",
"[",
"]",
"*",
"common",
".",
"SignaturePolicy",
",",
"identities",
"[",
"]",
"*",
"mb",
".",
"MSPPrincipal",
",",
"err",
"error",
")",
"{",
"for",
"i",
",",
"mspID",
":=",
"range",
"mspIDs",
"{",
"signedBy",
"=",
"append",
"(",
"signedBy",
",",
"NewSignedByPolicy",
"(",
"int32",
"(",
"i",
")",
")",
")",
"\n",
"principal",
",",
"err",
":=",
"NewPrincipal",
"(",
"mspID",
",",
"mb",
".",
"MSPPrincipal_ROLE",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"identities",
"=",
"append",
"(",
"identities",
",",
"principal",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// GetPolicies creates a set of 'signed by' signature policies and corresponding identities for the given set of MSP IDs
|
[
"GetPolicies",
"creates",
"a",
"set",
"of",
"signed",
"by",
"signature",
"policies",
"and",
"corresponding",
"identities",
"for",
"the",
"given",
"set",
"of",
"MSP",
"IDs"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/dynamicselection/pgresolver/mocks.go#L46-L56
|
train
|
hyperledger/fabric-sdk-go
|
pkg/msp/identitymgr.go
|
NewIdentityManager
|
func NewIdentityManager(orgName string, userStore msp.UserStore, cryptoSuite core.CryptoSuite, endpointConfig fab.EndpointConfig) (*IdentityManager, error) {
netConfig := endpointConfig.NetworkConfig()
// viper keys are case insensitive
orgConfig, ok := netConfig.Organizations[strings.ToLower(orgName)]
if !ok {
return nil, errors.New("org config retrieval failed")
}
if orgConfig.CryptoPath == "" && len(orgConfig.Users) == 0 {
return nil, errors.New("Either a cryptopath or an embedded list of users is required")
}
var mspPrivKeyStore core.KVStore
var mspCertStore core.KVStore
orgCryptoPathTemplate := orgConfig.CryptoPath
if orgCryptoPathTemplate != "" {
var err error
if !filepath.IsAbs(orgCryptoPathTemplate) {
orgCryptoPathTemplate = filepath.Join(endpointConfig.CryptoConfigPath(), orgCryptoPathTemplate)
}
mspPrivKeyStore, err = NewFileKeyStore(orgCryptoPathTemplate)
if err != nil {
return nil, errors.Wrap(err, "creating a private key store failed")
}
mspCertStore, err = NewFileCertStore(orgCryptoPathTemplate)
if err != nil {
return nil, errors.Wrap(err, "creating a cert store failed")
}
} else {
logger.Warnf("Cryptopath not provided for organization [%s], MSP stores not created", orgName)
}
mgr := &IdentityManager{
orgName: orgName,
orgMSPID: orgConfig.MSPID,
config: endpointConfig,
cryptoSuite: cryptoSuite,
mspPrivKeyStore: mspPrivKeyStore,
mspCertStore: mspCertStore,
embeddedUsers: orgConfig.Users,
userStore: userStore,
// CA Client state is created lazily, when (if) needed
}
return mgr, nil
}
|
go
|
func NewIdentityManager(orgName string, userStore msp.UserStore, cryptoSuite core.CryptoSuite, endpointConfig fab.EndpointConfig) (*IdentityManager, error) {
netConfig := endpointConfig.NetworkConfig()
// viper keys are case insensitive
orgConfig, ok := netConfig.Organizations[strings.ToLower(orgName)]
if !ok {
return nil, errors.New("org config retrieval failed")
}
if orgConfig.CryptoPath == "" && len(orgConfig.Users) == 0 {
return nil, errors.New("Either a cryptopath or an embedded list of users is required")
}
var mspPrivKeyStore core.KVStore
var mspCertStore core.KVStore
orgCryptoPathTemplate := orgConfig.CryptoPath
if orgCryptoPathTemplate != "" {
var err error
if !filepath.IsAbs(orgCryptoPathTemplate) {
orgCryptoPathTemplate = filepath.Join(endpointConfig.CryptoConfigPath(), orgCryptoPathTemplate)
}
mspPrivKeyStore, err = NewFileKeyStore(orgCryptoPathTemplate)
if err != nil {
return nil, errors.Wrap(err, "creating a private key store failed")
}
mspCertStore, err = NewFileCertStore(orgCryptoPathTemplate)
if err != nil {
return nil, errors.Wrap(err, "creating a cert store failed")
}
} else {
logger.Warnf("Cryptopath not provided for organization [%s], MSP stores not created", orgName)
}
mgr := &IdentityManager{
orgName: orgName,
orgMSPID: orgConfig.MSPID,
config: endpointConfig,
cryptoSuite: cryptoSuite,
mspPrivKeyStore: mspPrivKeyStore,
mspCertStore: mspCertStore,
embeddedUsers: orgConfig.Users,
userStore: userStore,
// CA Client state is created lazily, when (if) needed
}
return mgr, nil
}
|
[
"func",
"NewIdentityManager",
"(",
"orgName",
"string",
",",
"userStore",
"msp",
".",
"UserStore",
",",
"cryptoSuite",
"core",
".",
"CryptoSuite",
",",
"endpointConfig",
"fab",
".",
"EndpointConfig",
")",
"(",
"*",
"IdentityManager",
",",
"error",
")",
"{",
"netConfig",
":=",
"endpointConfig",
".",
"NetworkConfig",
"(",
")",
"\n",
"// viper keys are case insensitive",
"orgConfig",
",",
"ok",
":=",
"netConfig",
".",
"Organizations",
"[",
"strings",
".",
"ToLower",
"(",
"orgName",
")",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"orgConfig",
".",
"CryptoPath",
"==",
"\"",
"\"",
"&&",
"len",
"(",
"orgConfig",
".",
"Users",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"mspPrivKeyStore",
"core",
".",
"KVStore",
"\n",
"var",
"mspCertStore",
"core",
".",
"KVStore",
"\n\n",
"orgCryptoPathTemplate",
":=",
"orgConfig",
".",
"CryptoPath",
"\n",
"if",
"orgCryptoPathTemplate",
"!=",
"\"",
"\"",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"filepath",
".",
"IsAbs",
"(",
"orgCryptoPathTemplate",
")",
"{",
"orgCryptoPathTemplate",
"=",
"filepath",
".",
"Join",
"(",
"endpointConfig",
".",
"CryptoConfigPath",
"(",
")",
",",
"orgCryptoPathTemplate",
")",
"\n",
"}",
"\n",
"mspPrivKeyStore",
",",
"err",
"=",
"NewFileKeyStore",
"(",
"orgCryptoPathTemplate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"mspCertStore",
",",
"err",
"=",
"NewFileCertStore",
"(",
"orgCryptoPathTemplate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"logger",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"orgName",
")",
"\n",
"}",
"\n\n",
"mgr",
":=",
"&",
"IdentityManager",
"{",
"orgName",
":",
"orgName",
",",
"orgMSPID",
":",
"orgConfig",
".",
"MSPID",
",",
"config",
":",
"endpointConfig",
",",
"cryptoSuite",
":",
"cryptoSuite",
",",
"mspPrivKeyStore",
":",
"mspPrivKeyStore",
",",
"mspCertStore",
":",
"mspCertStore",
",",
"embeddedUsers",
":",
"orgConfig",
".",
"Users",
",",
"userStore",
":",
"userStore",
",",
"// CA Client state is created lazily, when (if) needed",
"}",
"\n",
"return",
"mgr",
",",
"nil",
"\n",
"}"
] |
// NewIdentityManager creates a new instance of IdentityManager
|
[
"NewIdentityManager",
"creates",
"a",
"new",
"instance",
"of",
"IdentityManager"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/msp/identitymgr.go#L33-L79
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockmspmanager.go
|
NewMockMSPManagerWithError
|
func NewMockMSPManagerWithError(msps map[string]msp.MSP, err error) *MockMSPManager {
return &MockMSPManager{MSPs: msps, Err: err}
}
|
go
|
func NewMockMSPManagerWithError(msps map[string]msp.MSP, err error) *MockMSPManager {
return &MockMSPManager{MSPs: msps, Err: err}
}
|
[
"func",
"NewMockMSPManagerWithError",
"(",
"msps",
"map",
"[",
"string",
"]",
"msp",
".",
"MSP",
",",
"err",
"error",
")",
"*",
"MockMSPManager",
"{",
"return",
"&",
"MockMSPManager",
"{",
"MSPs",
":",
"msps",
",",
"Err",
":",
"err",
"}",
"\n",
"}"
] |
// NewMockMSPManagerWithError mockcore msp manager
|
[
"NewMockMSPManagerWithError",
"mockcore",
"msp",
"manager"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockmspmanager.go#L26-L28
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockmspmanager.go
|
GetMSPs
|
func (mgr *MockMSPManager) GetMSPs() (map[string]msp.MSP, error) {
if mgr.Err != nil && mgr.Err.Error() == "GetMSPs" {
return nil, mgr.Err
}
return mgr.MSPs, nil
}
|
go
|
func (mgr *MockMSPManager) GetMSPs() (map[string]msp.MSP, error) {
if mgr.Err != nil && mgr.Err.Error() == "GetMSPs" {
return nil, mgr.Err
}
return mgr.MSPs, nil
}
|
[
"func",
"(",
"mgr",
"*",
"MockMSPManager",
")",
"GetMSPs",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"msp",
".",
"MSP",
",",
"error",
")",
"{",
"if",
"mgr",
".",
"Err",
"!=",
"nil",
"&&",
"mgr",
".",
"Err",
".",
"Error",
"(",
")",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"mgr",
".",
"Err",
"\n",
"}",
"\n\n",
"return",
"mgr",
".",
"MSPs",
",",
"nil",
"\n",
"}"
] |
// GetMSPs Provides a list of Membership Service providers
|
[
"GetMSPs",
"Provides",
"a",
"list",
"of",
"Membership",
"Service",
"providers"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockmspmanager.go#L46-L52
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockidentitymgr.go
|
NewMockIdentityManager
|
func NewMockIdentityManager(opts ...UsersOption) msp.IdentityManager {
manager := MockIdentityManager{}
usersOptions := UsersOptions{}
for _, param := range opts {
err := param(&usersOptions)
if err != nil {
panic(fmt.Errorf("failed to create IdentityManager: %s", err))
}
}
if usersOptions.users != nil {
manager.users = usersOptions.users
} else {
manager.users = make(map[string]msp.SigningIdentity)
}
return &manager
}
|
go
|
func NewMockIdentityManager(opts ...UsersOption) msp.IdentityManager {
manager := MockIdentityManager{}
usersOptions := UsersOptions{}
for _, param := range opts {
err := param(&usersOptions)
if err != nil {
panic(fmt.Errorf("failed to create IdentityManager: %s", err))
}
}
if usersOptions.users != nil {
manager.users = usersOptions.users
} else {
manager.users = make(map[string]msp.SigningIdentity)
}
return &manager
}
|
[
"func",
"NewMockIdentityManager",
"(",
"opts",
"...",
"UsersOption",
")",
"msp",
".",
"IdentityManager",
"{",
"manager",
":=",
"MockIdentityManager",
"{",
"}",
"\n\n",
"usersOptions",
":=",
"UsersOptions",
"{",
"}",
"\n\n",
"for",
"_",
",",
"param",
":=",
"range",
"opts",
"{",
"err",
":=",
"param",
"(",
"&",
"usersOptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"usersOptions",
".",
"users",
"!=",
"nil",
"{",
"manager",
".",
"users",
"=",
"usersOptions",
".",
"users",
"\n",
"}",
"else",
"{",
"manager",
".",
"users",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"msp",
".",
"SigningIdentity",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"manager",
"\n",
"}"
] |
// NewMockIdentityManager Constructor for a identity manager.
|
[
"NewMockIdentityManager",
"Constructor",
"for",
"a",
"identity",
"manager",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockidentitymgr.go#L54-L73
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockidentitymgr.go
|
GetSigningIdentity
|
func (mgr *MockIdentityManager) GetSigningIdentity(id string) (msp.SigningIdentity, error) {
si, ok := mgr.users[id]
if !ok {
return nil, msp.ErrUserNotFound
}
return si, nil
}
|
go
|
func (mgr *MockIdentityManager) GetSigningIdentity(id string) (msp.SigningIdentity, error) {
si, ok := mgr.users[id]
if !ok {
return nil, msp.ErrUserNotFound
}
return si, nil
}
|
[
"func",
"(",
"mgr",
"*",
"MockIdentityManager",
")",
"GetSigningIdentity",
"(",
"id",
"string",
")",
"(",
"msp",
".",
"SigningIdentity",
",",
"error",
")",
"{",
"si",
",",
"ok",
":=",
"mgr",
".",
"users",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"msp",
".",
"ErrUserNotFound",
"\n",
"}",
"\n",
"return",
"si",
",",
"nil",
"\n",
"}"
] |
// GetSigningIdentity will return an identity that can be used to cryptographically sign an object
|
[
"GetSigningIdentity",
"will",
"return",
"an",
"identity",
"that",
"can",
"be",
"used",
"to",
"cryptographically",
"sign",
"an",
"object"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockidentitymgr.go#L76-L82
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockorderer.go
|
SendBroadcast
|
func (o *MockOrderer) SendBroadcast(ctx reqContext.Context, envelope *fab.SignedEnvelope) (*common.Status, error) {
// Report this call to the listener
if o.BroadcastListener != nil {
o.BroadcastQueue <- envelope
}
select {
case err := <-o.BroadcastErrors:
return nil, err
default:
return nil, nil
}
}
|
go
|
func (o *MockOrderer) SendBroadcast(ctx reqContext.Context, envelope *fab.SignedEnvelope) (*common.Status, error) {
// Report this call to the listener
if o.BroadcastListener != nil {
o.BroadcastQueue <- envelope
}
select {
case err := <-o.BroadcastErrors:
return nil, err
default:
return nil, nil
}
}
|
[
"func",
"(",
"o",
"*",
"MockOrderer",
")",
"SendBroadcast",
"(",
"ctx",
"reqContext",
".",
"Context",
",",
"envelope",
"*",
"fab",
".",
"SignedEnvelope",
")",
"(",
"*",
"common",
".",
"Status",
",",
"error",
")",
"{",
"// Report this call to the listener",
"if",
"o",
".",
"BroadcastListener",
"!=",
"nil",
"{",
"o",
".",
"BroadcastQueue",
"<-",
"envelope",
"\n",
"}",
"\n",
"select",
"{",
"case",
"err",
":=",
"<-",
"o",
".",
"BroadcastErrors",
":",
"return",
"nil",
",",
"err",
"\n",
"default",
":",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// SendBroadcast accepts client broadcast calls and reports them to the listener channel
// Returns the first enqueued error, or nil if there are no enqueued errors
|
[
"SendBroadcast",
"accepts",
"client",
"broadcast",
"calls",
"and",
"reports",
"them",
"to",
"the",
"listener",
"channel",
"Returns",
"the",
"first",
"enqueued",
"error",
"or",
"nil",
"if",
"there",
"are",
"no",
"enqueued",
"errors"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockorderer.go#L88-L99
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/service/mocks/mockevents.go
|
NewBlock
|
func NewBlock(channelID string, transactions ...*TxInfo) *cb.Block {
var data [][]byte
txValidationFlags := make([]uint8, len(transactions))
for i, txInfo := range transactions {
envBytes, err := proto.Marshal(newEnvelope(channelID, txInfo))
if err != nil {
panic(err)
}
data = append(data, envBytes)
txValidationFlags[i] = uint8(txInfo.TxValidationCode)
}
blockMetaData := make([][]byte, 4)
blockMetaData[cb.BlockMetadataIndex_TRANSACTIONS_FILTER] = txValidationFlags
return &cb.Block{
Header: &cb.BlockHeader{},
Metadata: &cb.BlockMetadata{Metadata: blockMetaData},
Data: &cb.BlockData{Data: data},
}
}
|
go
|
func NewBlock(channelID string, transactions ...*TxInfo) *cb.Block {
var data [][]byte
txValidationFlags := make([]uint8, len(transactions))
for i, txInfo := range transactions {
envBytes, err := proto.Marshal(newEnvelope(channelID, txInfo))
if err != nil {
panic(err)
}
data = append(data, envBytes)
txValidationFlags[i] = uint8(txInfo.TxValidationCode)
}
blockMetaData := make([][]byte, 4)
blockMetaData[cb.BlockMetadataIndex_TRANSACTIONS_FILTER] = txValidationFlags
return &cb.Block{
Header: &cb.BlockHeader{},
Metadata: &cb.BlockMetadata{Metadata: blockMetaData},
Data: &cb.BlockData{Data: data},
}
}
|
[
"func",
"NewBlock",
"(",
"channelID",
"string",
",",
"transactions",
"...",
"*",
"TxInfo",
")",
"*",
"cb",
".",
"Block",
"{",
"var",
"data",
"[",
"]",
"[",
"]",
"byte",
"\n",
"txValidationFlags",
":=",
"make",
"(",
"[",
"]",
"uint8",
",",
"len",
"(",
"transactions",
")",
")",
"\n",
"for",
"i",
",",
"txInfo",
":=",
"range",
"transactions",
"{",
"envBytes",
",",
"err",
":=",
"proto",
".",
"Marshal",
"(",
"newEnvelope",
"(",
"channelID",
",",
"txInfo",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"data",
"=",
"append",
"(",
"data",
",",
"envBytes",
")",
"\n",
"txValidationFlags",
"[",
"i",
"]",
"=",
"uint8",
"(",
"txInfo",
".",
"TxValidationCode",
")",
"\n",
"}",
"\n\n",
"blockMetaData",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"4",
")",
"\n",
"blockMetaData",
"[",
"cb",
".",
"BlockMetadataIndex_TRANSACTIONS_FILTER",
"]",
"=",
"txValidationFlags",
"\n\n",
"return",
"&",
"cb",
".",
"Block",
"{",
"Header",
":",
"&",
"cb",
".",
"BlockHeader",
"{",
"}",
",",
"Metadata",
":",
"&",
"cb",
".",
"BlockMetadata",
"{",
"Metadata",
":",
"blockMetaData",
"}",
",",
"Data",
":",
"&",
"cb",
".",
"BlockData",
"{",
"Data",
":",
"data",
"}",
",",
"}",
"\n",
"}"
] |
// NewBlock returns a new mock block initialized with the given channel
|
[
"NewBlock",
"returns",
"a",
"new",
"mock",
"block",
"initialized",
"with",
"the",
"given",
"channel"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockevents.go#L16-L36
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/service/mocks/mockevents.go
|
NewTransaction
|
func NewTransaction(txID string, txValidationCode pb.TxValidationCode, headerType cb.HeaderType) *TxInfo {
return &TxInfo{
TxID: txID,
TxValidationCode: txValidationCode,
HeaderType: headerType,
}
}
|
go
|
func NewTransaction(txID string, txValidationCode pb.TxValidationCode, headerType cb.HeaderType) *TxInfo {
return &TxInfo{
TxID: txID,
TxValidationCode: txValidationCode,
HeaderType: headerType,
}
}
|
[
"func",
"NewTransaction",
"(",
"txID",
"string",
",",
"txValidationCode",
"pb",
".",
"TxValidationCode",
",",
"headerType",
"cb",
".",
"HeaderType",
")",
"*",
"TxInfo",
"{",
"return",
"&",
"TxInfo",
"{",
"TxID",
":",
"txID",
",",
"TxValidationCode",
":",
"txValidationCode",
",",
"HeaderType",
":",
"headerType",
",",
"}",
"\n",
"}"
] |
// NewTransaction creates a new transaction
|
[
"NewTransaction",
"creates",
"a",
"new",
"transaction"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockevents.go#L50-L56
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/service/mocks/mockevents.go
|
NewTransactionWithCCEvent
|
func NewTransactionWithCCEvent(txID string, txValidationCode pb.TxValidationCode, ccID string, eventName string, payload []byte) *TxInfo {
return &TxInfo{
TxID: txID,
TxValidationCode: txValidationCode,
ChaincodeID: ccID,
EventName: eventName,
Payload: payload,
HeaderType: cb.HeaderType_ENDORSER_TRANSACTION,
}
}
|
go
|
func NewTransactionWithCCEvent(txID string, txValidationCode pb.TxValidationCode, ccID string, eventName string, payload []byte) *TxInfo {
return &TxInfo{
TxID: txID,
TxValidationCode: txValidationCode,
ChaincodeID: ccID,
EventName: eventName,
Payload: payload,
HeaderType: cb.HeaderType_ENDORSER_TRANSACTION,
}
}
|
[
"func",
"NewTransactionWithCCEvent",
"(",
"txID",
"string",
",",
"txValidationCode",
"pb",
".",
"TxValidationCode",
",",
"ccID",
"string",
",",
"eventName",
"string",
",",
"payload",
"[",
"]",
"byte",
")",
"*",
"TxInfo",
"{",
"return",
"&",
"TxInfo",
"{",
"TxID",
":",
"txID",
",",
"TxValidationCode",
":",
"txValidationCode",
",",
"ChaincodeID",
":",
"ccID",
",",
"EventName",
":",
"eventName",
",",
"Payload",
":",
"payload",
",",
"HeaderType",
":",
"cb",
".",
"HeaderType_ENDORSER_TRANSACTION",
",",
"}",
"\n",
"}"
] |
// NewTransactionWithCCEvent creates a new transaction with the given chaincode event
|
[
"NewTransactionWithCCEvent",
"creates",
"a",
"new",
"transaction",
"with",
"the",
"given",
"chaincode",
"event"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockevents.go#L59-L68
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/service/mocks/mockevents.go
|
NewFilteredBlock
|
func NewFilteredBlock(channelID string, filteredTx ...*pb.FilteredTransaction) *pb.FilteredBlock {
return &pb.FilteredBlock{
ChannelId: channelID,
FilteredTransactions: filteredTx,
}
}
|
go
|
func NewFilteredBlock(channelID string, filteredTx ...*pb.FilteredTransaction) *pb.FilteredBlock {
return &pb.FilteredBlock{
ChannelId: channelID,
FilteredTransactions: filteredTx,
}
}
|
[
"func",
"NewFilteredBlock",
"(",
"channelID",
"string",
",",
"filteredTx",
"...",
"*",
"pb",
".",
"FilteredTransaction",
")",
"*",
"pb",
".",
"FilteredBlock",
"{",
"return",
"&",
"pb",
".",
"FilteredBlock",
"{",
"ChannelId",
":",
"channelID",
",",
"FilteredTransactions",
":",
"filteredTx",
",",
"}",
"\n",
"}"
] |
// NewFilteredBlock returns a new mock filtered block initialized with the given channel
// and filtered transactions
|
[
"NewFilteredBlock",
"returns",
"a",
"new",
"mock",
"filtered",
"block",
"initialized",
"with",
"the",
"given",
"channel",
"and",
"filtered",
"transactions"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockevents.go#L72-L77
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/service/mocks/mockevents.go
|
NewFilteredTx
|
func NewFilteredTx(txID string, txValidationCode pb.TxValidationCode) *pb.FilteredTransaction {
return &pb.FilteredTransaction{
Txid: txID,
TxValidationCode: txValidationCode,
}
}
|
go
|
func NewFilteredTx(txID string, txValidationCode pb.TxValidationCode) *pb.FilteredTransaction {
return &pb.FilteredTransaction{
Txid: txID,
TxValidationCode: txValidationCode,
}
}
|
[
"func",
"NewFilteredTx",
"(",
"txID",
"string",
",",
"txValidationCode",
"pb",
".",
"TxValidationCode",
")",
"*",
"pb",
".",
"FilteredTransaction",
"{",
"return",
"&",
"pb",
".",
"FilteredTransaction",
"{",
"Txid",
":",
"txID",
",",
"TxValidationCode",
":",
"txValidationCode",
",",
"}",
"\n",
"}"
] |
// NewFilteredTx returns a new mock filtered transaction
|
[
"NewFilteredTx",
"returns",
"a",
"new",
"mock",
"filtered",
"transaction"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockevents.go#L80-L85
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/service/mocks/mockevents.go
|
NewFilteredTxWithCCEvent
|
func NewFilteredTxWithCCEvent(txID, ccID, event string) *pb.FilteredTransaction {
return &pb.FilteredTransaction{
Txid: txID,
Data: &pb.FilteredTransaction_TransactionActions{
TransactionActions: &pb.FilteredTransactionActions{
ChaincodeActions: []*pb.FilteredChaincodeAction{
{
ChaincodeEvent: &pb.ChaincodeEvent{
ChaincodeId: ccID,
EventName: event,
TxId: txID,
},
},
},
},
},
}
}
|
go
|
func NewFilteredTxWithCCEvent(txID, ccID, event string) *pb.FilteredTransaction {
return &pb.FilteredTransaction{
Txid: txID,
Data: &pb.FilteredTransaction_TransactionActions{
TransactionActions: &pb.FilteredTransactionActions{
ChaincodeActions: []*pb.FilteredChaincodeAction{
{
ChaincodeEvent: &pb.ChaincodeEvent{
ChaincodeId: ccID,
EventName: event,
TxId: txID,
},
},
},
},
},
}
}
|
[
"func",
"NewFilteredTxWithCCEvent",
"(",
"txID",
",",
"ccID",
",",
"event",
"string",
")",
"*",
"pb",
".",
"FilteredTransaction",
"{",
"return",
"&",
"pb",
".",
"FilteredTransaction",
"{",
"Txid",
":",
"txID",
",",
"Data",
":",
"&",
"pb",
".",
"FilteredTransaction_TransactionActions",
"{",
"TransactionActions",
":",
"&",
"pb",
".",
"FilteredTransactionActions",
"{",
"ChaincodeActions",
":",
"[",
"]",
"*",
"pb",
".",
"FilteredChaincodeAction",
"{",
"{",
"ChaincodeEvent",
":",
"&",
"pb",
".",
"ChaincodeEvent",
"{",
"ChaincodeId",
":",
"ccID",
",",
"EventName",
":",
"event",
",",
"TxId",
":",
"txID",
",",
"}",
",",
"}",
",",
"}",
",",
"}",
",",
"}",
",",
"}",
"\n",
"}"
] |
// NewFilteredTxWithCCEvent returns a new mock filtered transaction
// with the given chaincode event
|
[
"NewFilteredTxWithCCEvent",
"returns",
"a",
"new",
"mock",
"filtered",
"transaction",
"with",
"the",
"given",
"chaincode",
"event"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/mocks/mockevents.go#L89-L106
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/orderer/orderer.go
|
New
|
func New(config fab.EndpointConfig, opts ...Option) (*Orderer, error) {
orderer := &Orderer{
config: config,
commManager: &defCommManager{},
}
for _, opt := range opts {
err := opt(orderer)
if err != nil {
return nil, err
}
}
var grpcOpts []grpc.DialOption
if orderer.kap.Time > 0 {
grpcOpts = append(grpcOpts, grpc.WithKeepaliveParams(orderer.kap))
}
grpcOpts = append(grpcOpts, grpc.WithDefaultCallOptions(grpc.WaitForReady(!orderer.failFast)))
if endpoint.AttemptSecured(orderer.url, orderer.allowInsecure) {
//tls config
tlsConfig, err := comm.TLSConfig(orderer.tlsCACert, orderer.serverName, config)
if err != nil {
return nil, err
}
tlsConfig.VerifyPeerCertificate = func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
return verifier.VerifyPeerCertificate(rawCerts, verifiedChains)
}
grpcOpts = append(grpcOpts, grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)))
} else {
grpcOpts = append(grpcOpts, grpc.WithInsecure())
}
grpcOpts = append(grpcOpts, grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(maxCallRecvMsgSize),
grpc.MaxCallSendMsgSize(maxCallSendMsgSize)))
orderer.dialTimeout = config.Timeout(fab.OrdererConnection)
orderer.url = endpoint.ToAddress(orderer.url)
orderer.grpcDialOption = grpcOpts
return orderer, nil
}
|
go
|
func New(config fab.EndpointConfig, opts ...Option) (*Orderer, error) {
orderer := &Orderer{
config: config,
commManager: &defCommManager{},
}
for _, opt := range opts {
err := opt(orderer)
if err != nil {
return nil, err
}
}
var grpcOpts []grpc.DialOption
if orderer.kap.Time > 0 {
grpcOpts = append(grpcOpts, grpc.WithKeepaliveParams(orderer.kap))
}
grpcOpts = append(grpcOpts, grpc.WithDefaultCallOptions(grpc.WaitForReady(!orderer.failFast)))
if endpoint.AttemptSecured(orderer.url, orderer.allowInsecure) {
//tls config
tlsConfig, err := comm.TLSConfig(orderer.tlsCACert, orderer.serverName, config)
if err != nil {
return nil, err
}
tlsConfig.VerifyPeerCertificate = func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
return verifier.VerifyPeerCertificate(rawCerts, verifiedChains)
}
grpcOpts = append(grpcOpts, grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)))
} else {
grpcOpts = append(grpcOpts, grpc.WithInsecure())
}
grpcOpts = append(grpcOpts, grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(maxCallRecvMsgSize),
grpc.MaxCallSendMsgSize(maxCallSendMsgSize)))
orderer.dialTimeout = config.Timeout(fab.OrdererConnection)
orderer.url = endpoint.ToAddress(orderer.url)
orderer.grpcDialOption = grpcOpts
return orderer, nil
}
|
[
"func",
"New",
"(",
"config",
"fab",
".",
"EndpointConfig",
",",
"opts",
"...",
"Option",
")",
"(",
"*",
"Orderer",
",",
"error",
")",
"{",
"orderer",
":=",
"&",
"Orderer",
"{",
"config",
":",
"config",
",",
"commManager",
":",
"&",
"defCommManager",
"{",
"}",
",",
"}",
"\n\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"err",
":=",
"opt",
"(",
"orderer",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"var",
"grpcOpts",
"[",
"]",
"grpc",
".",
"DialOption",
"\n",
"if",
"orderer",
".",
"kap",
".",
"Time",
">",
"0",
"{",
"grpcOpts",
"=",
"append",
"(",
"grpcOpts",
",",
"grpc",
".",
"WithKeepaliveParams",
"(",
"orderer",
".",
"kap",
")",
")",
"\n",
"}",
"\n",
"grpcOpts",
"=",
"append",
"(",
"grpcOpts",
",",
"grpc",
".",
"WithDefaultCallOptions",
"(",
"grpc",
".",
"WaitForReady",
"(",
"!",
"orderer",
".",
"failFast",
")",
")",
")",
"\n",
"if",
"endpoint",
".",
"AttemptSecured",
"(",
"orderer",
".",
"url",
",",
"orderer",
".",
"allowInsecure",
")",
"{",
"//tls config",
"tlsConfig",
",",
"err",
":=",
"comm",
".",
"TLSConfig",
"(",
"orderer",
".",
"tlsCACert",
",",
"orderer",
".",
"serverName",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"tlsConfig",
".",
"VerifyPeerCertificate",
"=",
"func",
"(",
"rawCerts",
"[",
"]",
"[",
"]",
"byte",
",",
"verifiedChains",
"[",
"]",
"[",
"]",
"*",
"x509",
".",
"Certificate",
")",
"error",
"{",
"return",
"verifier",
".",
"VerifyPeerCertificate",
"(",
"rawCerts",
",",
"verifiedChains",
")",
"\n",
"}",
"\n\n",
"grpcOpts",
"=",
"append",
"(",
"grpcOpts",
",",
"grpc",
".",
"WithTransportCredentials",
"(",
"credentials",
".",
"NewTLS",
"(",
"tlsConfig",
")",
")",
")",
"\n",
"}",
"else",
"{",
"grpcOpts",
"=",
"append",
"(",
"grpcOpts",
",",
"grpc",
".",
"WithInsecure",
"(",
")",
")",
"\n",
"}",
"\n\n",
"grpcOpts",
"=",
"append",
"(",
"grpcOpts",
",",
"grpc",
".",
"WithDefaultCallOptions",
"(",
"grpc",
".",
"MaxCallRecvMsgSize",
"(",
"maxCallRecvMsgSize",
")",
",",
"grpc",
".",
"MaxCallSendMsgSize",
"(",
"maxCallSendMsgSize",
")",
")",
")",
"\n\n",
"orderer",
".",
"dialTimeout",
"=",
"config",
".",
"Timeout",
"(",
"fab",
".",
"OrdererConnection",
")",
"\n",
"orderer",
".",
"url",
"=",
"endpoint",
".",
"ToAddress",
"(",
"orderer",
".",
"url",
")",
"\n",
"orderer",
".",
"grpcDialOption",
"=",
"grpcOpts",
"\n\n",
"return",
"orderer",
",",
"nil",
"\n",
"}"
] |
// New Returns a Orderer instance
|
[
"New",
"Returns",
"a",
"Orderer",
"instance"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L60-L101
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/orderer/orderer.go
|
WithURL
|
func WithURL(url string) Option {
return func(o *Orderer) error {
o.url = url
return nil
}
}
|
go
|
func WithURL(url string) Option {
return func(o *Orderer) error {
o.url = url
return nil
}
}
|
[
"func",
"WithURL",
"(",
"url",
"string",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"Orderer",
")",
"error",
"{",
"o",
".",
"url",
"=",
"url",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// WithURL is a functional option for the orderer.New constructor that configures the orderer's URL.
|
[
"WithURL",
"is",
"a",
"functional",
"option",
"for",
"the",
"orderer",
".",
"New",
"constructor",
"that",
"configures",
"the",
"orderer",
"s",
"URL",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L104-L110
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/orderer/orderer.go
|
WithTLSCert
|
func WithTLSCert(tlsCACert *x509.Certificate) Option {
return func(o *Orderer) error {
o.tlsCACert = tlsCACert
return nil
}
}
|
go
|
func WithTLSCert(tlsCACert *x509.Certificate) Option {
return func(o *Orderer) error {
o.tlsCACert = tlsCACert
return nil
}
}
|
[
"func",
"WithTLSCert",
"(",
"tlsCACert",
"*",
"x509",
".",
"Certificate",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"Orderer",
")",
"error",
"{",
"o",
".",
"tlsCACert",
"=",
"tlsCACert",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// WithTLSCert is a functional option for the orderer.New constructor that configures the orderer's TLS certificate
|
[
"WithTLSCert",
"is",
"a",
"functional",
"option",
"for",
"the",
"orderer",
".",
"New",
"constructor",
"that",
"configures",
"the",
"orderer",
"s",
"TLS",
"certificate"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L113-L119
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/orderer/orderer.go
|
WithServerName
|
func WithServerName(serverName string) Option {
return func(o *Orderer) error {
o.serverName = serverName
return nil
}
}
|
go
|
func WithServerName(serverName string) Option {
return func(o *Orderer) error {
o.serverName = serverName
return nil
}
}
|
[
"func",
"WithServerName",
"(",
"serverName",
"string",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"Orderer",
")",
"error",
"{",
"o",
".",
"serverName",
"=",
"serverName",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// WithServerName is a functional option for the orderer.New constructor that configures the orderer's server name
|
[
"WithServerName",
"is",
"a",
"functional",
"option",
"for",
"the",
"orderer",
".",
"New",
"constructor",
"that",
"configures",
"the",
"orderer",
"s",
"server",
"name"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L122-L128
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/orderer/orderer.go
|
FromOrdererConfig
|
func FromOrdererConfig(ordererCfg *fab.OrdererConfig) Option {
return func(o *Orderer) error {
o.url = ordererCfg.URL
o.tlsCACert = ordererCfg.TLSCACert
if ordererCfg.GRPCOptions["allow-insecure"] == false {
//verify if certificate was expired or not yet valid
err := verifier.ValidateCertificateDates(o.tlsCACert)
if err != nil {
//log this error
logger.Warn(err)
}
}
o.serverName = getServerNameOverride(ordererCfg)
o.kap = getKeepAliveOptions(ordererCfg)
o.failFast = getFailFast(ordererCfg)
o.allowInsecure = isInsecureConnectionAllowed(ordererCfg)
return nil
}
}
|
go
|
func FromOrdererConfig(ordererCfg *fab.OrdererConfig) Option {
return func(o *Orderer) error {
o.url = ordererCfg.URL
o.tlsCACert = ordererCfg.TLSCACert
if ordererCfg.GRPCOptions["allow-insecure"] == false {
//verify if certificate was expired or not yet valid
err := verifier.ValidateCertificateDates(o.tlsCACert)
if err != nil {
//log this error
logger.Warn(err)
}
}
o.serverName = getServerNameOverride(ordererCfg)
o.kap = getKeepAliveOptions(ordererCfg)
o.failFast = getFailFast(ordererCfg)
o.allowInsecure = isInsecureConnectionAllowed(ordererCfg)
return nil
}
}
|
[
"func",
"FromOrdererConfig",
"(",
"ordererCfg",
"*",
"fab",
".",
"OrdererConfig",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"Orderer",
")",
"error",
"{",
"o",
".",
"url",
"=",
"ordererCfg",
".",
"URL",
"\n",
"o",
".",
"tlsCACert",
"=",
"ordererCfg",
".",
"TLSCACert",
"\n\n",
"if",
"ordererCfg",
".",
"GRPCOptions",
"[",
"\"",
"\"",
"]",
"==",
"false",
"{",
"//verify if certificate was expired or not yet valid",
"err",
":=",
"verifier",
".",
"ValidateCertificateDates",
"(",
"o",
".",
"tlsCACert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"//log this error",
"logger",
".",
"Warn",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"o",
".",
"serverName",
"=",
"getServerNameOverride",
"(",
"ordererCfg",
")",
"\n",
"o",
".",
"kap",
"=",
"getKeepAliveOptions",
"(",
"ordererCfg",
")",
"\n",
"o",
".",
"failFast",
"=",
"getFailFast",
"(",
"ordererCfg",
")",
"\n",
"o",
".",
"allowInsecure",
"=",
"isInsecureConnectionAllowed",
"(",
"ordererCfg",
")",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// FromOrdererConfig is a functional option for the orderer.New constructor that configures a new orderer
// from a apiconfig.OrdererConfig struct
|
[
"FromOrdererConfig",
"is",
"a",
"functional",
"option",
"for",
"the",
"orderer",
".",
"New",
"constructor",
"that",
"configures",
"a",
"new",
"orderer",
"from",
"a",
"apiconfig",
".",
"OrdererConfig",
"struct"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L141-L162
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/orderer/orderer.go
|
FromOrdererName
|
func FromOrdererName(name string) Option {
return func(o *Orderer) error {
ordererCfg, found := o.config.OrdererConfig(name)
if !found {
return errors.Errorf("orderer config not found for orderer : %s", name)
}
return FromOrdererConfig(ordererCfg)(o)
}
}
|
go
|
func FromOrdererName(name string) Option {
return func(o *Orderer) error {
ordererCfg, found := o.config.OrdererConfig(name)
if !found {
return errors.Errorf("orderer config not found for orderer : %s", name)
}
return FromOrdererConfig(ordererCfg)(o)
}
}
|
[
"func",
"FromOrdererName",
"(",
"name",
"string",
")",
"Option",
"{",
"return",
"func",
"(",
"o",
"*",
"Orderer",
")",
"error",
"{",
"ordererCfg",
",",
"found",
":=",
"o",
".",
"config",
".",
"OrdererConfig",
"(",
"name",
")",
"\n",
"if",
"!",
"found",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n\n",
"return",
"FromOrdererConfig",
"(",
"ordererCfg",
")",
"(",
"o",
")",
"\n",
"}",
"\n",
"}"
] |
// FromOrdererName is a functional option for the orderer.New constructor that obtains an apiconfig.OrdererConfig
// by name from the apiconfig.Config supplied to the constructor, and then constructs a new orderer from it
|
[
"FromOrdererName",
"is",
"a",
"functional",
"option",
"for",
"the",
"orderer",
".",
"New",
"constructor",
"that",
"obtains",
"an",
"apiconfig",
".",
"OrdererConfig",
"by",
"name",
"from",
"the",
"apiconfig",
".",
"Config",
"supplied",
"to",
"the",
"constructor",
"and",
"then",
"constructs",
"a",
"new",
"orderer",
"from",
"it"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L166-L175
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/orderer/orderer.go
|
SendBroadcast
|
func (o *Orderer) SendBroadcast(ctx reqContext.Context, envelope *fab.SignedEnvelope) (*common.Status, error) {
conn, err := o.conn(ctx)
if err != nil {
rpcStatus, ok := grpcstatus.FromError(err)
if ok {
return nil, errors.WithMessage(status.NewFromGRPCStatus(rpcStatus), "connection failed")
}
return nil, status.New(status.OrdererClientStatus, status.ConnectionFailed.ToInt32(), err.Error(), nil)
}
defer o.releaseConn(ctx, conn)
broadcastClient, err := ab.NewAtomicBroadcastClient(conn).Broadcast(ctx)
if err != nil {
rpcStatus, ok := grpcstatus.FromError(err)
if ok {
err = status.NewFromGRPCStatus(rpcStatus)
}
return nil, errors.Wrap(err, "NewAtomicBroadcastClient failed")
}
responses := make(chan common.Status)
errs := make(chan error, 1)
go broadcastStream(broadcastClient, responses, errs)
err = broadcastClient.Send(&common.Envelope{
Payload: envelope.Payload,
Signature: envelope.Signature,
})
if err != nil {
return nil, errors.Wrap(err, "failed to send envelope to orderer")
}
if err = broadcastClient.CloseSend(); err != nil {
logger.Debugf("unable to close broadcast client [%s]", err)
}
return wrapStreamStatusRPC(responses, errs)
}
|
go
|
func (o *Orderer) SendBroadcast(ctx reqContext.Context, envelope *fab.SignedEnvelope) (*common.Status, error) {
conn, err := o.conn(ctx)
if err != nil {
rpcStatus, ok := grpcstatus.FromError(err)
if ok {
return nil, errors.WithMessage(status.NewFromGRPCStatus(rpcStatus), "connection failed")
}
return nil, status.New(status.OrdererClientStatus, status.ConnectionFailed.ToInt32(), err.Error(), nil)
}
defer o.releaseConn(ctx, conn)
broadcastClient, err := ab.NewAtomicBroadcastClient(conn).Broadcast(ctx)
if err != nil {
rpcStatus, ok := grpcstatus.FromError(err)
if ok {
err = status.NewFromGRPCStatus(rpcStatus)
}
return nil, errors.Wrap(err, "NewAtomicBroadcastClient failed")
}
responses := make(chan common.Status)
errs := make(chan error, 1)
go broadcastStream(broadcastClient, responses, errs)
err = broadcastClient.Send(&common.Envelope{
Payload: envelope.Payload,
Signature: envelope.Signature,
})
if err != nil {
return nil, errors.Wrap(err, "failed to send envelope to orderer")
}
if err = broadcastClient.CloseSend(); err != nil {
logger.Debugf("unable to close broadcast client [%s]", err)
}
return wrapStreamStatusRPC(responses, errs)
}
|
[
"func",
"(",
"o",
"*",
"Orderer",
")",
"SendBroadcast",
"(",
"ctx",
"reqContext",
".",
"Context",
",",
"envelope",
"*",
"fab",
".",
"SignedEnvelope",
")",
"(",
"*",
"common",
".",
"Status",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"o",
".",
"conn",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"rpcStatus",
",",
"ok",
":=",
"grpcstatus",
".",
"FromError",
"(",
"err",
")",
"\n",
"if",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"status",
".",
"NewFromGRPCStatus",
"(",
"rpcStatus",
")",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"status",
".",
"New",
"(",
"status",
".",
"OrdererClientStatus",
",",
"status",
".",
"ConnectionFailed",
".",
"ToInt32",
"(",
")",
",",
"err",
".",
"Error",
"(",
")",
",",
"nil",
")",
"\n",
"}",
"\n",
"defer",
"o",
".",
"releaseConn",
"(",
"ctx",
",",
"conn",
")",
"\n\n",
"broadcastClient",
",",
"err",
":=",
"ab",
".",
"NewAtomicBroadcastClient",
"(",
"conn",
")",
".",
"Broadcast",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"rpcStatus",
",",
"ok",
":=",
"grpcstatus",
".",
"FromError",
"(",
"err",
")",
"\n",
"if",
"ok",
"{",
"err",
"=",
"status",
".",
"NewFromGRPCStatus",
"(",
"rpcStatus",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"responses",
":=",
"make",
"(",
"chan",
"common",
".",
"Status",
")",
"\n",
"errs",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n\n",
"go",
"broadcastStream",
"(",
"broadcastClient",
",",
"responses",
",",
"errs",
")",
"\n\n",
"err",
"=",
"broadcastClient",
".",
"Send",
"(",
"&",
"common",
".",
"Envelope",
"{",
"Payload",
":",
"envelope",
".",
"Payload",
",",
"Signature",
":",
"envelope",
".",
"Signature",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"broadcastClient",
".",
"CloseSend",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"wrapStreamStatusRPC",
"(",
"responses",
",",
"errs",
")",
"\n",
"}"
] |
// SendBroadcast Send the created transaction to Orderer.
|
[
"SendBroadcast",
"Send",
"the",
"created",
"transaction",
"to",
"Orderer",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L246-L284
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/orderer/orderer.go
|
wrapStreamStatusRPC
|
func wrapStreamStatusRPC(responses chan common.Status, errs chan error) (*common.Status, error) {
var status common.Status
var err multi.Errors
read:
for {
select {
case s, ok := <-responses:
if !ok {
break read
}
status = s
case e := <-errs:
err = append(err, e)
}
}
// drain remaining errors.
for i := 0; i < len(errs); i++ {
e := <-errs
err = append(err, e)
}
return &status, err.ToError()
}
|
go
|
func wrapStreamStatusRPC(responses chan common.Status, errs chan error) (*common.Status, error) {
var status common.Status
var err multi.Errors
read:
for {
select {
case s, ok := <-responses:
if !ok {
break read
}
status = s
case e := <-errs:
err = append(err, e)
}
}
// drain remaining errors.
for i := 0; i < len(errs); i++ {
e := <-errs
err = append(err, e)
}
return &status, err.ToError()
}
|
[
"func",
"wrapStreamStatusRPC",
"(",
"responses",
"chan",
"common",
".",
"Status",
",",
"errs",
"chan",
"error",
")",
"(",
"*",
"common",
".",
"Status",
",",
"error",
")",
"{",
"var",
"status",
"common",
".",
"Status",
"\n",
"var",
"err",
"multi",
".",
"Errors",
"\n\n",
"read",
":",
"for",
"{",
"select",
"{",
"case",
"s",
",",
"ok",
":=",
"<-",
"responses",
":",
"if",
"!",
"ok",
"{",
"break",
"read",
"\n",
"}",
"\n",
"status",
"=",
"s",
"\n",
"case",
"e",
":=",
"<-",
"errs",
":",
"err",
"=",
"append",
"(",
"err",
",",
"e",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// drain remaining errors.",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"errs",
")",
";",
"i",
"++",
"{",
"e",
":=",
"<-",
"errs",
"\n",
"err",
"=",
"append",
"(",
"err",
",",
"e",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"status",
",",
"err",
".",
"ToError",
"(",
")",
"\n",
"}"
] |
// wrapStreamStatusRPC returns the last response and err and blocks until the chan is closed.
|
[
"wrapStreamStatusRPC",
"returns",
"the",
"last",
"response",
"and",
"err",
"and",
"blocks",
"until",
"the",
"chan",
"is",
"closed",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/orderer/orderer.go#L287-L311
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/mocks/numevents.go
|
NewReceived
|
func NewReceived(numBlock NumBlock, numChaincode NumChaincode) Received {
return Received{NumBlock: numBlock, NumChaincode: numChaincode}
}
|
go
|
func NewReceived(numBlock NumBlock, numChaincode NumChaincode) Received {
return Received{NumBlock: numBlock, NumChaincode: numChaincode}
}
|
[
"func",
"NewReceived",
"(",
"numBlock",
"NumBlock",
",",
"numChaincode",
"NumChaincode",
")",
"Received",
"{",
"return",
"Received",
"{",
"NumBlock",
":",
"numBlock",
",",
"NumChaincode",
":",
"numChaincode",
"}",
"\n",
"}"
] |
// NewReceived returns a new Received struct
|
[
"NewReceived",
"returns",
"a",
"new",
"Received",
"struct"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/numevents.go#L48-L50
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/channel/ledger.go
|
NewLedger
|
func NewLedger(chName string) (*Ledger, error) {
l := Ledger{
chName: chName,
}
return &l, nil
}
|
go
|
func NewLedger(chName string) (*Ledger, error) {
l := Ledger{
chName: chName,
}
return &l, nil
}
|
[
"func",
"NewLedger",
"(",
"chName",
"string",
")",
"(",
"*",
"Ledger",
",",
"error",
")",
"{",
"l",
":=",
"Ledger",
"{",
"chName",
":",
"chName",
",",
"}",
"\n",
"return",
"&",
"l",
",",
"nil",
"\n",
"}"
] |
// NewLedger constructs a Ledger client for the current context and named channel.
|
[
"NewLedger",
"constructs",
"a",
"Ledger",
"client",
"for",
"the",
"current",
"context",
"and",
"named",
"channel",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L45-L50
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/channel/ledger.go
|
QueryBlockByHash
|
func (c *Ledger) QueryBlockByHash(reqCtx reqContext.Context, blockHash []byte, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.Block, error) {
if len(blockHash) == 0 {
return nil, errors.New("blockHash is required")
}
cir := createBlockByHashInvokeRequest(c.chName, blockHash)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses, errors := getConfigBlocks(tprs)
errs = multi.Append(errs, errors)
return responses, errs
}
|
go
|
func (c *Ledger) QueryBlockByHash(reqCtx reqContext.Context, blockHash []byte, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.Block, error) {
if len(blockHash) == 0 {
return nil, errors.New("blockHash is required")
}
cir := createBlockByHashInvokeRequest(c.chName, blockHash)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses, errors := getConfigBlocks(tprs)
errs = multi.Append(errs, errors)
return responses, errs
}
|
[
"func",
"(",
"c",
"*",
"Ledger",
")",
"QueryBlockByHash",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"blockHash",
"[",
"]",
"byte",
",",
"targets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
",",
"verifier",
"ResponseVerifier",
")",
"(",
"[",
"]",
"*",
"common",
".",
"Block",
",",
"error",
")",
"{",
"if",
"len",
"(",
"blockHash",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cir",
":=",
"createBlockByHashInvokeRequest",
"(",
"c",
".",
"chName",
",",
"blockHash",
")",
"\n",
"tprs",
",",
"errs",
":=",
"queryChaincode",
"(",
"reqCtx",
",",
"c",
".",
"chName",
",",
"cir",
",",
"targets",
",",
"verifier",
")",
"\n\n",
"responses",
",",
"errors",
":=",
"getConfigBlocks",
"(",
"tprs",
")",
"\n",
"errs",
"=",
"multi",
".",
"Append",
"(",
"errs",
",",
"errors",
")",
"\n\n",
"return",
"responses",
",",
"errs",
"\n",
"}"
] |
// QueryBlockByHash queries the ledger for Block by block hash.
// This query will be made to specified targets.
// Returns the block.
|
[
"QueryBlockByHash",
"queries",
"the",
"ledger",
"for",
"Block",
"by",
"block",
"hash",
".",
"This",
"query",
"will",
"be",
"made",
"to",
"specified",
"targets",
".",
"Returns",
"the",
"block",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L84-L97
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/channel/ledger.go
|
QueryBlockByTxID
|
func (c *Ledger) QueryBlockByTxID(reqCtx reqContext.Context, txID fab.TransactionID, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.Block, error) {
if txID == "" {
return nil, errors.New("txID is required")
}
cir := createBlockByTxIDInvokeRequest(c.chName, txID)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses, errors := getConfigBlocks(tprs)
errs = multi.Append(errs, errors)
return responses, errs
}
|
go
|
func (c *Ledger) QueryBlockByTxID(reqCtx reqContext.Context, txID fab.TransactionID, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.Block, error) {
if txID == "" {
return nil, errors.New("txID is required")
}
cir := createBlockByTxIDInvokeRequest(c.chName, txID)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses, errors := getConfigBlocks(tprs)
errs = multi.Append(errs, errors)
return responses, errs
}
|
[
"func",
"(",
"c",
"*",
"Ledger",
")",
"QueryBlockByTxID",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"txID",
"fab",
".",
"TransactionID",
",",
"targets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
",",
"verifier",
"ResponseVerifier",
")",
"(",
"[",
"]",
"*",
"common",
".",
"Block",
",",
"error",
")",
"{",
"if",
"txID",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cir",
":=",
"createBlockByTxIDInvokeRequest",
"(",
"c",
".",
"chName",
",",
"txID",
")",
"\n",
"tprs",
",",
"errs",
":=",
"queryChaincode",
"(",
"reqCtx",
",",
"c",
".",
"chName",
",",
"cir",
",",
"targets",
",",
"verifier",
")",
"\n\n",
"responses",
",",
"errors",
":=",
"getConfigBlocks",
"(",
"tprs",
")",
"\n",
"errs",
"=",
"multi",
".",
"Append",
"(",
"errs",
",",
"errors",
")",
"\n\n",
"return",
"responses",
",",
"errs",
"\n",
"}"
] |
// QueryBlockByTxID returns a block which contains a transaction
// This query will be made to specified targets.
// Returns the block.
|
[
"QueryBlockByTxID",
"returns",
"a",
"block",
"which",
"contains",
"a",
"transaction",
"This",
"query",
"will",
"be",
"made",
"to",
"specified",
"targets",
".",
"Returns",
"the",
"block",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L102-L115
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/channel/ledger.go
|
QueryTransaction
|
func (c *Ledger) QueryTransaction(reqCtx reqContext.Context, transactionID fab.TransactionID, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*pb.ProcessedTransaction, error) {
cir := createTransactionByIDInvokeRequest(c.chName, transactionID)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*pb.ProcessedTransaction{}
for _, tpr := range tprs {
r, err := createProcessedTransaction(tpr)
if err != nil {
errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
} else {
responses = append(responses, r)
}
}
return responses, errs
}
|
go
|
func (c *Ledger) QueryTransaction(reqCtx reqContext.Context, transactionID fab.TransactionID, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*pb.ProcessedTransaction, error) {
cir := createTransactionByIDInvokeRequest(c.chName, transactionID)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*pb.ProcessedTransaction{}
for _, tpr := range tprs {
r, err := createProcessedTransaction(tpr)
if err != nil {
errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
} else {
responses = append(responses, r)
}
}
return responses, errs
}
|
[
"func",
"(",
"c",
"*",
"Ledger",
")",
"QueryTransaction",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"transactionID",
"fab",
".",
"TransactionID",
",",
"targets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
",",
"verifier",
"ResponseVerifier",
")",
"(",
"[",
"]",
"*",
"pb",
".",
"ProcessedTransaction",
",",
"error",
")",
"{",
"cir",
":=",
"createTransactionByIDInvokeRequest",
"(",
"c",
".",
"chName",
",",
"transactionID",
")",
"\n",
"tprs",
",",
"errs",
":=",
"queryChaincode",
"(",
"reqCtx",
",",
"c",
".",
"chName",
",",
"cir",
",",
"targets",
",",
"verifier",
")",
"\n\n",
"responses",
":=",
"[",
"]",
"*",
"pb",
".",
"ProcessedTransaction",
"{",
"}",
"\n",
"for",
"_",
",",
"tpr",
":=",
"range",
"tprs",
"{",
"r",
",",
"err",
":=",
"createProcessedTransaction",
"(",
"tpr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multi",
".",
"Append",
"(",
"errs",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
"+",
"tpr",
".",
"Endorser",
")",
")",
"\n",
"}",
"else",
"{",
"responses",
"=",
"append",
"(",
"responses",
",",
"r",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"responses",
",",
"errs",
"\n",
"}"
] |
// QueryTransaction queries the ledger for Transaction by number.
// This query will be made to specified targets.
// Returns the ProcessedTransaction information containing the transaction.
|
[
"QueryTransaction",
"queries",
"the",
"ledger",
"for",
"Transaction",
"by",
"number",
".",
"This",
"query",
"will",
"be",
"made",
"to",
"specified",
"targets",
".",
"Returns",
"the",
"ProcessedTransaction",
"information",
"containing",
"the",
"transaction",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L157-L173
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/channel/ledger.go
|
QueryInstantiatedChaincodes
|
func (c *Ledger) QueryInstantiatedChaincodes(reqCtx reqContext.Context, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*pb.ChaincodeQueryResponse, error) {
cir := createChaincodeInvokeRequest()
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*pb.ChaincodeQueryResponse{}
for _, tpr := range tprs {
r, err := createChaincodeQueryResponse(tpr)
if err != nil {
errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
} else {
responses = append(responses, r)
}
}
return responses, errs
}
|
go
|
func (c *Ledger) QueryInstantiatedChaincodes(reqCtx reqContext.Context, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*pb.ChaincodeQueryResponse, error) {
cir := createChaincodeInvokeRequest()
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*pb.ChaincodeQueryResponse{}
for _, tpr := range tprs {
r, err := createChaincodeQueryResponse(tpr)
if err != nil {
errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
} else {
responses = append(responses, r)
}
}
return responses, errs
}
|
[
"func",
"(",
"c",
"*",
"Ledger",
")",
"QueryInstantiatedChaincodes",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"targets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
",",
"verifier",
"ResponseVerifier",
")",
"(",
"[",
"]",
"*",
"pb",
".",
"ChaincodeQueryResponse",
",",
"error",
")",
"{",
"cir",
":=",
"createChaincodeInvokeRequest",
"(",
")",
"\n",
"tprs",
",",
"errs",
":=",
"queryChaincode",
"(",
"reqCtx",
",",
"c",
".",
"chName",
",",
"cir",
",",
"targets",
",",
"verifier",
")",
"\n\n",
"responses",
":=",
"[",
"]",
"*",
"pb",
".",
"ChaincodeQueryResponse",
"{",
"}",
"\n",
"for",
"_",
",",
"tpr",
":=",
"range",
"tprs",
"{",
"r",
",",
"err",
":=",
"createChaincodeQueryResponse",
"(",
"tpr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multi",
".",
"Append",
"(",
"errs",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
"+",
"tpr",
".",
"Endorser",
")",
")",
"\n",
"}",
"else",
"{",
"responses",
"=",
"append",
"(",
"responses",
",",
"r",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"responses",
",",
"errs",
"\n",
"}"
] |
// QueryInstantiatedChaincodes queries the instantiated chaincodes on this channel.
// This query will be made to specified targets.
|
[
"QueryInstantiatedChaincodes",
"queries",
"the",
"instantiated",
"chaincodes",
"on",
"this",
"channel",
".",
"This",
"query",
"will",
"be",
"made",
"to",
"specified",
"targets",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L186-L200
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/channel/ledger.go
|
QueryCollectionsConfig
|
func (c *Ledger) QueryCollectionsConfig(reqCtx reqContext.Context, chaincodeName string, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.CollectionConfigPackage, error) {
cir := createCollectionsConfigInvokeRequest(chaincodeName)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*common.CollectionConfigPackage{}
for _, tpr := range tprs {
r, err := createCollectionsConfigQueryResponse(tpr)
if err != nil {
errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
} else {
responses = append(responses, r)
}
}
return responses, errs
}
|
go
|
func (c *Ledger) QueryCollectionsConfig(reqCtx reqContext.Context, chaincodeName string, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.CollectionConfigPackage, error) {
cir := createCollectionsConfigInvokeRequest(chaincodeName)
tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
responses := []*common.CollectionConfigPackage{}
for _, tpr := range tprs {
r, err := createCollectionsConfigQueryResponse(tpr)
if err != nil {
errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
} else {
responses = append(responses, r)
}
}
return responses, errs
}
|
[
"func",
"(",
"c",
"*",
"Ledger",
")",
"QueryCollectionsConfig",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"chaincodeName",
"string",
",",
"targets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
",",
"verifier",
"ResponseVerifier",
")",
"(",
"[",
"]",
"*",
"common",
".",
"CollectionConfigPackage",
",",
"error",
")",
"{",
"cir",
":=",
"createCollectionsConfigInvokeRequest",
"(",
"chaincodeName",
")",
"\n",
"tprs",
",",
"errs",
":=",
"queryChaincode",
"(",
"reqCtx",
",",
"c",
".",
"chName",
",",
"cir",
",",
"targets",
",",
"verifier",
")",
"\n\n",
"responses",
":=",
"[",
"]",
"*",
"common",
".",
"CollectionConfigPackage",
"{",
"}",
"\n",
"for",
"_",
",",
"tpr",
":=",
"range",
"tprs",
"{",
"r",
",",
"err",
":=",
"createCollectionsConfigQueryResponse",
"(",
"tpr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multi",
".",
"Append",
"(",
"errs",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
"+",
"tpr",
".",
"Endorser",
")",
")",
"\n",
"}",
"else",
"{",
"responses",
"=",
"append",
"(",
"responses",
",",
"r",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"responses",
",",
"errs",
"\n",
"}"
] |
// QueryCollectionsConfig queries the collections config for a chaincode on this channel.
|
[
"QueryCollectionsConfig",
"queries",
"the",
"collections",
"config",
"for",
"a",
"chaincode",
"on",
"this",
"channel",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L212-L226
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/channel/ledger.go
|
QueryConfigBlock
|
func (c *Ledger) QueryConfigBlock(reqCtx reqContext.Context, targets []fab.ProposalProcessor, verifier ResponseVerifier) (*common.Block, error) {
if len(targets) == 0 {
return nil, errors.New("target(s) required")
}
cir := createConfigBlockInvokeRequest(c.chName)
tprs, err := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
if err != nil && len(tprs) == 0 {
return nil, errors.WithMessage(err, "queryChaincode failed")
}
matchErr := verifier.Match(tprs)
if matchErr != nil {
return nil, matchErr
}
return createCommonBlock(tprs[0])
}
|
go
|
func (c *Ledger) QueryConfigBlock(reqCtx reqContext.Context, targets []fab.ProposalProcessor, verifier ResponseVerifier) (*common.Block, error) {
if len(targets) == 0 {
return nil, errors.New("target(s) required")
}
cir := createConfigBlockInvokeRequest(c.chName)
tprs, err := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
if err != nil && len(tprs) == 0 {
return nil, errors.WithMessage(err, "queryChaincode failed")
}
matchErr := verifier.Match(tprs)
if matchErr != nil {
return nil, matchErr
}
return createCommonBlock(tprs[0])
}
|
[
"func",
"(",
"c",
"*",
"Ledger",
")",
"QueryConfigBlock",
"(",
"reqCtx",
"reqContext",
".",
"Context",
",",
"targets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
",",
"verifier",
"ResponseVerifier",
")",
"(",
"*",
"common",
".",
"Block",
",",
"error",
")",
"{",
"if",
"len",
"(",
"targets",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cir",
":=",
"createConfigBlockInvokeRequest",
"(",
"c",
".",
"chName",
")",
"\n",
"tprs",
",",
"err",
":=",
"queryChaincode",
"(",
"reqCtx",
",",
"c",
".",
"chName",
",",
"cir",
",",
"targets",
",",
"verifier",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"len",
"(",
"tprs",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"matchErr",
":=",
"verifier",
".",
"Match",
"(",
"tprs",
")",
"\n",
"if",
"matchErr",
"!=",
"nil",
"{",
"return",
"nil",
",",
"matchErr",
"\n",
"}",
"\n\n",
"return",
"createCommonBlock",
"(",
"tprs",
"[",
"0",
"]",
")",
"\n",
"}"
] |
// QueryConfigBlock returns the current configuration block for the specified channel. If the
// peer doesn't belong to the channel, return error
|
[
"QueryConfigBlock",
"returns",
"the",
"current",
"configuration",
"block",
"for",
"the",
"specified",
"channel",
".",
"If",
"the",
"peer",
"doesn",
"t",
"belong",
"to",
"the",
"channel",
"return",
"error"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/ledger.go#L239-L256
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/event/opts.go
|
WithBlockNum
|
func WithBlockNum(from uint64) ClientOption {
return func(c *Client) error {
c.fromBlock = from
return nil
}
}
|
go
|
func WithBlockNum(from uint64) ClientOption {
return func(c *Client) error {
c.fromBlock = from
return nil
}
}
|
[
"func",
"WithBlockNum",
"(",
"from",
"uint64",
")",
"ClientOption",
"{",
"return",
"func",
"(",
"c",
"*",
"Client",
")",
"error",
"{",
"c",
".",
"fromBlock",
"=",
"from",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// WithBlockNum indicates the block number from which events are to be received.
// Only deliverclient supports this
|
[
"WithBlockNum",
"indicates",
"the",
"block",
"number",
"from",
"which",
"events",
"are",
"to",
"be",
"received",
".",
"Only",
"deliverclient",
"supports",
"this"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/event/opts.go#L25-L30
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/event/opts.go
|
WithSeekType
|
func WithSeekType(seek seek.Type) ClientOption {
return func(c *Client) error {
c.seekType = seek
return nil
}
}
|
go
|
func WithSeekType(seek seek.Type) ClientOption {
return func(c *Client) error {
c.seekType = seek
return nil
}
}
|
[
"func",
"WithSeekType",
"(",
"seek",
"seek",
".",
"Type",
")",
"ClientOption",
"{",
"return",
"func",
"(",
"c",
"*",
"Client",
")",
"error",
"{",
"c",
".",
"seekType",
"=",
"seek",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// WithSeekType indicates the type of seek desired - newest, oldest or from given block
// Only deliverclient supports this
|
[
"WithSeekType",
"indicates",
"the",
"type",
"of",
"seek",
"desired",
"-",
"newest",
"oldest",
"or",
"from",
"given",
"block",
"Only",
"deliverclient",
"supports",
"this"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/event/opts.go#L34-L39
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/mocks/mockpeer.go
|
NewMockStatefulPeer
|
func NewMockStatefulPeer(name, url string, opts ...MockPeerOpt) *MockPeer {
p := &MockPeer{
MockPeer: fabmocks.NewMockPeer(name, url),
}
for _, opt := range opts {
opt(p)
}
return p
}
|
go
|
func NewMockStatefulPeer(name, url string, opts ...MockPeerOpt) *MockPeer {
p := &MockPeer{
MockPeer: fabmocks.NewMockPeer(name, url),
}
for _, opt := range opts {
opt(p)
}
return p
}
|
[
"func",
"NewMockStatefulPeer",
"(",
"name",
",",
"url",
"string",
",",
"opts",
"...",
"MockPeerOpt",
")",
"*",
"MockPeer",
"{",
"p",
":=",
"&",
"MockPeer",
"{",
"MockPeer",
":",
"fabmocks",
".",
"NewMockPeer",
"(",
"name",
",",
"url",
")",
",",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"p",
")",
"\n",
"}",
"\n",
"return",
"p",
"\n",
"}"
] |
// NewMockStatefulPeer returns a new MockPeer with the given options
|
[
"NewMockStatefulPeer",
"returns",
"a",
"new",
"MockPeer",
"with",
"the",
"given",
"options"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockpeer.go#L40-L48
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/mocks/mockpeer.go
|
BlockHeight
|
func (p *MockPeer) BlockHeight() uint64 {
p.lock.RLock()
defer p.lock.RUnlock()
return p.blockHeight
}
|
go
|
func (p *MockPeer) BlockHeight() uint64 {
p.lock.RLock()
defer p.lock.RUnlock()
return p.blockHeight
}
|
[
"func",
"(",
"p",
"*",
"MockPeer",
")",
"BlockHeight",
"(",
")",
"uint64",
"{",
"p",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"p",
".",
"blockHeight",
"\n",
"}"
] |
// BlockHeight returns the block height
|
[
"BlockHeight",
"returns",
"the",
"block",
"height"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockpeer.go#L60-L64
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/mocks/mockpeer.go
|
SetBlockHeight
|
func (p *MockPeer) SetBlockHeight(blockHeight uint64) {
p.lock.Lock()
defer p.lock.Unlock()
p.blockHeight = blockHeight
}
|
go
|
func (p *MockPeer) SetBlockHeight(blockHeight uint64) {
p.lock.Lock()
defer p.lock.Unlock()
p.blockHeight = blockHeight
}
|
[
"func",
"(",
"p",
"*",
"MockPeer",
")",
"SetBlockHeight",
"(",
"blockHeight",
"uint64",
")",
"{",
"p",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"p",
".",
"blockHeight",
"=",
"blockHeight",
"\n",
"}"
] |
// SetBlockHeight sets the block height
|
[
"SetBlockHeight",
"sets",
"the",
"block",
"height"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockpeer.go#L67-L71
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/ledger/ledger.go
|
New
|
func New(channelProvider context.ChannelProvider, opts ...ClientOption) (*Client, error) {
channelContext, err := channelProvider()
if err != nil {
return nil, err
}
if channelContext.ChannelService() == nil {
return nil, errors.New("channel service not initialized")
}
membership, err := channelContext.ChannelService().Membership()
if err != nil {
return nil, errors.WithMessage(err, "membership creation failed")
}
ledger, err := channel.NewLedger(channelContext.ChannelID())
if err != nil {
return nil, err
}
ledgerFilter := filter.NewEndpointFilter(channelContext, filter.LedgerQuery)
discoveryService, err := channelContext.ChannelService().Discovery()
if err != nil {
return nil, err
}
// Apply filter to discovery service
discovery := discovery.NewDiscoveryFilterService(discoveryService, ledgerFilter)
ledgerClient := Client{
ctx: channelContext,
ledger: ledger,
verifier: &verifier.Signature{Membership: membership},
discovery: discovery,
}
for _, opt := range opts {
err := opt(&ledgerClient)
if err != nil {
return nil, err
}
}
// check if target filter was set - if not set the default
if ledgerClient.filter == nil {
// Default target filter is based on user msp
if channelContext.Identifier().MSPID == "" {
return nil, errors.New("mspID not available in user context")
}
filter := &mspFilter{mspID: channelContext.Identifier().MSPID}
ledgerClient.filter = filter
}
return &ledgerClient, nil
}
|
go
|
func New(channelProvider context.ChannelProvider, opts ...ClientOption) (*Client, error) {
channelContext, err := channelProvider()
if err != nil {
return nil, err
}
if channelContext.ChannelService() == nil {
return nil, errors.New("channel service not initialized")
}
membership, err := channelContext.ChannelService().Membership()
if err != nil {
return nil, errors.WithMessage(err, "membership creation failed")
}
ledger, err := channel.NewLedger(channelContext.ChannelID())
if err != nil {
return nil, err
}
ledgerFilter := filter.NewEndpointFilter(channelContext, filter.LedgerQuery)
discoveryService, err := channelContext.ChannelService().Discovery()
if err != nil {
return nil, err
}
// Apply filter to discovery service
discovery := discovery.NewDiscoveryFilterService(discoveryService, ledgerFilter)
ledgerClient := Client{
ctx: channelContext,
ledger: ledger,
verifier: &verifier.Signature{Membership: membership},
discovery: discovery,
}
for _, opt := range opts {
err := opt(&ledgerClient)
if err != nil {
return nil, err
}
}
// check if target filter was set - if not set the default
if ledgerClient.filter == nil {
// Default target filter is based on user msp
if channelContext.Identifier().MSPID == "" {
return nil, errors.New("mspID not available in user context")
}
filter := &mspFilter{mspID: channelContext.Identifier().MSPID}
ledgerClient.filter = filter
}
return &ledgerClient, nil
}
|
[
"func",
"New",
"(",
"channelProvider",
"context",
".",
"ChannelProvider",
",",
"opts",
"...",
"ClientOption",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"channelContext",
",",
"err",
":=",
"channelProvider",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"channelContext",
".",
"ChannelService",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"membership",
",",
"err",
":=",
"channelContext",
".",
"ChannelService",
"(",
")",
".",
"Membership",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"ledger",
",",
"err",
":=",
"channel",
".",
"NewLedger",
"(",
"channelContext",
".",
"ChannelID",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"ledgerFilter",
":=",
"filter",
".",
"NewEndpointFilter",
"(",
"channelContext",
",",
"filter",
".",
"LedgerQuery",
")",
"\n\n",
"discoveryService",
",",
"err",
":=",
"channelContext",
".",
"ChannelService",
"(",
")",
".",
"Discovery",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Apply filter to discovery service",
"discovery",
":=",
"discovery",
".",
"NewDiscoveryFilterService",
"(",
"discoveryService",
",",
"ledgerFilter",
")",
"\n\n",
"ledgerClient",
":=",
"Client",
"{",
"ctx",
":",
"channelContext",
",",
"ledger",
":",
"ledger",
",",
"verifier",
":",
"&",
"verifier",
".",
"Signature",
"{",
"Membership",
":",
"membership",
"}",
",",
"discovery",
":",
"discovery",
",",
"}",
"\n\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"err",
":=",
"opt",
"(",
"&",
"ledgerClient",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// check if target filter was set - if not set the default",
"if",
"ledgerClient",
".",
"filter",
"==",
"nil",
"{",
"// Default target filter is based on user msp",
"if",
"channelContext",
".",
"Identifier",
"(",
")",
".",
"MSPID",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"filter",
":=",
"&",
"mspFilter",
"{",
"mspID",
":",
"channelContext",
".",
"Identifier",
"(",
")",
".",
"MSPID",
"}",
"\n",
"ledgerClient",
".",
"filter",
"=",
"filter",
"\n",
"}",
"\n\n",
"return",
"&",
"ledgerClient",
",",
"nil",
"\n",
"}"
] |
// New returns a ledger client instance. A ledger client instance provides a handler to query various info on specified channel.
// An application that requires interaction with multiple channels should create a separate
// instance of the ledger client for each channel. Ledger client supports specific queries only.
|
[
"New",
"returns",
"a",
"ledger",
"client",
"instance",
".",
"A",
"ledger",
"client",
"instance",
"provides",
"a",
"handler",
"to",
"query",
"various",
"info",
"on",
"specified",
"channel",
".",
"An",
"application",
"that",
"requires",
"interaction",
"with",
"multiple",
"channels",
"should",
"create",
"a",
"separate",
"instance",
"of",
"the",
"ledger",
"client",
"for",
"each",
"channel",
".",
"Ledger",
"client",
"supports",
"specific",
"queries",
"only",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/ledger/ledger.go#L63-L119
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/ledger/ledger.go
|
prepareRequestOpts
|
func (c *Client) prepareRequestOpts(options ...RequestOption) (requestOptions, error) {
opts := requestOptions{}
for _, option := range options {
err := option(c.ctx, &opts)
if err != nil {
return opts, errors.WithMessage(err, "Failed to read request opts")
}
}
// Set defaults for max targets
if opts.MaxTargets == 0 {
opts.MaxTargets = maxTargets
}
// Set defaults for min targets/matches
if opts.MinTargets == 0 {
opts.MinTargets = minTargets
}
if opts.MinTargets > opts.MaxTargets {
opts.MaxTargets = opts.MinTargets
}
return opts, nil
}
|
go
|
func (c *Client) prepareRequestOpts(options ...RequestOption) (requestOptions, error) {
opts := requestOptions{}
for _, option := range options {
err := option(c.ctx, &opts)
if err != nil {
return opts, errors.WithMessage(err, "Failed to read request opts")
}
}
// Set defaults for max targets
if opts.MaxTargets == 0 {
opts.MaxTargets = maxTargets
}
// Set defaults for min targets/matches
if opts.MinTargets == 0 {
opts.MinTargets = minTargets
}
if opts.MinTargets > opts.MaxTargets {
opts.MaxTargets = opts.MinTargets
}
return opts, nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"prepareRequestOpts",
"(",
"options",
"...",
"RequestOption",
")",
"(",
"requestOptions",
",",
"error",
")",
"{",
"opts",
":=",
"requestOptions",
"{",
"}",
"\n",
"for",
"_",
",",
"option",
":=",
"range",
"options",
"{",
"err",
":=",
"option",
"(",
"c",
".",
"ctx",
",",
"&",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"opts",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Set defaults for max targets",
"if",
"opts",
".",
"MaxTargets",
"==",
"0",
"{",
"opts",
".",
"MaxTargets",
"=",
"maxTargets",
"\n",
"}",
"\n\n",
"// Set defaults for min targets/matches",
"if",
"opts",
".",
"MinTargets",
"==",
"0",
"{",
"opts",
".",
"MinTargets",
"=",
"minTargets",
"\n",
"}",
"\n\n",
"if",
"opts",
".",
"MinTargets",
">",
"opts",
".",
"MaxTargets",
"{",
"opts",
".",
"MaxTargets",
"=",
"opts",
".",
"MinTargets",
"\n",
"}",
"\n\n",
"return",
"opts",
",",
"nil",
"\n",
"}"
] |
//prepareRequestOpts Reads Opts from Option array
|
[
"prepareRequestOpts",
"Reads",
"Opts",
"from",
"Option",
"array"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/ledger/ledger.go#L334-L358
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fabsdk/provider/chpvdr/cachekey.go
|
newCtxtCacheKey
|
func newCtxtCacheKey(ctx fab.ClientContext) (*ctxtCacheKey, error) {
identity, err := ctx.Serialize()
if err != nil {
return nil, err
}
h := sha256.New()
if _, err := h.Write(identity); err != nil {
return nil, err
}
hash := h.Sum(nil)
return &ctxtCacheKey{
key: string(hash),
context: ctx,
}, nil
}
|
go
|
func newCtxtCacheKey(ctx fab.ClientContext) (*ctxtCacheKey, error) {
identity, err := ctx.Serialize()
if err != nil {
return nil, err
}
h := sha256.New()
if _, err := h.Write(identity); err != nil {
return nil, err
}
hash := h.Sum(nil)
return &ctxtCacheKey{
key: string(hash),
context: ctx,
}, nil
}
|
[
"func",
"newCtxtCacheKey",
"(",
"ctx",
"fab",
".",
"ClientContext",
")",
"(",
"*",
"ctxtCacheKey",
",",
"error",
")",
"{",
"identity",
",",
"err",
":=",
"ctx",
".",
"Serialize",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"h",
":=",
"sha256",
".",
"New",
"(",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"h",
".",
"Write",
"(",
"identity",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"hash",
":=",
"h",
".",
"Sum",
"(",
"nil",
")",
"\n\n",
"return",
"&",
"ctxtCacheKey",
"{",
"key",
":",
"string",
"(",
"hash",
")",
",",
"context",
":",
"ctx",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// newCtxtCacheKey returns a new cacheKey
|
[
"newCtxtCacheKey",
"returns",
"a",
"new",
"cacheKey"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fabsdk/provider/chpvdr/cachekey.go#L24-L41
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fabsdk/provider/chpvdr/cachekey.go
|
newEventCacheKey
|
func newEventCacheKey(chConfig fab.ChannelCfg, opts ...options.Opt) (*eventCacheKey, error) {
params := defaultParams()
options.Apply(params, opts)
h := sha256.New()
if _, err := h.Write([]byte(params.getOptKey())); err != nil {
return nil, err
}
hash := h.Sum([]byte(chConfig.ID()))
return &eventCacheKey{
channelConfig: chConfig,
key: string(hash),
opts: opts,
}, nil
}
|
go
|
func newEventCacheKey(chConfig fab.ChannelCfg, opts ...options.Opt) (*eventCacheKey, error) {
params := defaultParams()
options.Apply(params, opts)
h := sha256.New()
if _, err := h.Write([]byte(params.getOptKey())); err != nil {
return nil, err
}
hash := h.Sum([]byte(chConfig.ID()))
return &eventCacheKey{
channelConfig: chConfig,
key: string(hash),
opts: opts,
}, nil
}
|
[
"func",
"newEventCacheKey",
"(",
"chConfig",
"fab",
".",
"ChannelCfg",
",",
"opts",
"...",
"options",
".",
"Opt",
")",
"(",
"*",
"eventCacheKey",
",",
"error",
")",
"{",
"params",
":=",
"defaultParams",
"(",
")",
"\n",
"options",
".",
"Apply",
"(",
"params",
",",
"opts",
")",
"\n\n",
"h",
":=",
"sha256",
".",
"New",
"(",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"h",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"params",
".",
"getOptKey",
"(",
")",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"hash",
":=",
"h",
".",
"Sum",
"(",
"[",
"]",
"byte",
"(",
"chConfig",
".",
"ID",
"(",
")",
")",
")",
"\n\n",
"return",
"&",
"eventCacheKey",
"{",
"channelConfig",
":",
"chConfig",
",",
"key",
":",
"string",
"(",
"hash",
")",
",",
"opts",
":",
"opts",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// newEventCacheKey returns a new eventCacheKey
|
[
"newEventCacheKey",
"returns",
"a",
"new",
"eventCacheKey"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fabsdk/provider/chpvdr/cachekey.go#L73-L88
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockconfig.go
|
CAConfig
|
func (c *MockConfig) CAConfig(org string) (*msp.CAConfig, bool) {
caConfig := msp.CAConfig{
CAName: "org1",
}
return &caConfig, true
}
|
go
|
func (c *MockConfig) CAConfig(org string) (*msp.CAConfig, bool) {
caConfig := msp.CAConfig{
CAName: "org1",
}
return &caConfig, true
}
|
[
"func",
"(",
"c",
"*",
"MockConfig",
")",
"CAConfig",
"(",
"org",
"string",
")",
"(",
"*",
"msp",
".",
"CAConfig",
",",
"bool",
")",
"{",
"caConfig",
":=",
"msp",
".",
"CAConfig",
"{",
"CAName",
":",
"\"",
"\"",
",",
"}",
"\n\n",
"return",
"&",
"caConfig",
",",
"true",
"\n",
"}"
] |
// CAConfig not implemented
|
[
"CAConfig",
"not",
"implemented"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L103-L109
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockconfig.go
|
Timeout
|
func (c *MockConfig) Timeout(arg fab.TimeoutType) time.Duration {
return time.Second * 10
}
|
go
|
func (c *MockConfig) Timeout(arg fab.TimeoutType) time.Duration {
return time.Second * 10
}
|
[
"func",
"(",
"c",
"*",
"MockConfig",
")",
"Timeout",
"(",
"arg",
"fab",
".",
"TimeoutType",
")",
"time",
".",
"Duration",
"{",
"return",
"time",
".",
"Second",
"*",
"10",
"\n",
"}"
] |
//Timeout not implemented
|
[
"Timeout",
"not",
"implemented"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L127-L129
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockconfig.go
|
PeersConfig
|
func (c *MockConfig) PeersConfig(org string) ([]fab.PeerConfig, bool) {
return nil, false
}
|
go
|
func (c *MockConfig) PeersConfig(org string) ([]fab.PeerConfig, bool) {
return nil, false
}
|
[
"func",
"(",
"c",
"*",
"MockConfig",
")",
"PeersConfig",
"(",
"org",
"string",
")",
"(",
"[",
"]",
"fab",
".",
"PeerConfig",
",",
"bool",
")",
"{",
"return",
"nil",
",",
"false",
"\n",
"}"
] |
// PeersConfig Retrieves the fabric peers from the config file provided
|
[
"PeersConfig",
"Retrieves",
"the",
"fabric",
"peers",
"from",
"the",
"config",
"file",
"provided"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L132-L134
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockconfig.go
|
PeerConfig
|
func (c *MockConfig) PeerConfig(nameOrURL string) (*fab.PeerConfig, bool) {
if nameOrURL == "invalid" {
return nil, false
}
if c.customPeerCfg != nil {
return c.customPeerCfg, true
}
cfg := fab.PeerConfig{
URL: "example.com",
}
return &cfg, true
}
|
go
|
func (c *MockConfig) PeerConfig(nameOrURL string) (*fab.PeerConfig, bool) {
if nameOrURL == "invalid" {
return nil, false
}
if c.customPeerCfg != nil {
return c.customPeerCfg, true
}
cfg := fab.PeerConfig{
URL: "example.com",
}
return &cfg, true
}
|
[
"func",
"(",
"c",
"*",
"MockConfig",
")",
"PeerConfig",
"(",
"nameOrURL",
"string",
")",
"(",
"*",
"fab",
".",
"PeerConfig",
",",
"bool",
")",
"{",
"if",
"nameOrURL",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n",
"if",
"c",
".",
"customPeerCfg",
"!=",
"nil",
"{",
"return",
"c",
".",
"customPeerCfg",
",",
"true",
"\n",
"}",
"\n",
"cfg",
":=",
"fab",
".",
"PeerConfig",
"{",
"URL",
":",
"\"",
"\"",
",",
"}",
"\n",
"return",
"&",
"cfg",
",",
"true",
"\n",
"}"
] |
// PeerConfig Retrieves a specific peer from the configuration by org and name
|
[
"PeerConfig",
"Retrieves",
"a",
"specific",
"peer",
"from",
"the",
"configuration",
"by",
"org",
"and",
"name"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L137-L149
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockconfig.go
|
OrderersConfig
|
func (c *MockConfig) OrderersConfig() []fab.OrdererConfig {
oConfig, _ := c.OrdererConfig("")
return []fab.OrdererConfig{*oConfig}
}
|
go
|
func (c *MockConfig) OrderersConfig() []fab.OrdererConfig {
oConfig, _ := c.OrdererConfig("")
return []fab.OrdererConfig{*oConfig}
}
|
[
"func",
"(",
"c",
"*",
"MockConfig",
")",
"OrderersConfig",
"(",
")",
"[",
"]",
"fab",
".",
"OrdererConfig",
"{",
"oConfig",
",",
"_",
":=",
"c",
".",
"OrdererConfig",
"(",
"\"",
"\"",
")",
"\n",
"return",
"[",
"]",
"fab",
".",
"OrdererConfig",
"{",
"*",
"oConfig",
"}",
"\n",
"}"
] |
// OrderersConfig returns a list of defined orderers
|
[
"OrderersConfig",
"returns",
"a",
"list",
"of",
"defined",
"orderers"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L183-L186
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockconfig.go
|
OrdererConfig
|
func (c *MockConfig) OrdererConfig(name string) (*fab.OrdererConfig, bool) {
if name == "Invalid" {
return nil, false
}
if c.customOrdererCfg != nil {
return c.customOrdererCfg, true
}
oConfig := fab.OrdererConfig{
URL: "example.com",
}
return &oConfig, true
}
|
go
|
func (c *MockConfig) OrdererConfig(name string) (*fab.OrdererConfig, bool) {
if name == "Invalid" {
return nil, false
}
if c.customOrdererCfg != nil {
return c.customOrdererCfg, true
}
oConfig := fab.OrdererConfig{
URL: "example.com",
}
return &oConfig, true
}
|
[
"func",
"(",
"c",
"*",
"MockConfig",
")",
"OrdererConfig",
"(",
"name",
"string",
")",
"(",
"*",
"fab",
".",
"OrdererConfig",
",",
"bool",
")",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n",
"if",
"c",
".",
"customOrdererCfg",
"!=",
"nil",
"{",
"return",
"c",
".",
"customOrdererCfg",
",",
"true",
"\n",
"}",
"\n",
"oConfig",
":=",
"fab",
".",
"OrdererConfig",
"{",
"URL",
":",
"\"",
"\"",
",",
"}",
"\n\n",
"return",
"&",
"oConfig",
",",
"true",
"\n",
"}"
] |
// OrdererConfig not implemented
|
[
"OrdererConfig",
"not",
"implemented"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L209-L221
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockconfig.go
|
SetCustomChannelConfig
|
func (c *MockConfig) SetCustomChannelConfig(channelID string, config *fab.ChannelEndpointConfig) {
if c.chConfig == nil {
c.chConfig = make(map[string]*fab.ChannelEndpointConfig)
}
c.chConfig[channelID] = config
}
|
go
|
func (c *MockConfig) SetCustomChannelConfig(channelID string, config *fab.ChannelEndpointConfig) {
if c.chConfig == nil {
c.chConfig = make(map[string]*fab.ChannelEndpointConfig)
}
c.chConfig[channelID] = config
}
|
[
"func",
"(",
"c",
"*",
"MockConfig",
")",
"SetCustomChannelConfig",
"(",
"channelID",
"string",
",",
"config",
"*",
"fab",
".",
"ChannelEndpointConfig",
")",
"{",
"if",
"c",
".",
"chConfig",
"==",
"nil",
"{",
"c",
".",
"chConfig",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"fab",
".",
"ChannelEndpointConfig",
")",
"\n",
"}",
"\n",
"c",
".",
"chConfig",
"[",
"channelID",
"]",
"=",
"config",
"\n",
"}"
] |
// SetCustomChannelConfig sets the config for the given channel
|
[
"SetCustomChannelConfig",
"sets",
"the",
"config",
"for",
"the",
"given",
"channel"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L268-L273
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockconfig.go
|
Lookup
|
func (c *MockConfig) Lookup(key string) (interface{}, bool) {
if key == "invalid" {
return nil, false
}
value, ok := c.Lookup(key)
if !ok {
return nil, false
}
return value, true
}
|
go
|
func (c *MockConfig) Lookup(key string) (interface{}, bool) {
if key == "invalid" {
return nil, false
}
value, ok := c.Lookup(key)
if !ok {
return nil, false
}
return value, true
}
|
[
"func",
"(",
"c",
"*",
"MockConfig",
")",
"Lookup",
"(",
"key",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"if",
"key",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n",
"value",
",",
"ok",
":=",
"c",
".",
"Lookup",
"(",
"key",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n",
"return",
"value",
",",
"true",
"\n",
"}"
] |
// Lookup gets the Value from config file by Key
|
[
"Lookup",
"gets",
"the",
"Value",
"from",
"config",
"file",
"by",
"Key"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockconfig.go#L338-L347
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockbroadcastserver.go
|
Broadcast
|
func (m *MockBroadcastServer) Broadcast(server po.AtomicBroadcast_BroadcastServer) error {
res, err := server.Recv()
if err == io.EOF {
return nil
}
if err != nil {
return err
}
if m.BroadcastError != nil {
return m.BroadcastError
}
if m.BroadcastInternalServerError {
return server.Send(broadcastResponseError)
}
if m.BroadcastCustomResponse != nil {
return server.Send(m.BroadcastCustomResponse)
}
err = server.Send(broadcastResponseSuccess)
if err != nil {
return err
}
return m.mockBlockDelivery(res.Payload)
}
|
go
|
func (m *MockBroadcastServer) Broadcast(server po.AtomicBroadcast_BroadcastServer) error {
res, err := server.Recv()
if err == io.EOF {
return nil
}
if err != nil {
return err
}
if m.BroadcastError != nil {
return m.BroadcastError
}
if m.BroadcastInternalServerError {
return server.Send(broadcastResponseError)
}
if m.BroadcastCustomResponse != nil {
return server.Send(m.BroadcastCustomResponse)
}
err = server.Send(broadcastResponseSuccess)
if err != nil {
return err
}
return m.mockBlockDelivery(res.Payload)
}
|
[
"func",
"(",
"m",
"*",
"MockBroadcastServer",
")",
"Broadcast",
"(",
"server",
"po",
".",
"AtomicBroadcast_BroadcastServer",
")",
"error",
"{",
"res",
",",
"err",
":=",
"server",
".",
"Recv",
"(",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"BroadcastError",
"!=",
"nil",
"{",
"return",
"m",
".",
"BroadcastError",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"BroadcastInternalServerError",
"{",
"return",
"server",
".",
"Send",
"(",
"broadcastResponseError",
")",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"BroadcastCustomResponse",
"!=",
"nil",
"{",
"return",
"server",
".",
"Send",
"(",
"m",
".",
"BroadcastCustomResponse",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"server",
".",
"Send",
"(",
"broadcastResponseSuccess",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"m",
".",
"mockBlockDelivery",
"(",
"res",
".",
"Payload",
")",
"\n",
"}"
] |
// Broadcast mock broadcast
|
[
"Broadcast",
"mock",
"broadcast"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockbroadcastserver.go#L59-L87
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockbroadcastserver.go
|
Deliver
|
func (m *MockBroadcastServer) Deliver(server po.AtomicBroadcast_DeliverServer) error {
if m.DeliverError != nil {
return m.DeliverError
}
if m.DeliverResponse != nil {
if _, err := server.Recv(); err != nil {
return err
}
if err := server.SendMsg(m.DeliverResponse); err != nil {
return err
}
return nil
}
if _, err := server.Recv(); err != nil {
return err
}
if err := server.Send(TestBlock); err != nil {
return err
}
return nil
}
|
go
|
func (m *MockBroadcastServer) Deliver(server po.AtomicBroadcast_DeliverServer) error {
if m.DeliverError != nil {
return m.DeliverError
}
if m.DeliverResponse != nil {
if _, err := server.Recv(); err != nil {
return err
}
if err := server.SendMsg(m.DeliverResponse); err != nil {
return err
}
return nil
}
if _, err := server.Recv(); err != nil {
return err
}
if err := server.Send(TestBlock); err != nil {
return err
}
return nil
}
|
[
"func",
"(",
"m",
"*",
"MockBroadcastServer",
")",
"Deliver",
"(",
"server",
"po",
".",
"AtomicBroadcast_DeliverServer",
")",
"error",
"{",
"if",
"m",
".",
"DeliverError",
"!=",
"nil",
"{",
"return",
"m",
".",
"DeliverError",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"DeliverResponse",
"!=",
"nil",
"{",
"if",
"_",
",",
"err",
":=",
"server",
".",
"Recv",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"server",
".",
"SendMsg",
"(",
"m",
".",
"DeliverResponse",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"server",
".",
"Recv",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"server",
".",
"Send",
"(",
"TestBlock",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Deliver mock deliver
|
[
"Deliver",
"mock",
"deliver"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockbroadcastserver.go#L134-L157
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockbroadcastserver.go
|
Start
|
func (m *MockBroadcastServer) Start(address string) string {
if m.srv != nil {
panic("MockBroadcastServer already started")
}
// pass in TLS creds if present
if m.Creds != nil {
m.srv = grpc.NewServer(grpc.Creds(m.Creds))
} else {
m.srv = grpc.NewServer()
}
lis, err := net.Listen("tcp", address)
if err != nil {
panic(fmt.Sprintf("Error starting BroadcastServer %s", err))
}
addr := lis.Addr().String()
test.Logf("Starting MockEventServer [%s]", addr)
po.RegisterAtomicBroadcastServer(m.srv, m)
m.wg.Add(1)
go func() {
defer m.wg.Done()
if err := m.srv.Serve(lis); err != nil {
test.Logf("StartMockBroadcastServer failed [%s]", err)
}
}()
return addr
}
|
go
|
func (m *MockBroadcastServer) Start(address string) string {
if m.srv != nil {
panic("MockBroadcastServer already started")
}
// pass in TLS creds if present
if m.Creds != nil {
m.srv = grpc.NewServer(grpc.Creds(m.Creds))
} else {
m.srv = grpc.NewServer()
}
lis, err := net.Listen("tcp", address)
if err != nil {
panic(fmt.Sprintf("Error starting BroadcastServer %s", err))
}
addr := lis.Addr().String()
test.Logf("Starting MockEventServer [%s]", addr)
po.RegisterAtomicBroadcastServer(m.srv, m)
m.wg.Add(1)
go func() {
defer m.wg.Done()
if err := m.srv.Serve(lis); err != nil {
test.Logf("StartMockBroadcastServer failed [%s]", err)
}
}()
return addr
}
|
[
"func",
"(",
"m",
"*",
"MockBroadcastServer",
")",
"Start",
"(",
"address",
"string",
")",
"string",
"{",
"if",
"m",
".",
"srv",
"!=",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// pass in TLS creds if present",
"if",
"m",
".",
"Creds",
"!=",
"nil",
"{",
"m",
".",
"srv",
"=",
"grpc",
".",
"NewServer",
"(",
"grpc",
".",
"Creds",
"(",
"m",
".",
"Creds",
")",
")",
"\n",
"}",
"else",
"{",
"m",
".",
"srv",
"=",
"grpc",
".",
"NewServer",
"(",
")",
"\n",
"}",
"\n\n",
"lis",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"addr",
":=",
"lis",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
"\n\n",
"test",
".",
"Logf",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"po",
".",
"RegisterAtomicBroadcastServer",
"(",
"m",
".",
"srv",
",",
"m",
")",
"\n",
"m",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"m",
".",
"wg",
".",
"Done",
"(",
")",
"\n",
"if",
"err",
":=",
"m",
".",
"srv",
".",
"Serve",
"(",
"lis",
")",
";",
"err",
"!=",
"nil",
"{",
"test",
".",
"Logf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"addr",
"\n",
"}"
] |
// Start the mock broadcast server
|
[
"Start",
"the",
"mock",
"broadcast",
"server"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockbroadcastserver.go#L160-L189
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/common/selection/sorter/blockheightsorter/blockheightsorter.go
|
New
|
func New(opts ...coptions.Opt) options.PeerSorter {
params := defaultParams()
coptions.Apply(params, opts)
sorter := &sorter{
params: params,
}
return func(peers []fab.Peer) []fab.Peer {
return sorter.Sort(peers)
}
}
|
go
|
func New(opts ...coptions.Opt) options.PeerSorter {
params := defaultParams()
coptions.Apply(params, opts)
sorter := &sorter{
params: params,
}
return func(peers []fab.Peer) []fab.Peer {
return sorter.Sort(peers)
}
}
|
[
"func",
"New",
"(",
"opts",
"...",
"coptions",
".",
"Opt",
")",
"options",
".",
"PeerSorter",
"{",
"params",
":=",
"defaultParams",
"(",
")",
"\n",
"coptions",
".",
"Apply",
"(",
"params",
",",
"opts",
")",
"\n\n",
"sorter",
":=",
"&",
"sorter",
"{",
"params",
":",
"params",
",",
"}",
"\n\n",
"return",
"func",
"(",
"peers",
"[",
"]",
"fab",
".",
"Peer",
")",
"[",
"]",
"fab",
".",
"Peer",
"{",
"return",
"sorter",
".",
"Sort",
"(",
"peers",
")",
"\n",
"}",
"\n",
"}"
] |
// New returns a peer sorter that uses block height and the provided balancer to sort the peers.
// This sorter uses a block-height-lag-threshold property which is the number of blocks from
// the highest block of a group of peers that a peer can lag behind and still be considered to be
// up-to-date. These peers are sorted using the given Balancer.
// If a peer's block height falls behind this "lag" threshold then it will be demoted to a lower
// priority list of peers which will be sorted according to block height.
|
[
"New",
"returns",
"a",
"peer",
"sorter",
"that",
"uses",
"block",
"height",
"and",
"the",
"provided",
"balancer",
"to",
"sort",
"the",
"peers",
".",
"This",
"sorter",
"uses",
"a",
"block",
"-",
"height",
"-",
"lag",
"-",
"threshold",
"property",
"which",
"is",
"the",
"number",
"of",
"blocks",
"from",
"the",
"highest",
"block",
"of",
"a",
"group",
"of",
"peers",
"that",
"a",
"peer",
"can",
"lag",
"behind",
"and",
"still",
"be",
"considered",
"to",
"be",
"up",
"-",
"to",
"-",
"date",
".",
"These",
"peers",
"are",
"sorted",
"using",
"the",
"given",
"Balancer",
".",
"If",
"a",
"peer",
"s",
"block",
"height",
"falls",
"behind",
"this",
"lag",
"threshold",
"then",
"it",
"will",
"be",
"demoted",
"to",
"a",
"lower",
"priority",
"list",
"of",
"peers",
"which",
"will",
"be",
"sorted",
"according",
"to",
"block",
"height",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/sorter/blockheightsorter/blockheightsorter.go#L26-L37
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/common/selection/sorter/blockheightsorter/blockheightsorter.go
|
Sort
|
func (f *sorter) Sort(peers []fab.Peer) []fab.Peer {
if len(peers) <= 1 {
return peers
}
if f.blockHeightLagThreshold < 0 {
logger.Debugf("Returning all peers")
return f.balancer(peers)
}
maxHeight := getMaxBlockHeight(peers)
logger.Debugf("Max block height of peers: %d", maxHeight)
if maxHeight <= uint64(f.blockHeightLagThreshold) {
logger.Debugf("Max block height of peers is %d and lag threshold is %d so returning peers unsorted", maxHeight, f.blockHeightLagThreshold)
return f.balancer(peers)
}
cutoffHeight := maxHeight - uint64(f.blockHeightLagThreshold)
logger.Debugf("Choosing peers whose block heights are greater than the cutoff height %d ...", cutoffHeight)
// preferredPeers are all of the peers that have the same priority
var preferredPeers []fab.Peer
// otherPeers are peers that did not make the cutoff
var otherPeers []fab.Peer
for _, p := range peers {
peerState, ok := p.(fab.PeerState)
if !ok {
logger.Debugf("Accepting peer [%s] since it does not have state (may be a local peer)", p.URL())
preferredPeers = append(preferredPeers, p)
} else if peerState.BlockHeight() >= cutoffHeight {
logger.Debugf("Accepting peer [%s] at block height %d which is greater than or equal to the cutoff %d", p.URL(), peerState.BlockHeight(), cutoffHeight)
preferredPeers = append(preferredPeers, p)
} else {
logger.Debugf("Rejecting peer [%s] at block height %d which is less than the cutoff %d", p.URL(), peerState.BlockHeight(), cutoffHeight)
otherPeers = append(otherPeers, p)
}
}
// Apply the balancer on the prefferred peers
preferredPeers = f.balancer(preferredPeers)
// Sort the remaining peers in reverse order of block height
sort.Sort(sort.Reverse(&peerSorter{
peers: otherPeers,
}))
return append(preferredPeers, otherPeers...)
}
|
go
|
func (f *sorter) Sort(peers []fab.Peer) []fab.Peer {
if len(peers) <= 1 {
return peers
}
if f.blockHeightLagThreshold < 0 {
logger.Debugf("Returning all peers")
return f.balancer(peers)
}
maxHeight := getMaxBlockHeight(peers)
logger.Debugf("Max block height of peers: %d", maxHeight)
if maxHeight <= uint64(f.blockHeightLagThreshold) {
logger.Debugf("Max block height of peers is %d and lag threshold is %d so returning peers unsorted", maxHeight, f.blockHeightLagThreshold)
return f.balancer(peers)
}
cutoffHeight := maxHeight - uint64(f.blockHeightLagThreshold)
logger.Debugf("Choosing peers whose block heights are greater than the cutoff height %d ...", cutoffHeight)
// preferredPeers are all of the peers that have the same priority
var preferredPeers []fab.Peer
// otherPeers are peers that did not make the cutoff
var otherPeers []fab.Peer
for _, p := range peers {
peerState, ok := p.(fab.PeerState)
if !ok {
logger.Debugf("Accepting peer [%s] since it does not have state (may be a local peer)", p.URL())
preferredPeers = append(preferredPeers, p)
} else if peerState.BlockHeight() >= cutoffHeight {
logger.Debugf("Accepting peer [%s] at block height %d which is greater than or equal to the cutoff %d", p.URL(), peerState.BlockHeight(), cutoffHeight)
preferredPeers = append(preferredPeers, p)
} else {
logger.Debugf("Rejecting peer [%s] at block height %d which is less than the cutoff %d", p.URL(), peerState.BlockHeight(), cutoffHeight)
otherPeers = append(otherPeers, p)
}
}
// Apply the balancer on the prefferred peers
preferredPeers = f.balancer(preferredPeers)
// Sort the remaining peers in reverse order of block height
sort.Sort(sort.Reverse(&peerSorter{
peers: otherPeers,
}))
return append(preferredPeers, otherPeers...)
}
|
[
"func",
"(",
"f",
"*",
"sorter",
")",
"Sort",
"(",
"peers",
"[",
"]",
"fab",
".",
"Peer",
")",
"[",
"]",
"fab",
".",
"Peer",
"{",
"if",
"len",
"(",
"peers",
")",
"<=",
"1",
"{",
"return",
"peers",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"blockHeightLagThreshold",
"<",
"0",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"f",
".",
"balancer",
"(",
"peers",
")",
"\n",
"}",
"\n\n",
"maxHeight",
":=",
"getMaxBlockHeight",
"(",
"peers",
")",
"\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"maxHeight",
")",
"\n\n",
"if",
"maxHeight",
"<=",
"uint64",
"(",
"f",
".",
"blockHeightLagThreshold",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"maxHeight",
",",
"f",
".",
"blockHeightLagThreshold",
")",
"\n",
"return",
"f",
".",
"balancer",
"(",
"peers",
")",
"\n",
"}",
"\n\n",
"cutoffHeight",
":=",
"maxHeight",
"-",
"uint64",
"(",
"f",
".",
"blockHeightLagThreshold",
")",
"\n\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"cutoffHeight",
")",
"\n\n",
"// preferredPeers are all of the peers that have the same priority",
"var",
"preferredPeers",
"[",
"]",
"fab",
".",
"Peer",
"\n\n",
"// otherPeers are peers that did not make the cutoff",
"var",
"otherPeers",
"[",
"]",
"fab",
".",
"Peer",
"\n\n",
"for",
"_",
",",
"p",
":=",
"range",
"peers",
"{",
"peerState",
",",
"ok",
":=",
"p",
".",
"(",
"fab",
".",
"PeerState",
")",
"\n",
"if",
"!",
"ok",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"p",
".",
"URL",
"(",
")",
")",
"\n",
"preferredPeers",
"=",
"append",
"(",
"preferredPeers",
",",
"p",
")",
"\n",
"}",
"else",
"if",
"peerState",
".",
"BlockHeight",
"(",
")",
">=",
"cutoffHeight",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"p",
".",
"URL",
"(",
")",
",",
"peerState",
".",
"BlockHeight",
"(",
")",
",",
"cutoffHeight",
")",
"\n",
"preferredPeers",
"=",
"append",
"(",
"preferredPeers",
",",
"p",
")",
"\n",
"}",
"else",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"p",
".",
"URL",
"(",
")",
",",
"peerState",
".",
"BlockHeight",
"(",
")",
",",
"cutoffHeight",
")",
"\n",
"otherPeers",
"=",
"append",
"(",
"otherPeers",
",",
"p",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Apply the balancer on the prefferred peers",
"preferredPeers",
"=",
"f",
".",
"balancer",
"(",
"preferredPeers",
")",
"\n\n",
"// Sort the remaining peers in reverse order of block height",
"sort",
".",
"Sort",
"(",
"sort",
".",
"Reverse",
"(",
"&",
"peerSorter",
"{",
"peers",
":",
"otherPeers",
",",
"}",
")",
")",
"\n\n",
"return",
"append",
"(",
"preferredPeers",
",",
"otherPeers",
"...",
")",
"\n",
"}"
] |
// Sort sorts the given peers according to block height and lag threshold.
|
[
"Sort",
"sorts",
"the",
"given",
"peers",
"according",
"to",
"block",
"height",
"and",
"lag",
"threshold",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/sorter/blockheightsorter/blockheightsorter.go#L44-L95
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockdiscovery.go
|
CreateLocalDiscoveryService
|
func (dp *MockStaticDiscoveryProvider) CreateLocalDiscoveryService(mspID string) (fab.DiscoveryService, error) {
if dp.customDiscoveryService != nil {
return dp.customDiscoveryService, nil
}
return NewMockDiscoveryService(dp.Error, dp.Peers...), nil
}
|
go
|
func (dp *MockStaticDiscoveryProvider) CreateLocalDiscoveryService(mspID string) (fab.DiscoveryService, error) {
if dp.customDiscoveryService != nil {
return dp.customDiscoveryService, nil
}
return NewMockDiscoveryService(dp.Error, dp.Peers...), nil
}
|
[
"func",
"(",
"dp",
"*",
"MockStaticDiscoveryProvider",
")",
"CreateLocalDiscoveryService",
"(",
"mspID",
"string",
")",
"(",
"fab",
".",
"DiscoveryService",
",",
"error",
")",
"{",
"if",
"dp",
".",
"customDiscoveryService",
"!=",
"nil",
"{",
"return",
"dp",
".",
"customDiscoveryService",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"NewMockDiscoveryService",
"(",
"dp",
".",
"Error",
",",
"dp",
".",
"Peers",
"...",
")",
",",
"nil",
"\n",
"}"
] |
// CreateLocalDiscoveryService return local discovery service
|
[
"CreateLocalDiscoveryService",
"return",
"local",
"discovery",
"service"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockdiscovery.go#L36-L43
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/mocks/mockdiscovery.go
|
GetPeers
|
func (ds *MockStaticDiscoveryService) GetPeers() ([]fab.Peer, error) {
if ds.Error != nil {
return nil, ds.Error
}
if ds.Peers == nil {
mockPeer := MockPeer{MockName: "Peer1", MockURL: "http://peer1.com", MockRoles: []string{}, MockCert: nil, MockMSP: "Org1MSP"}
peers := make([]fab.Peer, 0)
peers = append(peers, &mockPeer)
ds.Peers = peers
}
return ds.Peers, nil
}
|
go
|
func (ds *MockStaticDiscoveryService) GetPeers() ([]fab.Peer, error) {
if ds.Error != nil {
return nil, ds.Error
}
if ds.Peers == nil {
mockPeer := MockPeer{MockName: "Peer1", MockURL: "http://peer1.com", MockRoles: []string{}, MockCert: nil, MockMSP: "Org1MSP"}
peers := make([]fab.Peer, 0)
peers = append(peers, &mockPeer)
ds.Peers = peers
}
return ds.Peers, nil
}
|
[
"func",
"(",
"ds",
"*",
"MockStaticDiscoveryService",
")",
"GetPeers",
"(",
")",
"(",
"[",
"]",
"fab",
".",
"Peer",
",",
"error",
")",
"{",
"if",
"ds",
".",
"Error",
"!=",
"nil",
"{",
"return",
"nil",
",",
"ds",
".",
"Error",
"\n",
"}",
"\n\n",
"if",
"ds",
".",
"Peers",
"==",
"nil",
"{",
"mockPeer",
":=",
"MockPeer",
"{",
"MockName",
":",
"\"",
"\"",
",",
"MockURL",
":",
"\"",
"\"",
",",
"MockRoles",
":",
"[",
"]",
"string",
"{",
"}",
",",
"MockCert",
":",
"nil",
",",
"MockMSP",
":",
"\"",
"\"",
"}",
"\n",
"peers",
":=",
"make",
"(",
"[",
"]",
"fab",
".",
"Peer",
",",
"0",
")",
"\n",
"peers",
"=",
"append",
"(",
"peers",
",",
"&",
"mockPeer",
")",
"\n",
"ds",
".",
"Peers",
"=",
"peers",
"\n",
"}",
"\n\n",
"return",
"ds",
".",
"Peers",
",",
"nil",
"\n\n",
"}"
] |
// GetPeers is used to discover eligible peers for chaincode
|
[
"GetPeers",
"is",
"used",
"to",
"discover",
"eligible",
"peers",
"for",
"chaincode"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockdiscovery.go#L56-L71
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/channel/membership/cache.go
|
NewRefCache
|
func NewRefCache(refresh time.Duration) *lazycache.Cache {
initializer := func(key lazycache.Key) (interface{}, error) {
ck, ok := key.(CacheKey)
if !ok {
return nil, errors.New("unexpected cache key")
}
return NewRef(refresh, ck.Context(), ck.ChConfigRef()), nil
}
return lazycache.New("Membership_Cache", initializer)
}
|
go
|
func NewRefCache(refresh time.Duration) *lazycache.Cache {
initializer := func(key lazycache.Key) (interface{}, error) {
ck, ok := key.(CacheKey)
if !ok {
return nil, errors.New("unexpected cache key")
}
return NewRef(refresh, ck.Context(), ck.ChConfigRef()), nil
}
return lazycache.New("Membership_Cache", initializer)
}
|
[
"func",
"NewRefCache",
"(",
"refresh",
"time",
".",
"Duration",
")",
"*",
"lazycache",
".",
"Cache",
"{",
"initializer",
":=",
"func",
"(",
"key",
"lazycache",
".",
"Key",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"ck",
",",
"ok",
":=",
"key",
".",
"(",
"CacheKey",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"NewRef",
"(",
"refresh",
",",
"ck",
".",
"Context",
"(",
")",
",",
"ck",
".",
"ChConfigRef",
"(",
")",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"lazycache",
".",
"New",
"(",
"\"",
"\"",
",",
"initializer",
")",
"\n",
"}"
] |
// NewRefCache a cache of membership references that refreshed with the
// given interval
|
[
"NewRefCache",
"a",
"cache",
"of",
"membership",
"references",
"that",
"refreshed",
"with",
"the",
"given",
"interval"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/channel/membership/cache.go#L50-L60
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fabsdk/fabsdk_perf.go
|
initMetrics
|
func (sdk *FabricSDK) initMetrics(configs *configs) {
if configs == nil {
return
}
if sdk.system == nil {
sdk.system = newOperationsSystem(configs)
err := sdk.system.Start()
if err != nil {
panic("metrics failed to start: " + err.Error())
}
// for now NewClientMetrics supports channel client. TODO: if other client types require metrics tracking, update this function
sdk.clientMetrics = metrics.NewClientMetrics(sdk.system.Provider)
}
}
|
go
|
func (sdk *FabricSDK) initMetrics(configs *configs) {
if configs == nil {
return
}
if sdk.system == nil {
sdk.system = newOperationsSystem(configs)
err := sdk.system.Start()
if err != nil {
panic("metrics failed to start: " + err.Error())
}
// for now NewClientMetrics supports channel client. TODO: if other client types require metrics tracking, update this function
sdk.clientMetrics = metrics.NewClientMetrics(sdk.system.Provider)
}
}
|
[
"func",
"(",
"sdk",
"*",
"FabricSDK",
")",
"initMetrics",
"(",
"configs",
"*",
"configs",
")",
"{",
"if",
"configs",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"sdk",
".",
"system",
"==",
"nil",
"{",
"sdk",
".",
"system",
"=",
"newOperationsSystem",
"(",
"configs",
")",
"\n\n",
"err",
":=",
"sdk",
".",
"system",
".",
"Start",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
"+",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// for now NewClientMetrics supports channel client. TODO: if other client types require metrics tracking, update this function",
"sdk",
".",
"clientMetrics",
"=",
"metrics",
".",
"NewClientMetrics",
"(",
"sdk",
".",
"system",
".",
"Provider",
")",
"\n",
"}",
"\n",
"}"
] |
// initMetrics will initialize the Go SDK's metric's system instance to allow capturing metrics data by the SDK clients.
|
[
"initMetrics",
"will",
"initialize",
"the",
"Go",
"SDK",
"s",
"metric",
"s",
"system",
"instance",
"to",
"allow",
"capturing",
"metrics",
"data",
"by",
"the",
"SDK",
"clients",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fabsdk/fabsdk_perf.go#L18-L33
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/comm/connector.go
|
NewCachingConnector
|
func NewCachingConnector(sweepTime time.Duration, idleTime time.Duration) *CachingConnector {
cc := CachingConnector{
conns: map[string]*cachedConn{},
index: map[*grpc.ClientConn]*cachedConn{},
janitorDone: make(chan bool, 1),
janitorClosed: make(chan bool, 1),
sweepTime: sweepTime,
idleTime: idleTime,
}
// cc.janitorClosed determines if a goroutine needs to be spun up.
// The janitor is able to shut itself down when it has no connection to monitor.
// When it shuts itself down, it pushes a value onto janitorClosed. We initialize
// the go chan with a bootstrap value so that cachingConnector spins up the
// goroutine on first usage.
cc.janitorClosed <- true
return &cc
}
|
go
|
func NewCachingConnector(sweepTime time.Duration, idleTime time.Duration) *CachingConnector {
cc := CachingConnector{
conns: map[string]*cachedConn{},
index: map[*grpc.ClientConn]*cachedConn{},
janitorDone: make(chan bool, 1),
janitorClosed: make(chan bool, 1),
sweepTime: sweepTime,
idleTime: idleTime,
}
// cc.janitorClosed determines if a goroutine needs to be spun up.
// The janitor is able to shut itself down when it has no connection to monitor.
// When it shuts itself down, it pushes a value onto janitorClosed. We initialize
// the go chan with a bootstrap value so that cachingConnector spins up the
// goroutine on first usage.
cc.janitorClosed <- true
return &cc
}
|
[
"func",
"NewCachingConnector",
"(",
"sweepTime",
"time",
".",
"Duration",
",",
"idleTime",
"time",
".",
"Duration",
")",
"*",
"CachingConnector",
"{",
"cc",
":=",
"CachingConnector",
"{",
"conns",
":",
"map",
"[",
"string",
"]",
"*",
"cachedConn",
"{",
"}",
",",
"index",
":",
"map",
"[",
"*",
"grpc",
".",
"ClientConn",
"]",
"*",
"cachedConn",
"{",
"}",
",",
"janitorDone",
":",
"make",
"(",
"chan",
"bool",
",",
"1",
")",
",",
"janitorClosed",
":",
"make",
"(",
"chan",
"bool",
",",
"1",
")",
",",
"sweepTime",
":",
"sweepTime",
",",
"idleTime",
":",
"idleTime",
",",
"}",
"\n\n",
"// cc.janitorClosed determines if a goroutine needs to be spun up.",
"// The janitor is able to shut itself down when it has no connection to monitor.",
"// When it shuts itself down, it pushes a value onto janitorClosed. We initialize",
"// the go chan with a bootstrap value so that cachingConnector spins up the",
"// goroutine on first usage.",
"cc",
".",
"janitorClosed",
"<-",
"true",
"\n",
"return",
"&",
"cc",
"\n",
"}"
] |
// NewCachingConnector creates a GRPC connection cache. The cache is governed by
// sweepTime and idleTime.
|
[
"NewCachingConnector",
"creates",
"a",
"GRPC",
"connection",
"cache",
".",
"The",
"cache",
"is",
"governed",
"by",
"sweepTime",
"and",
"idleTime",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connector.go#L56-L73
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/comm/connector.go
|
Close
|
func (cc *CachingConnector) Close() {
cc.lock.RLock()
// Safety check to see if the connector has been closed. This represents a
// bug in the calling code, but it's not good to panic here.
if cc.janitorDone == nil {
cc.lock.RUnlock()
logger.Warn("Trying to close connector after already closed")
return
}
cc.lock.RUnlock()
logger.Debug("closing caching GRPC connector")
select {
case <-cc.janitorClosed:
logger.Debug("janitor not running")
default:
logger.Debug("janitor running")
cc.janitorDone <- true
cc.waitgroup.Wait()
}
cc.lock.Lock()
defer cc.lock.Unlock()
if len(cc.index) > 0 {
logger.Debugf("flushing connection cache with open connections [%d]", len(cc.index))
} else {
logger.Debug("flushing connection cache")
}
cc.flush()
close(cc.janitorClosed)
close(cc.janitorDone)
cc.janitorDone = nil
}
|
go
|
func (cc *CachingConnector) Close() {
cc.lock.RLock()
// Safety check to see if the connector has been closed. This represents a
// bug in the calling code, but it's not good to panic here.
if cc.janitorDone == nil {
cc.lock.RUnlock()
logger.Warn("Trying to close connector after already closed")
return
}
cc.lock.RUnlock()
logger.Debug("closing caching GRPC connector")
select {
case <-cc.janitorClosed:
logger.Debug("janitor not running")
default:
logger.Debug("janitor running")
cc.janitorDone <- true
cc.waitgroup.Wait()
}
cc.lock.Lock()
defer cc.lock.Unlock()
if len(cc.index) > 0 {
logger.Debugf("flushing connection cache with open connections [%d]", len(cc.index))
} else {
logger.Debug("flushing connection cache")
}
cc.flush()
close(cc.janitorClosed)
close(cc.janitorDone)
cc.janitorDone = nil
}
|
[
"func",
"(",
"cc",
"*",
"CachingConnector",
")",
"Close",
"(",
")",
"{",
"cc",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"// Safety check to see if the connector has been closed. This represents a",
"// bug in the calling code, but it's not good to panic here.",
"if",
"cc",
".",
"janitorDone",
"==",
"nil",
"{",
"cc",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"logger",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"cc",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"logger",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"select",
"{",
"case",
"<-",
"cc",
".",
"janitorClosed",
":",
"logger",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"default",
":",
"logger",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"cc",
".",
"janitorDone",
"<-",
"true",
"\n",
"cc",
".",
"waitgroup",
".",
"Wait",
"(",
")",
"\n",
"}",
"\n\n",
"cc",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cc",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"len",
"(",
"cc",
".",
"index",
")",
">",
"0",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"len",
"(",
"cc",
".",
"index",
")",
")",
"\n",
"}",
"else",
"{",
"logger",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cc",
".",
"flush",
"(",
")",
"\n",
"close",
"(",
"cc",
".",
"janitorClosed",
")",
"\n",
"close",
"(",
"cc",
".",
"janitorDone",
")",
"\n",
"cc",
".",
"janitorDone",
"=",
"nil",
"\n",
"}"
] |
// Close cleans up cached connections.
|
[
"Close",
"cleans",
"up",
"cached",
"connections",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connector.go#L76-L110
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/comm/connector.go
|
DialContext
|
func (cc *CachingConnector) DialContext(ctx context.Context, target string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
logger.Debugf("DialContext: %s", target)
cc.lock.Lock()
c, ok := cc.loadConn(target)
if !ok {
createdConn, err := cc.createConn(ctx, target, opts...)
if err != nil {
cc.lock.Unlock()
return nil, errors.WithMessage(err, "connection creation failed")
}
c = createdConn
}
cc.lock.Unlock()
if err := cc.openConn(ctx, c); err != nil {
cc.lock.Lock()
setClosed(c)
cc.lock.Unlock()
return nil, errors.Errorf("dialing connection timed out [%s]", target)
}
return c.conn, nil
}
|
go
|
func (cc *CachingConnector) DialContext(ctx context.Context, target string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
logger.Debugf("DialContext: %s", target)
cc.lock.Lock()
c, ok := cc.loadConn(target)
if !ok {
createdConn, err := cc.createConn(ctx, target, opts...)
if err != nil {
cc.lock.Unlock()
return nil, errors.WithMessage(err, "connection creation failed")
}
c = createdConn
}
cc.lock.Unlock()
if err := cc.openConn(ctx, c); err != nil {
cc.lock.Lock()
setClosed(c)
cc.lock.Unlock()
return nil, errors.Errorf("dialing connection timed out [%s]", target)
}
return c.conn, nil
}
|
[
"func",
"(",
"cc",
"*",
"CachingConnector",
")",
"DialContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"target",
"string",
",",
"opts",
"...",
"grpc",
".",
"DialOption",
")",
"(",
"*",
"grpc",
".",
"ClientConn",
",",
"error",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"target",
")",
"\n\n",
"cc",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"c",
",",
"ok",
":=",
"cc",
".",
"loadConn",
"(",
"target",
")",
"\n",
"if",
"!",
"ok",
"{",
"createdConn",
",",
"err",
":=",
"cc",
".",
"createConn",
"(",
"ctx",
",",
"target",
",",
"opts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"cc",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"c",
"=",
"createdConn",
"\n",
"}",
"\n\n",
"cc",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"err",
":=",
"cc",
".",
"openConn",
"(",
"ctx",
",",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"cc",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"setClosed",
"(",
"c",
")",
"\n",
"cc",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"target",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"conn",
",",
"nil",
"\n",
"}"
] |
// DialContext is a wrapper for grpc.DialContext where connections are cached.
|
[
"DialContext",
"is",
"a",
"wrapper",
"for",
"grpc",
".",
"DialContext",
"where",
"connections",
"are",
"cached",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connector.go#L113-L136
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/comm/connector.go
|
ReleaseConn
|
func (cc *CachingConnector) ReleaseConn(conn *grpc.ClientConn) {
cc.lock.Lock()
defer cc.lock.Unlock()
// Safety check to see if the connector has been closed. This represents a
// bug in the calling code, but it's not good to panic here.
if cc.janitorDone == nil {
logger.Warn("Trying to release connection after connector closed")
if conn.GetState() != connectivity.Shutdown {
logger.Warn("Connection is not shutdown, trying to close ...")
if err := conn.Close(); err != nil {
logger.Warnf("conn close failed err %s", err)
}
}
return
}
cconn, ok := cc.index[conn]
if !ok {
logger.Warnf("connection not found [%p]", conn)
return
}
logger.Debugf("ReleaseConn [%s]", cconn.target)
setClosed(cconn)
cc.ensureJanitorStarted()
}
|
go
|
func (cc *CachingConnector) ReleaseConn(conn *grpc.ClientConn) {
cc.lock.Lock()
defer cc.lock.Unlock()
// Safety check to see if the connector has been closed. This represents a
// bug in the calling code, but it's not good to panic here.
if cc.janitorDone == nil {
logger.Warn("Trying to release connection after connector closed")
if conn.GetState() != connectivity.Shutdown {
logger.Warn("Connection is not shutdown, trying to close ...")
if err := conn.Close(); err != nil {
logger.Warnf("conn close failed err %s", err)
}
}
return
}
cconn, ok := cc.index[conn]
if !ok {
logger.Warnf("connection not found [%p]", conn)
return
}
logger.Debugf("ReleaseConn [%s]", cconn.target)
setClosed(cconn)
cc.ensureJanitorStarted()
}
|
[
"func",
"(",
"cc",
"*",
"CachingConnector",
")",
"ReleaseConn",
"(",
"conn",
"*",
"grpc",
".",
"ClientConn",
")",
"{",
"cc",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cc",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"// Safety check to see if the connector has been closed. This represents a",
"// bug in the calling code, but it's not good to panic here.",
"if",
"cc",
".",
"janitorDone",
"==",
"nil",
"{",
"logger",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"conn",
".",
"GetState",
"(",
")",
"!=",
"connectivity",
".",
"Shutdown",
"{",
"logger",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"conn",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n\n",
"cconn",
",",
"ok",
":=",
"cc",
".",
"index",
"[",
"conn",
"]",
"\n",
"if",
"!",
"ok",
"{",
"logger",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"conn",
")",
"\n",
"return",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"cconn",
".",
"target",
")",
"\n\n",
"setClosed",
"(",
"cconn",
")",
"\n\n",
"cc",
".",
"ensureJanitorStarted",
"(",
")",
"\n",
"}"
] |
// ReleaseConn notifies the cache that the connection is no longer in use.
|
[
"ReleaseConn",
"notifies",
"the",
"cache",
"that",
"the",
"connection",
"is",
"no",
"longer",
"in",
"use",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/connector.go#L139-L167
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/channel/invoke/selectendorsehandler.go
|
NewSelectAndEndorseHandler
|
func NewSelectAndEndorseHandler(next ...Handler) Handler {
return &SelectAndEndorseHandler{
EndorsementHandler: NewEndorsementHandler(),
next: getNext(next),
}
}
|
go
|
func NewSelectAndEndorseHandler(next ...Handler) Handler {
return &SelectAndEndorseHandler{
EndorsementHandler: NewEndorsementHandler(),
next: getNext(next),
}
}
|
[
"func",
"NewSelectAndEndorseHandler",
"(",
"next",
"...",
"Handler",
")",
"Handler",
"{",
"return",
"&",
"SelectAndEndorseHandler",
"{",
"EndorsementHandler",
":",
"NewEndorsementHandler",
"(",
")",
",",
"next",
":",
"getNext",
"(",
"next",
")",
",",
"}",
"\n",
"}"
] |
// NewSelectAndEndorseHandler returns a new SelectAndEndorseHandler
|
[
"NewSelectAndEndorseHandler",
"returns",
"a",
"new",
"SelectAndEndorseHandler"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/selectendorsehandler.go#L39-L44
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/channel/invoke/selectendorsehandler.go
|
Handle
|
func (e *SelectAndEndorseHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
var ccCalls []*fab.ChaincodeCall
targets := requestContext.Opts.Targets
if len(targets) == 0 {
var err error
ccCalls, requestContext.Opts.Targets, err = getEndorsers(requestContext, clientContext)
if err != nil {
requestContext.Error = err
return
}
}
e.EndorsementHandler.Handle(requestContext, clientContext)
if requestContext.Error != nil {
return
}
if len(targets) == 0 && len(requestContext.Response.Responses) > 0 {
additionalEndorsers, err := getAdditionalEndorsers(requestContext, clientContext, ccCalls)
if err != nil {
// Log a warning. No need to fail the endorsement. Use the responses collected so far,
// which may be sufficient to satisfy the chaincode policy.
logger.Warnf("error getting additional endorsers: %s", err)
} else {
if len(additionalEndorsers) > 0 {
requestContext.Opts.Targets = additionalEndorsers
logger.Debugf("...getting additional endorsements from %d target(s)", len(additionalEndorsers))
additionalResponses, err := clientContext.Transactor.SendTransactionProposal(requestContext.Response.Proposal, peer.PeersToTxnProcessors(additionalEndorsers))
if err != nil {
requestContext.Error = errors.WithMessage(err, "error sending transaction proposal")
return
}
// Add the new endorsements to the list of responses
requestContext.Response.Responses = append(requestContext.Response.Responses, additionalResponses...)
} else {
logger.Debugf("...no additional endorsements are required.")
}
}
}
if e.next != nil {
e.next.Handle(requestContext, clientContext)
}
}
|
go
|
func (e *SelectAndEndorseHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
var ccCalls []*fab.ChaincodeCall
targets := requestContext.Opts.Targets
if len(targets) == 0 {
var err error
ccCalls, requestContext.Opts.Targets, err = getEndorsers(requestContext, clientContext)
if err != nil {
requestContext.Error = err
return
}
}
e.EndorsementHandler.Handle(requestContext, clientContext)
if requestContext.Error != nil {
return
}
if len(targets) == 0 && len(requestContext.Response.Responses) > 0 {
additionalEndorsers, err := getAdditionalEndorsers(requestContext, clientContext, ccCalls)
if err != nil {
// Log a warning. No need to fail the endorsement. Use the responses collected so far,
// which may be sufficient to satisfy the chaincode policy.
logger.Warnf("error getting additional endorsers: %s", err)
} else {
if len(additionalEndorsers) > 0 {
requestContext.Opts.Targets = additionalEndorsers
logger.Debugf("...getting additional endorsements from %d target(s)", len(additionalEndorsers))
additionalResponses, err := clientContext.Transactor.SendTransactionProposal(requestContext.Response.Proposal, peer.PeersToTxnProcessors(additionalEndorsers))
if err != nil {
requestContext.Error = errors.WithMessage(err, "error sending transaction proposal")
return
}
// Add the new endorsements to the list of responses
requestContext.Response.Responses = append(requestContext.Response.Responses, additionalResponses...)
} else {
logger.Debugf("...no additional endorsements are required.")
}
}
}
if e.next != nil {
e.next.Handle(requestContext, clientContext)
}
}
|
[
"func",
"(",
"e",
"*",
"SelectAndEndorseHandler",
")",
"Handle",
"(",
"requestContext",
"*",
"RequestContext",
",",
"clientContext",
"*",
"ClientContext",
")",
"{",
"var",
"ccCalls",
"[",
"]",
"*",
"fab",
".",
"ChaincodeCall",
"\n",
"targets",
":=",
"requestContext",
".",
"Opts",
".",
"Targets",
"\n",
"if",
"len",
"(",
"targets",
")",
"==",
"0",
"{",
"var",
"err",
"error",
"\n",
"ccCalls",
",",
"requestContext",
".",
"Opts",
".",
"Targets",
",",
"err",
"=",
"getEndorsers",
"(",
"requestContext",
",",
"clientContext",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"requestContext",
".",
"Error",
"=",
"err",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"e",
".",
"EndorsementHandler",
".",
"Handle",
"(",
"requestContext",
",",
"clientContext",
")",
"\n\n",
"if",
"requestContext",
".",
"Error",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"targets",
")",
"==",
"0",
"&&",
"len",
"(",
"requestContext",
".",
"Response",
".",
"Responses",
")",
">",
"0",
"{",
"additionalEndorsers",
",",
"err",
":=",
"getAdditionalEndorsers",
"(",
"requestContext",
",",
"clientContext",
",",
"ccCalls",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// Log a warning. No need to fail the endorsement. Use the responses collected so far,",
"// which may be sufficient to satisfy the chaincode policy.",
"logger",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"if",
"len",
"(",
"additionalEndorsers",
")",
">",
"0",
"{",
"requestContext",
".",
"Opts",
".",
"Targets",
"=",
"additionalEndorsers",
"\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"len",
"(",
"additionalEndorsers",
")",
")",
"\n",
"additionalResponses",
",",
"err",
":=",
"clientContext",
".",
"Transactor",
".",
"SendTransactionProposal",
"(",
"requestContext",
".",
"Response",
".",
"Proposal",
",",
"peer",
".",
"PeersToTxnProcessors",
"(",
"additionalEndorsers",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"requestContext",
".",
"Error",
"=",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Add the new endorsements to the list of responses",
"requestContext",
".",
"Response",
".",
"Responses",
"=",
"append",
"(",
"requestContext",
".",
"Response",
".",
"Responses",
",",
"additionalResponses",
"...",
")",
"\n",
"}",
"else",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"e",
".",
"next",
"!=",
"nil",
"{",
"e",
".",
"next",
".",
"Handle",
"(",
"requestContext",
",",
"clientContext",
")",
"\n",
"}",
"\n",
"}"
] |
// Handle selects endorsers and sends proposals to the endorsers
|
[
"Handle",
"selects",
"endorsers",
"and",
"sends",
"proposals",
"to",
"the",
"endorsers"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/selectendorsehandler.go#L47-L92
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/channel/invoke/selectendorsehandler.go
|
NewChainedCCFilter
|
func NewChainedCCFilter(filters ...CCFilter) CCFilter {
return func(ccID string) bool {
for _, filter := range filters {
if !filter(ccID) {
return false
}
}
return true
}
}
|
go
|
func NewChainedCCFilter(filters ...CCFilter) CCFilter {
return func(ccID string) bool {
for _, filter := range filters {
if !filter(ccID) {
return false
}
}
return true
}
}
|
[
"func",
"NewChainedCCFilter",
"(",
"filters",
"...",
"CCFilter",
")",
"CCFilter",
"{",
"return",
"func",
"(",
"ccID",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"filter",
":=",
"range",
"filters",
"{",
"if",
"!",
"filter",
"(",
"ccID",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"}"
] |
//NewChainedCCFilter returns a chaincode filter that chains
//multiple filters together. False is returned if at least one
//of the filters in the chain returns false.
|
[
"NewChainedCCFilter",
"returns",
"a",
"chaincode",
"filter",
"that",
"chains",
"multiple",
"filters",
"together",
".",
"False",
"is",
"returned",
"if",
"at",
"least",
"one",
"of",
"the",
"filters",
"in",
"the",
"chain",
"returns",
"false",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/selectendorsehandler.go#L97-L106
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/channel/invoke/selectendorsehandler.go
|
getCCCall
|
func getCCCall(invocChain []*fab.ChaincodeCall, ccID string) (*fab.ChaincodeCall, bool) {
for _, ccCall := range invocChain {
if ccCall.ID == ccID {
return ccCall, true
}
}
return nil, false
}
|
go
|
func getCCCall(invocChain []*fab.ChaincodeCall, ccID string) (*fab.ChaincodeCall, bool) {
for _, ccCall := range invocChain {
if ccCall.ID == ccID {
return ccCall, true
}
}
return nil, false
}
|
[
"func",
"getCCCall",
"(",
"invocChain",
"[",
"]",
"*",
"fab",
".",
"ChaincodeCall",
",",
"ccID",
"string",
")",
"(",
"*",
"fab",
".",
"ChaincodeCall",
",",
"bool",
")",
"{",
"for",
"_",
",",
"ccCall",
":=",
"range",
"invocChain",
"{",
"if",
"ccCall",
".",
"ID",
"==",
"ccID",
"{",
"return",
"ccCall",
",",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"false",
"\n",
"}"
] |
// getCC returns the ChaincodeCall from the invocation chain that matches the chaincode ID or
// returns nil if the ChaincodeCall is not found.
|
[
"getCC",
"returns",
"the",
"ChaincodeCall",
"from",
"the",
"invocation",
"chain",
"that",
"matches",
"the",
"chaincode",
"ID",
"or",
"returns",
"nil",
"if",
"the",
"ChaincodeCall",
"is",
"not",
"found",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/selectendorsehandler.go#L264-L271
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/channel/invoke/selectendorsehandler.go
|
merge
|
func merge(c1 *fab.ChaincodeCall, c2 *fab.ChaincodeCall) (*fab.ChaincodeCall, bool) {
c := &fab.ChaincodeCall{ID: c1.ID, Collections: c1.Collections}
merged := false
for _, coll := range c2.Collections {
if !contains(c.Collections, coll) {
c.Collections = append(c.Collections, coll)
merged = true
}
}
return c, merged
}
|
go
|
func merge(c1 *fab.ChaincodeCall, c2 *fab.ChaincodeCall) (*fab.ChaincodeCall, bool) {
c := &fab.ChaincodeCall{ID: c1.ID, Collections: c1.Collections}
merged := false
for _, coll := range c2.Collections {
if !contains(c.Collections, coll) {
c.Collections = append(c.Collections, coll)
merged = true
}
}
return c, merged
}
|
[
"func",
"merge",
"(",
"c1",
"*",
"fab",
".",
"ChaincodeCall",
",",
"c2",
"*",
"fab",
".",
"ChaincodeCall",
")",
"(",
"*",
"fab",
".",
"ChaincodeCall",
",",
"bool",
")",
"{",
"c",
":=",
"&",
"fab",
".",
"ChaincodeCall",
"{",
"ID",
":",
"c1",
".",
"ID",
",",
"Collections",
":",
"c1",
".",
"Collections",
"}",
"\n",
"merged",
":=",
"false",
"\n",
"for",
"_",
",",
"coll",
":=",
"range",
"c2",
".",
"Collections",
"{",
"if",
"!",
"contains",
"(",
"c",
".",
"Collections",
",",
"coll",
")",
"{",
"c",
".",
"Collections",
"=",
"append",
"(",
"c",
".",
"Collections",
",",
"coll",
")",
"\n",
"merged",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"c",
",",
"merged",
"\n",
"}"
] |
// merge merges the collections from c1 and c2 and returns the resulting ChaincodeCall.
// true is returned if a merge was necessary; false is returned if the two ChaincodeCalls were the same.
|
[
"merge",
"merges",
"the",
"collections",
"from",
"c1",
"and",
"c2",
"and",
"returns",
"the",
"resulting",
"ChaincodeCall",
".",
"true",
"is",
"returned",
"if",
"a",
"merge",
"was",
"necessary",
";",
"false",
"is",
"returned",
"if",
"the",
"two",
"ChaincodeCalls",
"were",
"the",
"same",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/selectendorsehandler.go#L275-L285
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/channel/invoke/selectendorsehandler.go
|
prioritizePeers
|
func prioritizePeers(peers []fab.Peer) selectopts.PrioritySelector {
return func(peer1, peer2 fab.Peer) int {
hasPeer1 := containsPeer(peers, peer1)
hasPeer2 := containsPeer(peers, peer2)
if hasPeer1 && hasPeer2 {
return 0
}
if hasPeer1 {
return 1
}
if hasPeer2 {
return -1
}
return 0
}
}
|
go
|
func prioritizePeers(peers []fab.Peer) selectopts.PrioritySelector {
return func(peer1, peer2 fab.Peer) int {
hasPeer1 := containsPeer(peers, peer1)
hasPeer2 := containsPeer(peers, peer2)
if hasPeer1 && hasPeer2 {
return 0
}
if hasPeer1 {
return 1
}
if hasPeer2 {
return -1
}
return 0
}
}
|
[
"func",
"prioritizePeers",
"(",
"peers",
"[",
"]",
"fab",
".",
"Peer",
")",
"selectopts",
".",
"PrioritySelector",
"{",
"return",
"func",
"(",
"peer1",
",",
"peer2",
"fab",
".",
"Peer",
")",
"int",
"{",
"hasPeer1",
":=",
"containsPeer",
"(",
"peers",
",",
"peer1",
")",
"\n",
"hasPeer2",
":=",
"containsPeer",
"(",
"peers",
",",
"peer2",
")",
"\n\n",
"if",
"hasPeer1",
"&&",
"hasPeer2",
"{",
"return",
"0",
"\n",
"}",
"\n",
"if",
"hasPeer1",
"{",
"return",
"1",
"\n",
"}",
"\n",
"if",
"hasPeer2",
"{",
"return",
"-",
"1",
"\n",
"}",
"\n",
"return",
"0",
"\n",
"}",
"\n",
"}"
] |
// prioritizePeers is a priority selector that gives priority to the peers that are in the given set
|
[
"prioritizePeers",
"is",
"a",
"priority",
"selector",
"that",
"gives",
"priority",
"to",
"the",
"peers",
"that",
"are",
"in",
"the",
"given",
"set"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/selectendorsehandler.go#L297-L313
|
train
|
hyperledger/fabric-sdk-go
|
pkg/util/concurrent/lazyref/lazyref.go
|
New
|
func New(initializer Initializer, opts ...options.Opt) *Reference {
return NewWithData(func(interface{}) (interface{}, error) {
return initializer()
}, opts...)
}
|
go
|
func New(initializer Initializer, opts ...options.Opt) *Reference {
return NewWithData(func(interface{}) (interface{}, error) {
return initializer()
}, opts...)
}
|
[
"func",
"New",
"(",
"initializer",
"Initializer",
",",
"opts",
"...",
"options",
".",
"Opt",
")",
"*",
"Reference",
"{",
"return",
"NewWithData",
"(",
"func",
"(",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"initializer",
"(",
")",
"\n",
"}",
",",
"opts",
"...",
")",
"\n",
"}"
] |
// New creates a new reference
|
[
"New",
"creates",
"a",
"new",
"reference"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/util/concurrent/lazyref/lazyref.go#L88-L92
|
train
|
hyperledger/fabric-sdk-go
|
pkg/util/concurrent/lazyref/lazyref.go
|
NewWithData
|
func NewWithData(initializer InitializerWithData, opts ...options.Opt) *Reference {
lazyRef := &Reference{
params: params{
initialInit: InitOnFirstAccess,
},
initializer: initializer,
}
options.Apply(lazyRef, opts)
if lazyRef.expirationProvider != nil {
// This is an expiring reference. After the initializer is
// called, set a timer that will call the expiration handler.
initializer := lazyRef.initializer
initialExpiration := lazyRef.expirationProvider()
lazyRef.initializer = func(data interface{}) (interface{}, error) {
value, err := initializer(data)
if err == nil {
lazyRef.ensureTimerStarted(initialExpiration)
}
return value, err
}
lazyRef.closech = make(chan bool, 1)
if lazyRef.expirationHandler == nil {
if lazyRef.expiryType == Refreshing {
lazyRef.expirationHandler = lazyRef.refreshValue
} else {
lazyRef.expirationHandler = lazyRef.resetValue
}
}
if lazyRef.initialInit >= 0 {
lazyRef.ensureTimerStarted(lazyRef.initialInit)
}
}
return lazyRef
}
|
go
|
func NewWithData(initializer InitializerWithData, opts ...options.Opt) *Reference {
lazyRef := &Reference{
params: params{
initialInit: InitOnFirstAccess,
},
initializer: initializer,
}
options.Apply(lazyRef, opts)
if lazyRef.expirationProvider != nil {
// This is an expiring reference. After the initializer is
// called, set a timer that will call the expiration handler.
initializer := lazyRef.initializer
initialExpiration := lazyRef.expirationProvider()
lazyRef.initializer = func(data interface{}) (interface{}, error) {
value, err := initializer(data)
if err == nil {
lazyRef.ensureTimerStarted(initialExpiration)
}
return value, err
}
lazyRef.closech = make(chan bool, 1)
if lazyRef.expirationHandler == nil {
if lazyRef.expiryType == Refreshing {
lazyRef.expirationHandler = lazyRef.refreshValue
} else {
lazyRef.expirationHandler = lazyRef.resetValue
}
}
if lazyRef.initialInit >= 0 {
lazyRef.ensureTimerStarted(lazyRef.initialInit)
}
}
return lazyRef
}
|
[
"func",
"NewWithData",
"(",
"initializer",
"InitializerWithData",
",",
"opts",
"...",
"options",
".",
"Opt",
")",
"*",
"Reference",
"{",
"lazyRef",
":=",
"&",
"Reference",
"{",
"params",
":",
"params",
"{",
"initialInit",
":",
"InitOnFirstAccess",
",",
"}",
",",
"initializer",
":",
"initializer",
",",
"}",
"\n\n",
"options",
".",
"Apply",
"(",
"lazyRef",
",",
"opts",
")",
"\n\n",
"if",
"lazyRef",
".",
"expirationProvider",
"!=",
"nil",
"{",
"// This is an expiring reference. After the initializer is",
"// called, set a timer that will call the expiration handler.",
"initializer",
":=",
"lazyRef",
".",
"initializer",
"\n",
"initialExpiration",
":=",
"lazyRef",
".",
"expirationProvider",
"(",
")",
"\n",
"lazyRef",
".",
"initializer",
"=",
"func",
"(",
"data",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"value",
",",
"err",
":=",
"initializer",
"(",
"data",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"lazyRef",
".",
"ensureTimerStarted",
"(",
"initialExpiration",
")",
"\n",
"}",
"\n",
"return",
"value",
",",
"err",
"\n",
"}",
"\n\n",
"lazyRef",
".",
"closech",
"=",
"make",
"(",
"chan",
"bool",
",",
"1",
")",
"\n\n",
"if",
"lazyRef",
".",
"expirationHandler",
"==",
"nil",
"{",
"if",
"lazyRef",
".",
"expiryType",
"==",
"Refreshing",
"{",
"lazyRef",
".",
"expirationHandler",
"=",
"lazyRef",
".",
"refreshValue",
"\n",
"}",
"else",
"{",
"lazyRef",
".",
"expirationHandler",
"=",
"lazyRef",
".",
"resetValue",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"lazyRef",
".",
"initialInit",
">=",
"0",
"{",
"lazyRef",
".",
"ensureTimerStarted",
"(",
"lazyRef",
".",
"initialInit",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"lazyRef",
"\n",
"}"
] |
// NewWithData creates a new reference where data is passed from the Get
// function to the initializer. This is useful for refreshing the reference
// with dynamic data.
|
[
"NewWithData",
"creates",
"a",
"new",
"reference",
"where",
"data",
"is",
"passed",
"from",
"the",
"Get",
"function",
"to",
"the",
"initializer",
".",
"This",
"is",
"useful",
"for",
"refreshing",
"the",
"reference",
"with",
"dynamic",
"data",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/util/concurrent/lazyref/lazyref.go#L97-L136
|
train
|
hyperledger/fabric-sdk-go
|
pkg/util/concurrent/lazyref/lazyref.go
|
Get
|
func (r *Reference) Get(data ...interface{}) (interface{}, error) {
if r.IsClosed() {
return nil, errors.New("reference is already closed")
}
// Try outside of a lock
if value, ok := r.get(); ok {
return value, nil
}
r.lock.Lock()
defer r.lock.Unlock()
// Try again inside the lock
if value, ok := r.get(); ok {
return value, nil
}
// Value hasn't been set yet
value, err := r.initializer(first(data))
if err != nil {
return nil, err
}
r.set(value)
return value, nil
}
|
go
|
func (r *Reference) Get(data ...interface{}) (interface{}, error) {
if r.IsClosed() {
return nil, errors.New("reference is already closed")
}
// Try outside of a lock
if value, ok := r.get(); ok {
return value, nil
}
r.lock.Lock()
defer r.lock.Unlock()
// Try again inside the lock
if value, ok := r.get(); ok {
return value, nil
}
// Value hasn't been set yet
value, err := r.initializer(first(data))
if err != nil {
return nil, err
}
r.set(value)
return value, nil
}
|
[
"func",
"(",
"r",
"*",
"Reference",
")",
"Get",
"(",
"data",
"...",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"r",
".",
"IsClosed",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Try outside of a lock",
"if",
"value",
",",
"ok",
":=",
"r",
".",
"get",
"(",
")",
";",
"ok",
"{",
"return",
"value",
",",
"nil",
"\n",
"}",
"\n\n",
"r",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"// Try again inside the lock",
"if",
"value",
",",
"ok",
":=",
"r",
".",
"get",
"(",
")",
";",
"ok",
"{",
"return",
"value",
",",
"nil",
"\n",
"}",
"\n\n",
"// Value hasn't been set yet",
"value",
",",
"err",
":=",
"r",
".",
"initializer",
"(",
"first",
"(",
"data",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"r",
".",
"set",
"(",
"value",
")",
"\n\n",
"return",
"value",
",",
"nil",
"\n",
"}"
] |
// Get returns the value, or an error if the initialiser returned an error.
|
[
"Get",
"returns",
"the",
"value",
"or",
"an",
"error",
"if",
"the",
"initialiser",
"returned",
"an",
"error",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/util/concurrent/lazyref/lazyref.go#L144-L170
|
train
|
hyperledger/fabric-sdk-go
|
pkg/util/concurrent/lazyref/lazyref.go
|
MustGet
|
func (r *Reference) MustGet() interface{} {
value, err := r.Get()
if err != nil {
panic(fmt.Sprintf("error returned from Get: %s", err))
}
return value
}
|
go
|
func (r *Reference) MustGet() interface{} {
value, err := r.Get()
if err != nil {
panic(fmt.Sprintf("error returned from Get: %s", err))
}
return value
}
|
[
"func",
"(",
"r",
"*",
"Reference",
")",
"MustGet",
"(",
")",
"interface",
"{",
"}",
"{",
"value",
",",
"err",
":=",
"r",
".",
"Get",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"return",
"value",
"\n",
"}"
] |
// MustGet returns the value. If an error is returned
// during initialization of the value then this function
// will panic.
|
[
"MustGet",
"returns",
"the",
"value",
".",
"If",
"an",
"error",
"is",
"returned",
"during",
"initialization",
"of",
"the",
"value",
"then",
"this",
"function",
"will",
"panic",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/util/concurrent/lazyref/lazyref.go#L175-L181
|
train
|
hyperledger/fabric-sdk-go
|
pkg/core/logging/metadata/level.go
|
GetLevel
|
func (l *ModuleLevels) GetLevel(module string) api.Level {
level, exists := l.levels[module]
if !exists {
level, exists = l.levels[""]
// no configuration exists, default to info
if !exists {
level = api.INFO
}
}
return level
}
|
go
|
func (l *ModuleLevels) GetLevel(module string) api.Level {
level, exists := l.levels[module]
if !exists {
level, exists = l.levels[""]
// no configuration exists, default to info
if !exists {
level = api.INFO
}
}
return level
}
|
[
"func",
"(",
"l",
"*",
"ModuleLevels",
")",
"GetLevel",
"(",
"module",
"string",
")",
"api",
".",
"Level",
"{",
"level",
",",
"exists",
":=",
"l",
".",
"levels",
"[",
"module",
"]",
"\n",
"if",
"!",
"exists",
"{",
"level",
",",
"exists",
"=",
"l",
".",
"levels",
"[",
"\"",
"\"",
"]",
"\n",
"// no configuration exists, default to info",
"if",
"!",
"exists",
"{",
"level",
"=",
"api",
".",
"INFO",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"level",
"\n",
"}"
] |
// GetLevel returns the log level for the given module.
|
[
"GetLevel",
"returns",
"the",
"log",
"level",
"for",
"the",
"given",
"module",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/metadata/level.go#L17-L27
|
train
|
hyperledger/fabric-sdk-go
|
pkg/core/logging/metadata/level.go
|
SetLevel
|
func (l *ModuleLevels) SetLevel(module string, level api.Level) {
if l.levels == nil {
l.levels = make(map[string]api.Level)
}
l.levels[module] = level
}
|
go
|
func (l *ModuleLevels) SetLevel(module string, level api.Level) {
if l.levels == nil {
l.levels = make(map[string]api.Level)
}
l.levels[module] = level
}
|
[
"func",
"(",
"l",
"*",
"ModuleLevels",
")",
"SetLevel",
"(",
"module",
"string",
",",
"level",
"api",
".",
"Level",
")",
"{",
"if",
"l",
".",
"levels",
"==",
"nil",
"{",
"l",
".",
"levels",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"api",
".",
"Level",
")",
"\n",
"}",
"\n",
"l",
".",
"levels",
"[",
"module",
"]",
"=",
"level",
"\n",
"}"
] |
// SetLevel sets the log level for the given module.
|
[
"SetLevel",
"sets",
"the",
"log",
"level",
"for",
"the",
"given",
"module",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/metadata/level.go#L30-L35
|
train
|
hyperledger/fabric-sdk-go
|
pkg/core/logging/metadata/level.go
|
IsEnabledFor
|
func (l *ModuleLevels) IsEnabledFor(module string, level api.Level) bool {
return level <= l.GetLevel(module)
}
|
go
|
func (l *ModuleLevels) IsEnabledFor(module string, level api.Level) bool {
return level <= l.GetLevel(module)
}
|
[
"func",
"(",
"l",
"*",
"ModuleLevels",
")",
"IsEnabledFor",
"(",
"module",
"string",
",",
"level",
"api",
".",
"Level",
")",
"bool",
"{",
"return",
"level",
"<=",
"l",
".",
"GetLevel",
"(",
"module",
")",
"\n",
"}"
] |
// IsEnabledFor will return true if logging is enabled for the given module.
|
[
"IsEnabledFor",
"will",
"return",
"true",
"if",
"logging",
"is",
"enabled",
"for",
"the",
"given",
"module",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/logging/metadata/level.go#L38-L40
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/chconfig/reference.go
|
NewRef
|
func NewRef(ctx fab.ClientContext, pvdr Provider, channel string, opts ...options.Opt) *Ref {
params := newDefaultParams()
options.Apply(params, opts)
cfgRef := &Ref{
pvdr: pvdr,
ctx: ctx,
channelID: channel,
errHandler: params.errHandler,
}
cfgRef.Reference = lazyref.New(
cfgRef.initializer(),
lazyref.WithRefreshInterval(lazyref.InitImmediately, params.refreshInterval),
)
return cfgRef
}
|
go
|
func NewRef(ctx fab.ClientContext, pvdr Provider, channel string, opts ...options.Opt) *Ref {
params := newDefaultParams()
options.Apply(params, opts)
cfgRef := &Ref{
pvdr: pvdr,
ctx: ctx,
channelID: channel,
errHandler: params.errHandler,
}
cfgRef.Reference = lazyref.New(
cfgRef.initializer(),
lazyref.WithRefreshInterval(lazyref.InitImmediately, params.refreshInterval),
)
return cfgRef
}
|
[
"func",
"NewRef",
"(",
"ctx",
"fab",
".",
"ClientContext",
",",
"pvdr",
"Provider",
",",
"channel",
"string",
",",
"opts",
"...",
"options",
".",
"Opt",
")",
"*",
"Ref",
"{",
"params",
":=",
"newDefaultParams",
"(",
")",
"\n",
"options",
".",
"Apply",
"(",
"params",
",",
"opts",
")",
"\n\n",
"cfgRef",
":=",
"&",
"Ref",
"{",
"pvdr",
":",
"pvdr",
",",
"ctx",
":",
"ctx",
",",
"channelID",
":",
"channel",
",",
"errHandler",
":",
"params",
".",
"errHandler",
",",
"}",
"\n\n",
"cfgRef",
".",
"Reference",
"=",
"lazyref",
".",
"New",
"(",
"cfgRef",
".",
"initializer",
"(",
")",
",",
"lazyref",
".",
"WithRefreshInterval",
"(",
"lazyref",
".",
"InitImmediately",
",",
"params",
".",
"refreshInterval",
")",
",",
")",
"\n\n",
"return",
"cfgRef",
"\n",
"}"
] |
// NewRef returns a new channel config reference
|
[
"NewRef",
"returns",
"a",
"new",
"channel",
"config",
"reference"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/chconfig/reference.go#L30-L47
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/client.go
|
New
|
func New(dispatcher eventservice.Dispatcher, opts ...options.Opt) *Client {
params := defaultParams()
options.Apply(params, opts)
return &Client{
Service: eventservice.New(dispatcher, opts...),
params: *params,
connectionState: int32(Disconnected),
}
}
|
go
|
func New(dispatcher eventservice.Dispatcher, opts ...options.Opt) *Client {
params := defaultParams()
options.Apply(params, opts)
return &Client{
Service: eventservice.New(dispatcher, opts...),
params: *params,
connectionState: int32(Disconnected),
}
}
|
[
"func",
"New",
"(",
"dispatcher",
"eventservice",
".",
"Dispatcher",
",",
"opts",
"...",
"options",
".",
"Opt",
")",
"*",
"Client",
"{",
"params",
":=",
"defaultParams",
"(",
")",
"\n",
"options",
".",
"Apply",
"(",
"params",
",",
"opts",
")",
"\n\n",
"return",
"&",
"Client",
"{",
"Service",
":",
"eventservice",
".",
"New",
"(",
"dispatcher",
",",
"opts",
"...",
")",
",",
"params",
":",
"*",
"params",
",",
"connectionState",
":",
"int32",
"(",
"Disconnected",
")",
",",
"}",
"\n",
"}"
] |
// New returns a new event client
|
[
"New",
"returns",
"a",
"new",
"event",
"client"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/client.go#L55-L64
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/client.go
|
SetAfterConnectHandler
|
func (c *Client) SetAfterConnectHandler(h handler) {
c.Lock()
defer c.Unlock()
c.afterConnect = h
}
|
go
|
func (c *Client) SetAfterConnectHandler(h handler) {
c.Lock()
defer c.Unlock()
c.afterConnect = h
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"SetAfterConnectHandler",
"(",
"h",
"handler",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"afterConnect",
"=",
"h",
"\n",
"}"
] |
// SetAfterConnectHandler registers a handler that is called
// after the client connects to the event server. This allows for
// custom code to be executed for a particular
// event client implementation.
|
[
"SetAfterConnectHandler",
"registers",
"a",
"handler",
"that",
"is",
"called",
"after",
"the",
"client",
"connects",
"to",
"the",
"event",
"server",
".",
"This",
"allows",
"for",
"custom",
"code",
"to",
"be",
"executed",
"for",
"a",
"particular",
"event",
"client",
"implementation",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/client.go#L70-L74
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/client.go
|
SetBeforeReconnectHandler
|
func (c *Client) SetBeforeReconnectHandler(h handler) {
c.Lock()
defer c.Unlock()
c.beforeReconnect = h
}
|
go
|
func (c *Client) SetBeforeReconnectHandler(h handler) {
c.Lock()
defer c.Unlock()
c.beforeReconnect = h
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"SetBeforeReconnectHandler",
"(",
"h",
"handler",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"beforeReconnect",
"=",
"h",
"\n",
"}"
] |
// SetBeforeReconnectHandler registers a handler that will be called
// before retrying to reconnect to the event server. This allows for
// custom code to be executed for a particular event client implementation.
|
[
"SetBeforeReconnectHandler",
"registers",
"a",
"handler",
"that",
"will",
"be",
"called",
"before",
"retrying",
"to",
"reconnect",
"to",
"the",
"event",
"server",
".",
"This",
"allows",
"for",
"custom",
"code",
"to",
"be",
"executed",
"for",
"a",
"particular",
"event",
"client",
"implementation",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/client.go#L85-L89
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/client.go
|
Connect
|
func (c *Client) Connect() error {
if c.maxConnAttempts == 1 {
return c.connect()
}
return c.connectWithRetry(c.maxConnAttempts, c.timeBetweenConnAttempts)
}
|
go
|
func (c *Client) Connect() error {
if c.maxConnAttempts == 1 {
return c.connect()
}
return c.connectWithRetry(c.maxConnAttempts, c.timeBetweenConnAttempts)
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"Connect",
"(",
")",
"error",
"{",
"if",
"c",
".",
"maxConnAttempts",
"==",
"1",
"{",
"return",
"c",
".",
"connect",
"(",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"connectWithRetry",
"(",
"c",
".",
"maxConnAttempts",
",",
"c",
".",
"timeBetweenConnAttempts",
")",
"\n",
"}"
] |
// Connect connects to the peer and registers for events on a particular channel.
|
[
"Connect",
"connects",
"to",
"the",
"peer",
"and",
"registers",
"for",
"events",
"on",
"a",
"particular",
"channel",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/client.go#L98-L103
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/client.go
|
CloseIfIdle
|
func (c *Client) CloseIfIdle() bool {
logger.Debug("Attempting to close event client...")
// Check if there are any outstanding registrations
regInfoCh := make(chan *esdispatcher.RegistrationInfo)
err := c.Submit(esdispatcher.NewRegistrationInfoEvent(regInfoCh))
if err != nil {
logger.Debugf("Submit failed %s", err)
return false
}
regInfo := <-regInfoCh
logger.Debugf("Outstanding registrations: %d", regInfo.TotalRegistrations)
if regInfo.TotalRegistrations > 0 {
logger.Debugf("Cannot stop client since there are %d outstanding registrations", regInfo.TotalRegistrations)
return false
}
c.Close()
return true
}
|
go
|
func (c *Client) CloseIfIdle() bool {
logger.Debug("Attempting to close event client...")
// Check if there are any outstanding registrations
regInfoCh := make(chan *esdispatcher.RegistrationInfo)
err := c.Submit(esdispatcher.NewRegistrationInfoEvent(regInfoCh))
if err != nil {
logger.Debugf("Submit failed %s", err)
return false
}
regInfo := <-regInfoCh
logger.Debugf("Outstanding registrations: %d", regInfo.TotalRegistrations)
if regInfo.TotalRegistrations > 0 {
logger.Debugf("Cannot stop client since there are %d outstanding registrations", regInfo.TotalRegistrations)
return false
}
c.Close()
return true
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"CloseIfIdle",
"(",
")",
"bool",
"{",
"logger",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"// Check if there are any outstanding registrations",
"regInfoCh",
":=",
"make",
"(",
"chan",
"*",
"esdispatcher",
".",
"RegistrationInfo",
")",
"\n",
"err",
":=",
"c",
".",
"Submit",
"(",
"esdispatcher",
".",
"NewRegistrationInfoEvent",
"(",
"regInfoCh",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"regInfo",
":=",
"<-",
"regInfoCh",
"\n\n",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"regInfo",
".",
"TotalRegistrations",
")",
"\n\n",
"if",
"regInfo",
".",
"TotalRegistrations",
">",
"0",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"regInfo",
".",
"TotalRegistrations",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n\n",
"c",
".",
"Close",
"(",
")",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// CloseIfIdle closes the connection to the event server only if there are no outstanding
// registrations.
// Returns true if the client was closed. In this case the client may no longer be used.
// A return value of false indicates that the client could not be closed since
// there was at least one registration.
|
[
"CloseIfIdle",
"closes",
"the",
"connection",
"to",
"the",
"event",
"server",
"only",
"if",
"there",
"are",
"no",
"outstanding",
"registrations",
".",
"Returns",
"true",
"if",
"the",
"client",
"was",
"closed",
".",
"In",
"this",
"case",
"the",
"client",
"may",
"no",
"longer",
"be",
"used",
".",
"A",
"return",
"value",
"of",
"false",
"indicates",
"that",
"the",
"client",
"could",
"not",
"be",
"closed",
"since",
"there",
"was",
"at",
"least",
"one",
"registration",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/client.go#L110-L132
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/client.go
|
TransferRegistrations
|
func (c *Client) TransferRegistrations(close bool) (fab.EventSnapshot, error) {
if !close {
return c.Transfer()
}
var snapshot fab.EventSnapshot
var err error
c.close(func() {
logger.Debug("Stopping dispatcher and taking snapshot of all registrations...")
snapshot, err = c.StopAndTransfer()
if err != nil {
logger.Errorf("An error occurred while stopping dispatcher and taking snapshot: %s", err)
}
})
return snapshot, err
}
|
go
|
func (c *Client) TransferRegistrations(close bool) (fab.EventSnapshot, error) {
if !close {
return c.Transfer()
}
var snapshot fab.EventSnapshot
var err error
c.close(func() {
logger.Debug("Stopping dispatcher and taking snapshot of all registrations...")
snapshot, err = c.StopAndTransfer()
if err != nil {
logger.Errorf("An error occurred while stopping dispatcher and taking snapshot: %s", err)
}
})
return snapshot, err
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"TransferRegistrations",
"(",
"close",
"bool",
")",
"(",
"fab",
".",
"EventSnapshot",
",",
"error",
")",
"{",
"if",
"!",
"close",
"{",
"return",
"c",
".",
"Transfer",
"(",
")",
"\n",
"}",
"\n\n",
"var",
"snapshot",
"fab",
".",
"EventSnapshot",
"\n",
"var",
"err",
"error",
"\n",
"c",
".",
"close",
"(",
"func",
"(",
")",
"{",
"logger",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"snapshot",
",",
"err",
"=",
"c",
".",
"StopAndTransfer",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
")",
"\n\n",
"return",
"snapshot",
",",
"err",
"\n",
"}"
] |
// TransferRegistrations transfers all registrations into an EventSnapshot.
// The registrations are not closed and may susequently be transferred to a
// new event client.
// - close - if true then the client will also be closed
|
[
"TransferRegistrations",
"transfers",
"all",
"registrations",
"into",
"an",
"EventSnapshot",
".",
"The",
"registrations",
"are",
"not",
"closed",
"and",
"may",
"susequently",
"be",
"transferred",
"to",
"a",
"new",
"event",
"client",
".",
"-",
"close",
"-",
"if",
"true",
"then",
"the",
"client",
"will",
"also",
"be",
"closed"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/client.go#L146-L162
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/client.go
|
registerConnectionEvent
|
func (c *Client) registerConnectionEvent() (fab.Registration, chan *dispatcher.ConnectionEvent, error) {
if c.Stopped() {
return nil, nil, errors.New("event client is closed")
}
eventch := make(chan *dispatcher.ConnectionEvent, c.eventConsumerBufferSize)
errch := make(chan error)
regch := make(chan fab.Registration)
err1 := c.Submit(dispatcher.NewRegisterConnectionEvent(eventch, regch, errch))
if err1 != nil {
return nil, nil, err1
}
select {
case reg := <-regch:
return reg, eventch, nil
case err := <-errch:
return nil, nil, err
}
}
|
go
|
func (c *Client) registerConnectionEvent() (fab.Registration, chan *dispatcher.ConnectionEvent, error) {
if c.Stopped() {
return nil, nil, errors.New("event client is closed")
}
eventch := make(chan *dispatcher.ConnectionEvent, c.eventConsumerBufferSize)
errch := make(chan error)
regch := make(chan fab.Registration)
err1 := c.Submit(dispatcher.NewRegisterConnectionEvent(eventch, regch, errch))
if err1 != nil {
return nil, nil, err1
}
select {
case reg := <-regch:
return reg, eventch, nil
case err := <-errch:
return nil, nil, err
}
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"registerConnectionEvent",
"(",
")",
"(",
"fab",
".",
"Registration",
",",
"chan",
"*",
"dispatcher",
".",
"ConnectionEvent",
",",
"error",
")",
"{",
"if",
"c",
".",
"Stopped",
"(",
")",
"{",
"return",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"eventch",
":=",
"make",
"(",
"chan",
"*",
"dispatcher",
".",
"ConnectionEvent",
",",
"c",
".",
"eventConsumerBufferSize",
")",
"\n",
"errch",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"regch",
":=",
"make",
"(",
"chan",
"fab",
".",
"Registration",
")",
"\n",
"err1",
":=",
"c",
".",
"Submit",
"(",
"dispatcher",
".",
"NewRegisterConnectionEvent",
"(",
"eventch",
",",
"regch",
",",
"errch",
")",
")",
"\n",
"if",
"err1",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err1",
"\n",
"}",
"\n",
"select",
"{",
"case",
"reg",
":=",
"<-",
"regch",
":",
"return",
"reg",
",",
"eventch",
",",
"nil",
"\n",
"case",
"err",
":=",
"<-",
"errch",
":",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// registerConnectionEvent registers a connection event. The returned
// ConnectionEvent channel will be called whenever the client clients or disconnects
// from the event server
|
[
"registerConnectionEvent",
"registers",
"a",
"connection",
"event",
".",
"The",
"returned",
"ConnectionEvent",
"channel",
"will",
"be",
"called",
"whenever",
"the",
"client",
"clients",
"or",
"disconnects",
"from",
"the",
"event",
"server"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/client.go#L319-L337
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/client.go
|
setConnectionState
|
func (c *Client) setConnectionState(currentState, newState ConnectionState) bool {
return atomic.CompareAndSwapInt32(&c.connectionState, int32(currentState), int32(newState))
}
|
go
|
func (c *Client) setConnectionState(currentState, newState ConnectionState) bool {
return atomic.CompareAndSwapInt32(&c.connectionState, int32(currentState), int32(newState))
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"setConnectionState",
"(",
"currentState",
",",
"newState",
"ConnectionState",
")",
"bool",
"{",
"return",
"atomic",
".",
"CompareAndSwapInt32",
"(",
"&",
"c",
".",
"connectionState",
",",
"int32",
"(",
"currentState",
")",
",",
"int32",
"(",
"newState",
")",
")",
"\n",
"}"
] |
// setConnectionState sets the connection state only if the given currentState
// matches the actual state. True is returned if the connection state was successfully set.
|
[
"setConnectionState",
"sets",
"the",
"connection",
"state",
"only",
"if",
"the",
"given",
"currentState",
"matches",
"the",
"actual",
"state",
".",
"True",
"is",
"returned",
"if",
"the",
"connection",
"state",
"was",
"successfully",
"set",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/client.go#L356-L358
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/channel/invoke/txnhandler.go
|
Handle
|
func (e *EndorsementHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
if len(requestContext.Opts.Targets) == 0 {
requestContext.Error = status.New(status.ClientStatus, status.NoPeersFound.ToInt32(), "targets were not provided", nil)
return
}
// Endorse Tx
var TxnHeaderOpts []fab.TxnHeaderOpt
if e.headerOptsProvider != nil {
TxnHeaderOpts = e.headerOptsProvider()
}
transactionProposalResponses, proposal, err := createAndSendTransactionProposal(
clientContext.Transactor,
&requestContext.Request,
peer.PeersToTxnProcessors(requestContext.Opts.Targets),
TxnHeaderOpts...,
)
requestContext.Response.Proposal = proposal
requestContext.Response.TransactionID = proposal.TxnID // TODO: still needed?
if err != nil {
requestContext.Error = err
return
}
requestContext.Response.Responses = transactionProposalResponses
if len(transactionProposalResponses) > 0 {
requestContext.Response.Payload = transactionProposalResponses[0].ProposalResponse.GetResponse().Payload
requestContext.Response.ChaincodeStatus = transactionProposalResponses[0].ChaincodeStatus
}
//Delegate to next step if any
if e.next != nil {
e.next.Handle(requestContext, clientContext)
}
}
|
go
|
func (e *EndorsementHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
if len(requestContext.Opts.Targets) == 0 {
requestContext.Error = status.New(status.ClientStatus, status.NoPeersFound.ToInt32(), "targets were not provided", nil)
return
}
// Endorse Tx
var TxnHeaderOpts []fab.TxnHeaderOpt
if e.headerOptsProvider != nil {
TxnHeaderOpts = e.headerOptsProvider()
}
transactionProposalResponses, proposal, err := createAndSendTransactionProposal(
clientContext.Transactor,
&requestContext.Request,
peer.PeersToTxnProcessors(requestContext.Opts.Targets),
TxnHeaderOpts...,
)
requestContext.Response.Proposal = proposal
requestContext.Response.TransactionID = proposal.TxnID // TODO: still needed?
if err != nil {
requestContext.Error = err
return
}
requestContext.Response.Responses = transactionProposalResponses
if len(transactionProposalResponses) > 0 {
requestContext.Response.Payload = transactionProposalResponses[0].ProposalResponse.GetResponse().Payload
requestContext.Response.ChaincodeStatus = transactionProposalResponses[0].ChaincodeStatus
}
//Delegate to next step if any
if e.next != nil {
e.next.Handle(requestContext, clientContext)
}
}
|
[
"func",
"(",
"e",
"*",
"EndorsementHandler",
")",
"Handle",
"(",
"requestContext",
"*",
"RequestContext",
",",
"clientContext",
"*",
"ClientContext",
")",
"{",
"if",
"len",
"(",
"requestContext",
".",
"Opts",
".",
"Targets",
")",
"==",
"0",
"{",
"requestContext",
".",
"Error",
"=",
"status",
".",
"New",
"(",
"status",
".",
"ClientStatus",
",",
"status",
".",
"NoPeersFound",
".",
"ToInt32",
"(",
")",
",",
"\"",
"\"",
",",
"nil",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Endorse Tx",
"var",
"TxnHeaderOpts",
"[",
"]",
"fab",
".",
"TxnHeaderOpt",
"\n",
"if",
"e",
".",
"headerOptsProvider",
"!=",
"nil",
"{",
"TxnHeaderOpts",
"=",
"e",
".",
"headerOptsProvider",
"(",
")",
"\n",
"}",
"\n\n",
"transactionProposalResponses",
",",
"proposal",
",",
"err",
":=",
"createAndSendTransactionProposal",
"(",
"clientContext",
".",
"Transactor",
",",
"&",
"requestContext",
".",
"Request",
",",
"peer",
".",
"PeersToTxnProcessors",
"(",
"requestContext",
".",
"Opts",
".",
"Targets",
")",
",",
"TxnHeaderOpts",
"...",
",",
")",
"\n\n",
"requestContext",
".",
"Response",
".",
"Proposal",
"=",
"proposal",
"\n",
"requestContext",
".",
"Response",
".",
"TransactionID",
"=",
"proposal",
".",
"TxnID",
"// TODO: still needed?",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"requestContext",
".",
"Error",
"=",
"err",
"\n",
"return",
"\n",
"}",
"\n\n",
"requestContext",
".",
"Response",
".",
"Responses",
"=",
"transactionProposalResponses",
"\n",
"if",
"len",
"(",
"transactionProposalResponses",
")",
">",
"0",
"{",
"requestContext",
".",
"Response",
".",
"Payload",
"=",
"transactionProposalResponses",
"[",
"0",
"]",
".",
"ProposalResponse",
".",
"GetResponse",
"(",
")",
".",
"Payload",
"\n",
"requestContext",
".",
"Response",
".",
"ChaincodeStatus",
"=",
"transactionProposalResponses",
"[",
"0",
"]",
".",
"ChaincodeStatus",
"\n",
"}",
"\n\n",
"//Delegate to next step if any",
"if",
"e",
".",
"next",
"!=",
"nil",
"{",
"e",
".",
"next",
".",
"Handle",
"(",
"requestContext",
",",
"clientContext",
")",
"\n",
"}",
"\n",
"}"
] |
//Handle for endorsing transactions
|
[
"Handle",
"for",
"endorsing",
"transactions"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/txnhandler.go#L35-L73
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/channel/invoke/txnhandler.go
|
Handle
|
func (h *ProposalProcessorHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
//Get proposal processor, if not supplied then use selection service to get available peers as endorser
if len(requestContext.Opts.Targets) == 0 {
var selectionOpts []options.Opt
if requestContext.SelectionFilter != nil {
selectionOpts = append(selectionOpts, selectopts.WithPeerFilter(requestContext.SelectionFilter))
}
if requestContext.PeerSorter != nil {
selectionOpts = append(selectionOpts, selectopts.WithPeerSorter(requestContext.PeerSorter))
}
endorsers, err := clientContext.Selection.GetEndorsersForChaincode(newInvocationChain(requestContext), selectionOpts...)
if err != nil {
requestContext.Error = errors.WithMessage(err, "Failed to get endorsing peers")
return
}
requestContext.Opts.Targets = endorsers
}
//Delegate to next step if any
if h.next != nil {
h.next.Handle(requestContext, clientContext)
}
}
|
go
|
func (h *ProposalProcessorHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
//Get proposal processor, if not supplied then use selection service to get available peers as endorser
if len(requestContext.Opts.Targets) == 0 {
var selectionOpts []options.Opt
if requestContext.SelectionFilter != nil {
selectionOpts = append(selectionOpts, selectopts.WithPeerFilter(requestContext.SelectionFilter))
}
if requestContext.PeerSorter != nil {
selectionOpts = append(selectionOpts, selectopts.WithPeerSorter(requestContext.PeerSorter))
}
endorsers, err := clientContext.Selection.GetEndorsersForChaincode(newInvocationChain(requestContext), selectionOpts...)
if err != nil {
requestContext.Error = errors.WithMessage(err, "Failed to get endorsing peers")
return
}
requestContext.Opts.Targets = endorsers
}
//Delegate to next step if any
if h.next != nil {
h.next.Handle(requestContext, clientContext)
}
}
|
[
"func",
"(",
"h",
"*",
"ProposalProcessorHandler",
")",
"Handle",
"(",
"requestContext",
"*",
"RequestContext",
",",
"clientContext",
"*",
"ClientContext",
")",
"{",
"//Get proposal processor, if not supplied then use selection service to get available peers as endorser",
"if",
"len",
"(",
"requestContext",
".",
"Opts",
".",
"Targets",
")",
"==",
"0",
"{",
"var",
"selectionOpts",
"[",
"]",
"options",
".",
"Opt",
"\n",
"if",
"requestContext",
".",
"SelectionFilter",
"!=",
"nil",
"{",
"selectionOpts",
"=",
"append",
"(",
"selectionOpts",
",",
"selectopts",
".",
"WithPeerFilter",
"(",
"requestContext",
".",
"SelectionFilter",
")",
")",
"\n",
"}",
"\n",
"if",
"requestContext",
".",
"PeerSorter",
"!=",
"nil",
"{",
"selectionOpts",
"=",
"append",
"(",
"selectionOpts",
",",
"selectopts",
".",
"WithPeerSorter",
"(",
"requestContext",
".",
"PeerSorter",
")",
")",
"\n",
"}",
"\n\n",
"endorsers",
",",
"err",
":=",
"clientContext",
".",
"Selection",
".",
"GetEndorsersForChaincode",
"(",
"newInvocationChain",
"(",
"requestContext",
")",
",",
"selectionOpts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"requestContext",
".",
"Error",
"=",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"requestContext",
".",
"Opts",
".",
"Targets",
"=",
"endorsers",
"\n",
"}",
"\n\n",
"//Delegate to next step if any",
"if",
"h",
".",
"next",
"!=",
"nil",
"{",
"h",
".",
"next",
".",
"Handle",
"(",
"requestContext",
",",
"clientContext",
")",
"\n",
"}",
"\n",
"}"
] |
//Handle selects proposal processors
|
[
"Handle",
"selects",
"proposal",
"processors"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/txnhandler.go#L81-L104
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/channel/invoke/txnhandler.go
|
Handle
|
func (f *EndorsementValidationHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
//Filter tx proposal responses
err := f.validate(requestContext.Response.Responses)
if err != nil {
requestContext.Error = errors.WithMessage(err, "endorsement validation failed")
return
}
//Delegate to next step if any
if f.next != nil {
f.next.Handle(requestContext, clientContext)
}
}
|
go
|
func (f *EndorsementValidationHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
//Filter tx proposal responses
err := f.validate(requestContext.Response.Responses)
if err != nil {
requestContext.Error = errors.WithMessage(err, "endorsement validation failed")
return
}
//Delegate to next step if any
if f.next != nil {
f.next.Handle(requestContext, clientContext)
}
}
|
[
"func",
"(",
"f",
"*",
"EndorsementValidationHandler",
")",
"Handle",
"(",
"requestContext",
"*",
"RequestContext",
",",
"clientContext",
"*",
"ClientContext",
")",
"{",
"//Filter tx proposal responses",
"err",
":=",
"f",
".",
"validate",
"(",
"requestContext",
".",
"Response",
".",
"Responses",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"requestContext",
".",
"Error",
"=",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"//Delegate to next step if any",
"if",
"f",
".",
"next",
"!=",
"nil",
"{",
"f",
".",
"next",
".",
"Handle",
"(",
"requestContext",
",",
"clientContext",
")",
"\n",
"}",
"\n",
"}"
] |
//Handle for Filtering proposal response
|
[
"Handle",
"for",
"Filtering",
"proposal",
"response"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/txnhandler.go#L124-L137
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/channel/invoke/txnhandler.go
|
Handle
|
func (c *CommitTxHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
txnID := requestContext.Response.TransactionID
//Register Tx event
reg, statusNotifier, err := clientContext.EventService.RegisterTxStatusEvent(string(txnID)) // TODO: Change func to use TransactionID instead of string
if err != nil {
requestContext.Error = errors.Wrap(err, "error registering for TxStatus event")
return
}
defer clientContext.EventService.Unregister(reg)
_, err = createAndSendTransaction(clientContext.Transactor, requestContext.Response.Proposal, requestContext.Response.Responses)
if err != nil {
requestContext.Error = errors.Wrap(err, "CreateAndSendTransaction failed")
return
}
select {
case txStatus := <-statusNotifier:
requestContext.Response.TxValidationCode = txStatus.TxValidationCode
if txStatus.TxValidationCode != pb.TxValidationCode_VALID {
requestContext.Error = status.New(status.EventServerStatus, int32(txStatus.TxValidationCode),
"received invalid transaction", nil)
return
}
case <-requestContext.Ctx.Done():
requestContext.Error = status.New(status.ClientStatus, status.Timeout.ToInt32(),
"Execute didn't receive block event", nil)
return
}
//Delegate to next step if any
if c.next != nil {
c.next.Handle(requestContext, clientContext)
}
}
|
go
|
func (c *CommitTxHandler) Handle(requestContext *RequestContext, clientContext *ClientContext) {
txnID := requestContext.Response.TransactionID
//Register Tx event
reg, statusNotifier, err := clientContext.EventService.RegisterTxStatusEvent(string(txnID)) // TODO: Change func to use TransactionID instead of string
if err != nil {
requestContext.Error = errors.Wrap(err, "error registering for TxStatus event")
return
}
defer clientContext.EventService.Unregister(reg)
_, err = createAndSendTransaction(clientContext.Transactor, requestContext.Response.Proposal, requestContext.Response.Responses)
if err != nil {
requestContext.Error = errors.Wrap(err, "CreateAndSendTransaction failed")
return
}
select {
case txStatus := <-statusNotifier:
requestContext.Response.TxValidationCode = txStatus.TxValidationCode
if txStatus.TxValidationCode != pb.TxValidationCode_VALID {
requestContext.Error = status.New(status.EventServerStatus, int32(txStatus.TxValidationCode),
"received invalid transaction", nil)
return
}
case <-requestContext.Ctx.Done():
requestContext.Error = status.New(status.ClientStatus, status.Timeout.ToInt32(),
"Execute didn't receive block event", nil)
return
}
//Delegate to next step if any
if c.next != nil {
c.next.Handle(requestContext, clientContext)
}
}
|
[
"func",
"(",
"c",
"*",
"CommitTxHandler",
")",
"Handle",
"(",
"requestContext",
"*",
"RequestContext",
",",
"clientContext",
"*",
"ClientContext",
")",
"{",
"txnID",
":=",
"requestContext",
".",
"Response",
".",
"TransactionID",
"\n\n",
"//Register Tx event",
"reg",
",",
"statusNotifier",
",",
"err",
":=",
"clientContext",
".",
"EventService",
".",
"RegisterTxStatusEvent",
"(",
"string",
"(",
"txnID",
")",
")",
"// TODO: Change func to use TransactionID instead of string",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"requestContext",
".",
"Error",
"=",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"defer",
"clientContext",
".",
"EventService",
".",
"Unregister",
"(",
"reg",
")",
"\n\n",
"_",
",",
"err",
"=",
"createAndSendTransaction",
"(",
"clientContext",
".",
"Transactor",
",",
"requestContext",
".",
"Response",
".",
"Proposal",
",",
"requestContext",
".",
"Response",
".",
"Responses",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"requestContext",
".",
"Error",
"=",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"select",
"{",
"case",
"txStatus",
":=",
"<-",
"statusNotifier",
":",
"requestContext",
".",
"Response",
".",
"TxValidationCode",
"=",
"txStatus",
".",
"TxValidationCode",
"\n\n",
"if",
"txStatus",
".",
"TxValidationCode",
"!=",
"pb",
".",
"TxValidationCode_VALID",
"{",
"requestContext",
".",
"Error",
"=",
"status",
".",
"New",
"(",
"status",
".",
"EventServerStatus",
",",
"int32",
"(",
"txStatus",
".",
"TxValidationCode",
")",
",",
"\"",
"\"",
",",
"nil",
")",
"\n",
"return",
"\n",
"}",
"\n",
"case",
"<-",
"requestContext",
".",
"Ctx",
".",
"Done",
"(",
")",
":",
"requestContext",
".",
"Error",
"=",
"status",
".",
"New",
"(",
"status",
".",
"ClientStatus",
",",
"status",
".",
"Timeout",
".",
"ToInt32",
"(",
")",
",",
"\"",
"\"",
",",
"nil",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"//Delegate to next step if any",
"if",
"c",
".",
"next",
"!=",
"nil",
"{",
"c",
".",
"next",
".",
"Handle",
"(",
"requestContext",
",",
"clientContext",
")",
"\n",
"}",
"\n",
"}"
] |
//Handle handles commit tx
|
[
"Handle",
"handles",
"commit",
"tx"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/txnhandler.go#L167-L203
|
train
|
hyperledger/fabric-sdk-go
|
pkg/client/channel/invoke/txnhandler.go
|
NewEndorsementHandlerWithOpts
|
func NewEndorsementHandlerWithOpts(next Handler, provider TxnHeaderOptsProvider) *EndorsementHandler {
return &EndorsementHandler{next: next, headerOptsProvider: provider}
}
|
go
|
func NewEndorsementHandlerWithOpts(next Handler, provider TxnHeaderOptsProvider) *EndorsementHandler {
return &EndorsementHandler{next: next, headerOptsProvider: provider}
}
|
[
"func",
"NewEndorsementHandlerWithOpts",
"(",
"next",
"Handler",
",",
"provider",
"TxnHeaderOptsProvider",
")",
"*",
"EndorsementHandler",
"{",
"return",
"&",
"EndorsementHandler",
"{",
"next",
":",
"next",
",",
"headerOptsProvider",
":",
"provider",
"}",
"\n",
"}"
] |
//NewEndorsementHandlerWithOpts returns a handler that endorses a transaction proposal
|
[
"NewEndorsementHandlerWithOpts",
"returns",
"a",
"handler",
"that",
"endorses",
"a",
"transaction",
"proposal"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/channel/invoke/txnhandler.go#L236-L238
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/events/client/lbp/roundrobin.go
|
Choose
|
func (lbp *RoundRobin) Choose(peers []fab.Peer) (fab.Peer, error) {
if len(peers) == 0 {
logger.Warn("No peers to choose from!")
return nil, nil
}
return peers[lbp.counter.Next(len(peers))], nil
}
|
go
|
func (lbp *RoundRobin) Choose(peers []fab.Peer) (fab.Peer, error) {
if len(peers) == 0 {
logger.Warn("No peers to choose from!")
return nil, nil
}
return peers[lbp.counter.Next(len(peers))], nil
}
|
[
"func",
"(",
"lbp",
"*",
"RoundRobin",
")",
"Choose",
"(",
"peers",
"[",
"]",
"fab",
".",
"Peer",
")",
"(",
"fab",
".",
"Peer",
",",
"error",
")",
"{",
"if",
"len",
"(",
"peers",
")",
"==",
"0",
"{",
"logger",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"return",
"peers",
"[",
"lbp",
".",
"counter",
".",
"Next",
"(",
"len",
"(",
"peers",
")",
")",
"]",
",",
"nil",
"\n",
"}"
] |
// Choose chooses from the list of peers in round-robin fashion
|
[
"Choose",
"chooses",
"from",
"the",
"list",
"of",
"peers",
"in",
"round",
"-",
"robin",
"fashion"
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/lbp/roundrobin.go#L28-L34
|
train
|
hyperledger/fabric-sdk-go
|
pkg/fab/signingmgr/signingmgr.go
|
New
|
func New(cryptoProvider core.CryptoSuite) (*SigningManager, error) {
return &SigningManager{cryptoProvider: cryptoProvider, hashOpts: cryptosuite.GetSHAOpts()}, nil
}
|
go
|
func New(cryptoProvider core.CryptoSuite) (*SigningManager, error) {
return &SigningManager{cryptoProvider: cryptoProvider, hashOpts: cryptosuite.GetSHAOpts()}, nil
}
|
[
"func",
"New",
"(",
"cryptoProvider",
"core",
".",
"CryptoSuite",
")",
"(",
"*",
"SigningManager",
",",
"error",
")",
"{",
"return",
"&",
"SigningManager",
"{",
"cryptoProvider",
":",
"cryptoProvider",
",",
"hashOpts",
":",
"cryptosuite",
".",
"GetSHAOpts",
"(",
")",
"}",
",",
"nil",
"\n",
"}"
] |
// New Constructor for a signing manager.
// @param {BCCSP} cryptoProvider - crypto provider
// @param {Config} config - configuration provider
// @returns {SigningManager} new signing manager
|
[
"New",
"Constructor",
"for",
"a",
"signing",
"manager",
"."
] |
48bb0d199e2cee03ad3af0a413bdfc064fc69bfe
|
https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/signingmgr/signingmgr.go#L27-L29
|
train
|
gobuffalo/packr
|
box.go
|
NewBox
|
func NewBox(path string) Box {
var cd string
if !filepath.IsAbs(path) {
_, filename, _, _ := runtime.Caller(1)
cd = filepath.Dir(filename)
}
// this little hack courtesy of the `-cover` flag!!
cov := filepath.Join("_test", "_obj_test")
cd = strings.Replace(cd, string(filepath.Separator)+cov, "", 1)
if !filepath.IsAbs(cd) && cd != "" {
cd = filepath.Join(GoPath(), "src", cd)
}
return Box{
Path: path,
callingDir: cd,
data: map[string][]byte{},
}
}
|
go
|
func NewBox(path string) Box {
var cd string
if !filepath.IsAbs(path) {
_, filename, _, _ := runtime.Caller(1)
cd = filepath.Dir(filename)
}
// this little hack courtesy of the `-cover` flag!!
cov := filepath.Join("_test", "_obj_test")
cd = strings.Replace(cd, string(filepath.Separator)+cov, "", 1)
if !filepath.IsAbs(cd) && cd != "" {
cd = filepath.Join(GoPath(), "src", cd)
}
return Box{
Path: path,
callingDir: cd,
data: map[string][]byte{},
}
}
|
[
"func",
"NewBox",
"(",
"path",
"string",
")",
"Box",
"{",
"var",
"cd",
"string",
"\n",
"if",
"!",
"filepath",
".",
"IsAbs",
"(",
"path",
")",
"{",
"_",
",",
"filename",
",",
"_",
",",
"_",
":=",
"runtime",
".",
"Caller",
"(",
"1",
")",
"\n",
"cd",
"=",
"filepath",
".",
"Dir",
"(",
"filename",
")",
"\n",
"}",
"\n\n",
"// this little hack courtesy of the `-cover` flag!!",
"cov",
":=",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"cd",
"=",
"strings",
".",
"Replace",
"(",
"cd",
",",
"string",
"(",
"filepath",
".",
"Separator",
")",
"+",
"cov",
",",
"\"",
"\"",
",",
"1",
")",
"\n",
"if",
"!",
"filepath",
".",
"IsAbs",
"(",
"cd",
")",
"&&",
"cd",
"!=",
"\"",
"\"",
"{",
"cd",
"=",
"filepath",
".",
"Join",
"(",
"GoPath",
"(",
")",
",",
"\"",
"\"",
",",
"cd",
")",
"\n",
"}",
"\n\n",
"return",
"Box",
"{",
"Path",
":",
"path",
",",
"callingDir",
":",
"cd",
",",
"data",
":",
"map",
"[",
"string",
"]",
"[",
"]",
"byte",
"{",
"}",
",",
"}",
"\n",
"}"
] |
// NewBox returns a Box that can be used to
// retrieve files from either disk or the embedded
// binary.
|
[
"NewBox",
"returns",
"a",
"Box",
"that",
"can",
"be",
"used",
"to",
"retrieve",
"files",
"from",
"either",
"disk",
"or",
"the",
"embedded",
"binary",
"."
] |
9819ef1571983a956c49475cb0524d8a4971620f
|
https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/box.go#L35-L54
|
train
|
gobuffalo/packr
|
v2/jam/parser/box.go
|
String
|
func (b Box) String() string {
x, _ := json.Marshal(b)
return string(x)
}
|
go
|
func (b Box) String() string {
x, _ := json.Marshal(b)
return string(x)
}
|
[
"func",
"(",
"b",
"Box",
")",
"String",
"(",
")",
"string",
"{",
"x",
",",
"_",
":=",
"json",
".",
"Marshal",
"(",
"b",
")",
"\n",
"return",
"string",
"(",
"x",
")",
"\n",
"}"
] |
// String - json returned
|
[
"String",
"-",
"json",
"returned"
] |
9819ef1571983a956c49475cb0524d8a4971620f
|
https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/jam/parser/box.go#L22-L25
|
train
|
gobuffalo/packr
|
v2/jam/parser/box.go
|
NewBox
|
func NewBox(name string, path string) *Box {
if len(name) == 0 {
name = path
}
name = strings.Replace(name, "\"", "", -1)
pwd, _ := os.Getwd()
box := &Box{
Name: name,
Path: path,
PWD: pwd,
}
return box
}
|
go
|
func NewBox(name string, path string) *Box {
if len(name) == 0 {
name = path
}
name = strings.Replace(name, "\"", "", -1)
pwd, _ := os.Getwd()
box := &Box{
Name: name,
Path: path,
PWD: pwd,
}
return box
}
|
[
"func",
"NewBox",
"(",
"name",
"string",
",",
"path",
"string",
")",
"*",
"Box",
"{",
"if",
"len",
"(",
"name",
")",
"==",
"0",
"{",
"name",
"=",
"path",
"\n",
"}",
"\n",
"name",
"=",
"strings",
".",
"Replace",
"(",
"name",
",",
"\"",
"\\\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"pwd",
",",
"_",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"box",
":=",
"&",
"Box",
"{",
"Name",
":",
"name",
",",
"Path",
":",
"path",
",",
"PWD",
":",
"pwd",
",",
"}",
"\n",
"return",
"box",
"\n",
"}"
] |
// NewBox stub from the name and the path provided
|
[
"NewBox",
"stub",
"from",
"the",
"name",
"and",
"the",
"path",
"provided"
] |
9819ef1571983a956c49475cb0524d8a4971620f
|
https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/jam/parser/box.go#L28-L40
|
train
|
gobuffalo/packr
|
v2/jam/pack.go
|
Pack
|
func Pack(opts PackOptions) error {
pwd, err := os.Getwd()
if err != nil {
return err
}
opts.Roots = append(opts.Roots, pwd)
if err := Clean(opts.Roots...); err != nil {
return err
}
p, err := parser.NewFromRoots(opts.Roots, &parser.RootsOptions{
IgnoreImports: opts.IgnoreImports,
})
if err != nil {
return err
}
boxes, err := p.Run()
if err != nil {
return err
}
// reduce boxes - remove ones we don't want
// MB: current assumption is we want all these
// boxes, just adding a comment suggesting they're
// might be a reason to exclude some
plog.Logger.Debugf("found %d boxes", len(boxes))
if len(opts.StoreCmd) != 0 {
return ShellPack(opts, boxes)
}
var st store.Store = store.NewDisk("", "")
if opts.Legacy {
st = store.NewLegacy()
}
for _, b := range boxes {
if b.Name == store.DISK_GLOBAL_KEY {
continue
}
if err := st.Pack(b); err != nil {
return err
}
}
if cl, ok := st.(io.Closer); ok {
return cl.Close()
}
return nil
}
|
go
|
func Pack(opts PackOptions) error {
pwd, err := os.Getwd()
if err != nil {
return err
}
opts.Roots = append(opts.Roots, pwd)
if err := Clean(opts.Roots...); err != nil {
return err
}
p, err := parser.NewFromRoots(opts.Roots, &parser.RootsOptions{
IgnoreImports: opts.IgnoreImports,
})
if err != nil {
return err
}
boxes, err := p.Run()
if err != nil {
return err
}
// reduce boxes - remove ones we don't want
// MB: current assumption is we want all these
// boxes, just adding a comment suggesting they're
// might be a reason to exclude some
plog.Logger.Debugf("found %d boxes", len(boxes))
if len(opts.StoreCmd) != 0 {
return ShellPack(opts, boxes)
}
var st store.Store = store.NewDisk("", "")
if opts.Legacy {
st = store.NewLegacy()
}
for _, b := range boxes {
if b.Name == store.DISK_GLOBAL_KEY {
continue
}
if err := st.Pack(b); err != nil {
return err
}
}
if cl, ok := st.(io.Closer); ok {
return cl.Close()
}
return nil
}
|
[
"func",
"Pack",
"(",
"opts",
"PackOptions",
")",
"error",
"{",
"pwd",
",",
"err",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"opts",
".",
"Roots",
"=",
"append",
"(",
"opts",
".",
"Roots",
",",
"pwd",
")",
"\n",
"if",
"err",
":=",
"Clean",
"(",
"opts",
".",
"Roots",
"...",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"p",
",",
"err",
":=",
"parser",
".",
"NewFromRoots",
"(",
"opts",
".",
"Roots",
",",
"&",
"parser",
".",
"RootsOptions",
"{",
"IgnoreImports",
":",
"opts",
".",
"IgnoreImports",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"boxes",
",",
"err",
":=",
"p",
".",
"Run",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// reduce boxes - remove ones we don't want",
"// MB: current assumption is we want all these",
"// boxes, just adding a comment suggesting they're",
"// might be a reason to exclude some",
"plog",
".",
"Logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"len",
"(",
"boxes",
")",
")",
"\n\n",
"if",
"len",
"(",
"opts",
".",
"StoreCmd",
")",
"!=",
"0",
"{",
"return",
"ShellPack",
"(",
"opts",
",",
"boxes",
")",
"\n",
"}",
"\n\n",
"var",
"st",
"store",
".",
"Store",
"=",
"store",
".",
"NewDisk",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"if",
"opts",
".",
"Legacy",
"{",
"st",
"=",
"store",
".",
"NewLegacy",
"(",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"b",
":=",
"range",
"boxes",
"{",
"if",
"b",
".",
"Name",
"==",
"store",
".",
"DISK_GLOBAL_KEY",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"err",
":=",
"st",
".",
"Pack",
"(",
"b",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"cl",
",",
"ok",
":=",
"st",
".",
"(",
"io",
".",
"Closer",
")",
";",
"ok",
"{",
"return",
"cl",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Pack the roots given + PWD
|
[
"Pack",
"the",
"roots",
"given",
"+",
"PWD"
] |
9819ef1571983a956c49475cb0524d8a4971620f
|
https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/jam/pack.go#L25-L76
|
train
|
gobuffalo/packr
|
builder/builder.go
|
Run
|
func (b *Builder) Run() error {
wg := &errgroup.Group{}
root, err := filepath.EvalSymlinks(b.RootPath)
if err != nil {
return err
}
err = filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if info == nil {
return filepath.SkipDir
}
base := strings.ToLower(filepath.Base(path))
if strings.HasPrefix(base, "_") {
return filepath.SkipDir
}
for _, f := range b.IgnoredFolders {
if strings.ToLower(f) == base {
if info.IsDir() {
return filepath.SkipDir
} else {
return nil
}
}
}
if !info.IsDir() {
wg.Go(func() error {
return b.process(path)
})
}
return nil
})
if err != nil {
return err
}
if err := wg.Wait(); err != nil {
return err
}
return b.dump()
}
|
go
|
func (b *Builder) Run() error {
wg := &errgroup.Group{}
root, err := filepath.EvalSymlinks(b.RootPath)
if err != nil {
return err
}
err = filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if info == nil {
return filepath.SkipDir
}
base := strings.ToLower(filepath.Base(path))
if strings.HasPrefix(base, "_") {
return filepath.SkipDir
}
for _, f := range b.IgnoredFolders {
if strings.ToLower(f) == base {
if info.IsDir() {
return filepath.SkipDir
} else {
return nil
}
}
}
if !info.IsDir() {
wg.Go(func() error {
return b.process(path)
})
}
return nil
})
if err != nil {
return err
}
if err := wg.Wait(); err != nil {
return err
}
return b.dump()
}
|
[
"func",
"(",
"b",
"*",
"Builder",
")",
"Run",
"(",
")",
"error",
"{",
"wg",
":=",
"&",
"errgroup",
".",
"Group",
"{",
"}",
"\n",
"root",
",",
"err",
":=",
"filepath",
".",
"EvalSymlinks",
"(",
"b",
".",
"RootPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"filepath",
".",
"Walk",
"(",
"root",
",",
"func",
"(",
"path",
"string",
",",
"info",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"error",
"{",
"if",
"info",
"==",
"nil",
"{",
"return",
"filepath",
".",
"SkipDir",
"\n",
"}",
"\n\n",
"base",
":=",
"strings",
".",
"ToLower",
"(",
"filepath",
".",
"Base",
"(",
"path",
")",
")",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"base",
",",
"\"",
"\"",
")",
"{",
"return",
"filepath",
".",
"SkipDir",
"\n",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"b",
".",
"IgnoredFolders",
"{",
"if",
"strings",
".",
"ToLower",
"(",
"f",
")",
"==",
"base",
"{",
"if",
"info",
".",
"IsDir",
"(",
")",
"{",
"return",
"filepath",
".",
"SkipDir",
"\n",
"}",
"else",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"info",
".",
"IsDir",
"(",
")",
"{",
"wg",
".",
"Go",
"(",
"func",
"(",
")",
"error",
"{",
"return",
"b",
".",
"process",
"(",
"path",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"wg",
".",
"Wait",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"b",
".",
"dump",
"(",
")",
"\n",
"}"
] |
// Run the builder.
|
[
"Run",
"the",
"builder",
"."
] |
9819ef1571983a956c49475cb0524d8a4971620f
|
https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/builder/builder.go#L37-L75
|
train
|
gobuffalo/packr
|
builder/builder.go
|
New
|
func New(ctx context.Context, path string) *Builder {
return &Builder{
Context: ctx,
RootPath: path,
IgnoredBoxes: []string{},
IgnoredFolders: []string{"vendor", ".git", "node_modules", ".idea"},
pkgs: map[string]pkg{},
moot: &sync.Mutex{},
}
}
|
go
|
func New(ctx context.Context, path string) *Builder {
return &Builder{
Context: ctx,
RootPath: path,
IgnoredBoxes: []string{},
IgnoredFolders: []string{"vendor", ".git", "node_modules", ".idea"},
pkgs: map[string]pkg{},
moot: &sync.Mutex{},
}
}
|
[
"func",
"New",
"(",
"ctx",
"context",
".",
"Context",
",",
"path",
"string",
")",
"*",
"Builder",
"{",
"return",
"&",
"Builder",
"{",
"Context",
":",
"ctx",
",",
"RootPath",
":",
"path",
",",
"IgnoredBoxes",
":",
"[",
"]",
"string",
"{",
"}",
",",
"IgnoredFolders",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"pkgs",
":",
"map",
"[",
"string",
"]",
"pkg",
"{",
"}",
",",
"moot",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
",",
"}",
"\n",
"}"
] |
// New Builder with a given context and path
|
[
"New",
"Builder",
"with",
"a",
"given",
"context",
"and",
"path"
] |
9819ef1571983a956c49475cb0524d8a4971620f
|
https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/builder/builder.go#L162-L171
|
train
|
gobuffalo/packr
|
v2/jam/parser/file.go
|
String
|
func (f *File) String() string {
src, _ := ioutil.ReadAll(f)
f.Reader = bytes.NewReader(src)
return string(src)
}
|
go
|
func (f *File) String() string {
src, _ := ioutil.ReadAll(f)
f.Reader = bytes.NewReader(src)
return string(src)
}
|
[
"func",
"(",
"f",
"*",
"File",
")",
"String",
"(",
")",
"string",
"{",
"src",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"f",
")",
"\n",
"f",
".",
"Reader",
"=",
"bytes",
".",
"NewReader",
"(",
"src",
")",
"\n",
"return",
"string",
"(",
"src",
")",
"\n",
"}"
] |
// String returns the contents of the reader
|
[
"String",
"returns",
"the",
"contents",
"of",
"the",
"reader"
] |
9819ef1571983a956c49475cb0524d8a4971620f
|
https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/jam/parser/file.go#L23-L27
|
train
|
gobuffalo/packr
|
v2/jam/parser/file.go
|
NewFile
|
func NewFile(path string, r io.Reader) *File {
if r == nil {
r = &bytes.Buffer{}
}
if seek, ok := r.(io.Seeker); ok {
seek.Seek(0, 0)
}
abs := path
if !filepath.IsAbs(path) {
abs, _ = filepath.Abs(path)
}
return &File{
Reader: r,
Path: path,
AbsPath: abs,
}
}
|
go
|
func NewFile(path string, r io.Reader) *File {
if r == nil {
r = &bytes.Buffer{}
}
if seek, ok := r.(io.Seeker); ok {
seek.Seek(0, 0)
}
abs := path
if !filepath.IsAbs(path) {
abs, _ = filepath.Abs(path)
}
return &File{
Reader: r,
Path: path,
AbsPath: abs,
}
}
|
[
"func",
"NewFile",
"(",
"path",
"string",
",",
"r",
"io",
".",
"Reader",
")",
"*",
"File",
"{",
"if",
"r",
"==",
"nil",
"{",
"r",
"=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"}",
"\n",
"if",
"seek",
",",
"ok",
":=",
"r",
".",
"(",
"io",
".",
"Seeker",
")",
";",
"ok",
"{",
"seek",
".",
"Seek",
"(",
"0",
",",
"0",
")",
"\n",
"}",
"\n",
"abs",
":=",
"path",
"\n",
"if",
"!",
"filepath",
".",
"IsAbs",
"(",
"path",
")",
"{",
"abs",
",",
"_",
"=",
"filepath",
".",
"Abs",
"(",
"path",
")",
"\n",
"}",
"\n",
"return",
"&",
"File",
"{",
"Reader",
":",
"r",
",",
"Path",
":",
"path",
",",
"AbsPath",
":",
"abs",
",",
"}",
"\n",
"}"
] |
// NewFile takes the name of the file you want to
// write to and a reader to reader from
|
[
"NewFile",
"takes",
"the",
"name",
"of",
"the",
"file",
"you",
"want",
"to",
"write",
"to",
"and",
"a",
"reader",
"to",
"reader",
"from"
] |
9819ef1571983a956c49475cb0524d8a4971620f
|
https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/jam/parser/file.go#L38-L54
|
train
|
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.