_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q29800 | WithResponseTimeout | train | func WithResponseTimeout(value time.Duration) options.Opt {
return func(p options.Params) {
if setter, ok := p.(responseTimeoutSetter); ok {
setter.SetResponseTimeout(value)
}
}
} | go | {
"resource": ""
} |
q29801 | searchForLib | train | func searchForLib(paths string) (firstFound string, err error) {
libPaths := strings.Split(paths, ",")
for _, path := range libPaths {
if _, err = os.Stat(strings.TrimSpace(path)); !os.IsNotExist(err) {
firstFound = strings.TrimSpace(path)
break
}
}
if firstFound == "" {
err = fmt.Errorf("no suitable ... | go | {
"resource": ""
} |
q29802 | CreateCryptoSuiteProvider | train | func (f *ProviderFactory) CreateCryptoSuiteProvider(config core.CryptoSuiteConfig) (core.CryptoSuite, error) {
if config.SecurityProvider() != "sw" {
logger.Warnf("default provider factory doesn't support '%s' crypto provider", config.SecurityProvider())
}
cryptoSuiteProvider, err := cryptosuiteimpl.GetSuiteByConf... | go | {
"resource": ""
} |
q29803 | CreateSigningManager | train | func (f *ProviderFactory) CreateSigningManager(cryptoProvider core.CryptoSuite) (core.SigningManager, error) {
return signingMgr.New(cryptoProvider)
} | go | {
"resource": ""
} |
q29804 | CreateInfraProvider | train | func (f *ProviderFactory) CreateInfraProvider(config fab.EndpointConfig) (fab.InfraProvider, error) {
return fabpvdr.New(config), nil
} | go | {
"resource": ""
} |
q29805 | WithRetryOpts | train | func WithRetryOpts(value retry.Opts) coptions.Opt {
return func(p coptions.Params) {
logger.Debug("Checking retryOptsSetter")
if setter, ok := p.(retryOptsSetter); ok {
setter.SetSelectionRetryOpts(value)
}
}
} | go | {
"resource": ""
} |
q29806 | NewMockProviderContext | train | func NewMockProviderContext(userOpts ...ProviderOption) *MockProviderContext {
users := ProviderUsersOptions{}
for _, param := range userOpts {
err := param(&users)
if err != nil {
panic(fmt.Errorf("error creating MockProviderContext: %s", err))
}
}
im := make(map[string]msp.IdentityManager)
for org := ... | go | {
"resource": ""
} |
q29807 | NewMockProviderContextCustom | train | func NewMockProviderContextCustom(cryptoConfig core.CryptoSuiteConfig, endpointConfig fab.EndpointConfig, identityConfig msp.IdentityConfig, cryptoSuite core.CryptoSuite, signer core.SigningManager, userStore msp.UserStore, identityManager map[string]msp.IdentityManager) *MockProviderContext {
context := MockProviderC... | go | {
"resource": ""
} |
q29808 | IdentityManager | train | func (pc *MockProviderContext) IdentityManager(orgName string) (msp.IdentityManager, bool) {
mgr, ok := pc.identityManager[strings.ToLower(orgName)]
return mgr, ok
} | go | {
"resource": ""
} |
q29809 | NewMockContext | train | func NewMockContext(si msp.SigningIdentity) *MockContext {
ctx := MockContext{
MockProviderContext: NewMockProviderContext(),
SigningIdentity: si,
}
return &ctx
} | go | {
"resource": ""
} |
q29810 | Identifier | train | func (m MockContext) Identifier() *msp.IdentityIdentifier {
return &msp.IdentityIdentifier{ID: m.SigningIdentity.Identifier().ID, MSPID: m.SigningIdentity.Identifier().MSPID}
} | go | {
"resource": ""
} |
q29811 | PublicVersion | train | func (m MockContext) PublicVersion() msp.Identity {
if m.SigningIdentity == nil {
return nil
}
return m.SigningIdentity.PublicVersion()
} | go | {
"resource": ""
} |
q29812 | PrivateKey | train | func (m MockContext) PrivateKey() core.Key {
if m.SigningIdentity == nil {
return nil
}
return m.SigningIdentity.PrivateKey()
} | go | {
"resource": ""
} |
q29813 | NewMockChannelContext | train | func NewMockChannelContext(context *MockContext, channelID string) *MockChannelContext {
return &MockChannelContext{
MockContext: context,
channelID: channelID,
}
} | go | {
"resource": ""
} |
q29814 | NewMockTransactionHeader | train | func NewMockTransactionHeader(channelID string) (fab.TransactionHeader, error) {
user := mspmocks.NewMockSigningIdentity("test", "Org1MSP")
// generate a random nonce
nonce, err := crypto.GetRandomNonce()
if err != nil {
return nil, err
}
creator, err := user.Serialize()
if err != nil {
return nil, err
}
... | go | {
"resource": ""
} |
q29815 | NewChannelService | train | func NewChannelService(ctx contextAPI.Client, membership fab.ChannelMembership, channelID string, opts ...coptions.Opt) (*ChannelService, error) {
logger.Debug("Creating new dynamic discovery service")
s := &ChannelService{
channelID: channelID,
membership: membership,
}
s.service = newService(ctx.EndpointConf... | go | {
"resource": ""
} |
q29816 | evaluate | train | func (s *ChannelService) evaluate(ctx contextAPI.Client, responses []fabdiscovery.Response) ([]fab.Peer, error) {
if len(responses) == 0 {
return nil, errors.New("no successful response received from any peer")
}
// TODO: In a future patch:
// - validate the signatures in the responses
// For now just pick the ... | go | {
"resource": ""
} |
q29817 | NewCertFileUserStore1 | train | func NewCertFileUserStore1(store core.KVStore) (*CertFileUserStore, error) {
return &CertFileUserStore{
store: store,
}, nil
} | go | {
"resource": ""
} |
q29818 | NewCertFileUserStore | train | func NewCertFileUserStore(path string) (*CertFileUserStore, error) {
if path == "" {
return nil, errors.New("path is empty")
}
store, err := keyvaluestore.New(&keyvaluestore.FileKeyValueStoreOptions{
Path: path,
})
if err != nil {
return nil, errors.WithMessage(err, "user store creation failed")
}
return N... | go | {
"resource": ""
} |
q29819 | Load | train | func (s *CertFileUserStore) Load(key msp.IdentityIdentifier) (*msp.UserData, error) {
cert, err := s.store.Load(storeKeyFromUserIdentifier(key))
if err != nil {
if err == core.ErrKeyValueNotFound {
return nil, msp.ErrUserNotFound
}
return nil, err
}
certBytes, ok := cert.([]byte)
if !ok {
return nil, er... | go | {
"resource": ""
} |
q29820 | Store | train | func (s *CertFileUserStore) Store(user *msp.UserData) error {
key := storeKeyFromUserIdentifier(msp.IdentityIdentifier{MSPID: user.MSPID, ID: user.ID})
return s.store.Store(key, user.EnrollmentCertificate)
} | go | {
"resource": ""
} |
q29821 | Delete | train | func (s *CertFileUserStore) Delete(key msp.IdentityIdentifier) error {
return s.store.Delete(storeKeyFromUserIdentifier(key))
} | go | {
"resource": ""
} |
q29822 | Verify | train | func (v *Signature) Verify(response *fab.TransactionProposalResponse) error {
if response.ProposalResponse.GetResponse().Status < int32(common.Status_SUCCESS) || response.ProposalResponse.GetResponse().Status >= int32(common.Status_BAD_REQUEST) {
return status.NewFromProposalResponse(response.ProposalResponse, resp... | go | {
"resource": ""
} |
q29823 | ValidateCertificateDates | train | func ValidateCertificateDates(cert *x509.Certificate) error {
if cert == nil {
return nil
}
if time.Now().UTC().Before(cert.NotBefore) {
return errors.New("Certificate provided is not valid until later date")
}
if time.Now().UTC().After(cert.NotAfter) {
return errors.New("Certificate provided has expired")
... | go | {
"resource": ""
} |
q29824 | VerifyPeerCertificate | train | func VerifyPeerCertificate(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
for _, chaincert := range rawCerts {
cert, err := utils.DERToX509Certificate(chaincert)
if err != nil {
logger.Warn("Got error while verifying cert")
}
if cert != nil {
err = ValidateCertificateDates(cert)
if e... | go | {
"resource": ""
} |
q29825 | Apply | train | func Apply(params Params, opts []Opt) {
for _, opt := range opts {
opt(params)
}
} | go | {
"resource": ""
} |
q29826 | ConfigFromBackend | train | func ConfigFromBackend(coreBackend ...core.ConfigBackend) (fab.EndpointConfig, error) {
config := &EndpointConfig{
backend: lookup.New(coreBackend...),
}
if err := config.loadEndpointConfiguration(); err != nil {
return nil, errors.WithMessage(err, "network configuration load failed")
}
//print deprecated w... | go | {
"resource": ""
} |
q29827 | Timeout | train | func (c *EndpointConfig) Timeout(tType fab.TimeoutType) time.Duration {
return c.getTimeout(tType)
} | go | {
"resource": ""
} |
q29828 | OrdererConfig | train | func (c *EndpointConfig) OrdererConfig(nameOrURL string) (*fab.OrdererConfig, bool) {
return c.tryMatchingOrdererConfig(nameOrURL, true)
} | go | {
"resource": ""
} |
q29829 | PeersConfig | train | func (c *EndpointConfig) PeersConfig(org string) ([]fab.PeerConfig, bool) {
peerConfigs, ok := c.peerConfigsByOrg[strings.ToLower(org)]
return peerConfigs, ok
} | go | {
"resource": ""
} |
q29830 | PeerConfig | train | func (c *EndpointConfig) PeerConfig(nameOrURL string) (*fab.PeerConfig, bool) {
return c.tryMatchingPeerConfig(nameOrURL, true)
} | go | {
"resource": ""
} |
q29831 | mappedChannelName | train | func (c *EndpointConfig) mappedChannelName(networkConfig *fab.NetworkConfig, channelName string) string {
// if channelName is the original key found in the Channels map config, then return it as is
_, ok := networkConfig.Channels[strings.ToLower(channelName)]
if ok {
return channelName
}
// if !ok, then find ... | go | {
"resource": ""
} |
q29832 | loadAllTLSConfig | train | func (c *EndpointConfig) loadAllTLSConfig(configEntity *endpointConfigEntity) error {
//resolve path and load bytes
err := c.loadClientTLSConfig(configEntity)
if err != nil {
return errors.WithMessage(err, "failed to load client TLSConfig ")
}
//resolve path and load bytes
err = c.loadOrgTLSConfig(configEntity... | go | {
"resource": ""
} |
q29833 | loadOrgTLSConfig | train | func (c *EndpointConfig) loadOrgTLSConfig(configEntity *endpointConfigEntity) error {
//Organizations Config
for org, orgConfig := range configEntity.Organizations {
for user, userConfig := range orgConfig.Users {
//resolve paths
userConfig.Key.Path = pathvar.Subst(userConfig.Key.Path)
userConfig.Cert.Pat... | go | {
"resource": ""
} |
q29834 | loadOrdererPeerTLSConfig | train | func (c *EndpointConfig) loadOrdererPeerTLSConfig(configEntity *endpointConfigEntity) error {
//Orderers Config
for orderer, ordererConfig := range configEntity.Orderers {
//resolve paths
ordererConfig.TLSCACerts.Path = pathvar.Subst(ordererConfig.TLSCACerts.Path)
//pre load key and cert bytes
err := orderer... | go | {
"resource": ""
} |
q29835 | loadTLSClientCerts | train | func (c *EndpointConfig) loadTLSClientCerts(configEntity *endpointConfigEntity) error {
var clientCerts tls.Certificate
cb := configEntity.Client.TLSCerts.Client.Cert.Bytes()
if len(cb) == 0 {
// if no cert found in the config, empty cert chain should be used
c.tlsClientCerts = []tls.Certificate{clientCerts}
... | go | {
"resource": ""
} |
q29836 | getDefaultMatchingURL | train | func (c *EndpointConfig) getDefaultMatchingURL(searchKey string) string {
if strings.Contains(searchKey, ":") {
return searchKey
}
return ""
} | go | {
"resource": ""
} |
q29837 | peerMSPID | train | func (c *EndpointConfig) peerMSPID(name string) (string, bool) {
var mspID string
// Find organisation/msp that peer belongs to
for _, org := range c.networkConfig.Organizations {
for i := 0; i < len(org.Peers); i++ {
if strings.EqualFold(org.Peers[i], name) {
// peer belongs to this org add org msp
msp... | go | {
"resource": ""
} |
q29838 | setDefault | train | func setDefault(dataMap map[string]interface{}, key string, defaultVal interface{}) {
_, ok := dataMap[key]
if !ok {
dataMap[key] = defaultVal
}
} | go | {
"resource": ""
} |
q29839 | WithUnmarshalHookFunction | train | func WithUnmarshalHookFunction(hookFunction mapstructure.DecodeHookFunc) UnmarshalOption {
return func(o *unmarshalOpts) {
o.hooks = append(o.hooks, hookFunction)
}
} | go | {
"resource": ""
} |
q29840 | Lookup | train | func (c *ConfigLookup) Lookup(key string) (interface{}, bool) {
//loop through each backend to find the value by key, fallback to next one if not found
for _, backend := range c.backends {
if backend == nil {
continue
}
val, ok := backend.Lookup(key)
if ok {
return val, true
}
}
return nil, false
} | go | {
"resource": ""
} |
q29841 | GetBool | train | func (c *ConfigLookup) GetBool(key string) bool {
value, ok := c.Lookup(key)
if !ok {
return false
}
return cast.ToBool(value)
} | go | {
"resource": ""
} |
q29842 | GetString | train | func (c *ConfigLookup) GetString(key string) string {
value, ok := c.Lookup(key)
if !ok {
return ""
}
return cast.ToString(value)
} | go | {
"resource": ""
} |
q29843 | GetLowerString | train | func (c *ConfigLookup) GetLowerString(key string) string {
value, ok := c.Lookup(key)
if !ok {
return ""
}
return strings.ToLower(cast.ToString(value))
} | go | {
"resource": ""
} |
q29844 | GetInt | train | func (c *ConfigLookup) GetInt(key string) int {
value, ok := c.Lookup(key)
if !ok {
return 0
}
return cast.ToInt(value)
} | go | {
"resource": ""
} |
q29845 | GetDuration | train | func (c *ConfigLookup) GetDuration(key string) time.Duration {
value, ok := c.Lookup(key)
if !ok {
return 0
}
return cast.ToDuration(value)
} | go | {
"resource": ""
} |
q29846 | UnmarshalKey | train | func (c *ConfigLookup) UnmarshalKey(key string, rawVal interface{}, opts ...UnmarshalOption) error {
value, ok := c.Lookup(key)
if !ok {
return nil
}
//mandatory hook func
var unmarshalHooks []mapstructure.DecodeHookFunc
unmarshalHooks = append(unmarshalHooks, mapstructure.StringToTimeDurationHookFunc())
//c... | go | {
"resource": ""
} |
q29847 | ShowCallerInfo | train | func (l *CallerInfo) ShowCallerInfo(module string, level api.Level) {
if l.showcaller == nil {
l.showcaller = l.getDefaultCallerInfoSetting()
}
l.showcaller[callerInfoKey{module, level}] = true
} | go | {
"resource": ""
} |
q29848 | HideCallerInfo | train | func (l *CallerInfo) HideCallerInfo(module string, level api.Level) {
if l.showcaller == nil {
l.showcaller = l.getDefaultCallerInfoSetting()
}
l.showcaller[callerInfoKey{module, level}] = false
} | go | {
"resource": ""
} |
q29849 | IsCallerInfoEnabled | train | func (l *CallerInfo) IsCallerInfoEnabled(module string, level api.Level) bool {
showcaller, exists := l.showcaller[callerInfoKey{module, level}]
if !exists {
//If no callerinfo setting exists, then look for default
showcaller, exists = l.showcaller[callerInfoKey{"", level}]
if !exists {
return true
}
}
r... | go | {
"resource": ""
} |
q29850 | getDefaultCallerInfoSetting | train | func (l *CallerInfo) getDefaultCallerInfoSetting() map[callerInfoKey]bool {
return map[callerInfoKey]bool{
{"", api.CRITICAL}: true,
{"", api.ERROR}: true,
{"", api.WARNING}: true,
{"", api.INFO}: true,
{"", api.DEBUG}: true,
}
} | go | {
"resource": ""
} |
q29851 | New | train | func New(context fabcontext.Client, chConfig fab.ChannelCfg, discoveryService fab.DiscoveryService, connectionProvider api.ConnectionProvider, opts ...options.Opt) *Dispatcher {
return &Dispatcher{
Dispatcher: clientdisp.New(context, chConfig, discoveryService, connectionProvider, opts...),
}
} | go | {
"resource": ""
} |
q29852 | Start | train | func (ed *Dispatcher) Start() error {
ed.registerHandlers()
if err := ed.Dispatcher.Start(); err != nil {
return errors.WithMessage(err, "error starting deliver event dispatcher")
}
return nil
} | go | {
"resource": ""
} |
q29853 | NewMockConfig | train | func NewMockConfig(channelID string, policy fab.EventServicePolicy) *fabmocks.MockConfig {
config := &fabmocks.MockConfig{}
config.SetCustomChannelConfig(channelID, &fab.ChannelEndpointConfig{
Policies: fab.ChannelPolicies{
EventService: policy,
},
})
return config
} | go | {
"resource": ""
} |
q29854 | NewRegisterConnectionEvent | train | func NewRegisterConnectionEvent(eventch chan<- *ConnectionEvent, regch chan<- fab.Registration, errch chan<- error) *RegisterConnectionEvent {
return &RegisterConnectionEvent{
Reg: &ConnectionReg{Eventch: eventch},
RegisterEvent: esdispatcher.NewRegisterEvent(regch, errch),
}
} | go | {
"resource": ""
} |
q29855 | NewFatalDisconnectedEvent | train | func NewFatalDisconnectedEvent(cause error) *DisconnectedEvent {
return &DisconnectedEvent{Err: &disconnectedError{cause: cause, fatal: true}}
} | go | {
"resource": ""
} |
q29856 | NewConnectionEvent | train | func NewConnectionEvent(connected bool, err DisconnectedError) *ConnectionEvent {
return &ConnectionEvent{Connected: connected, Err: err}
} | go | {
"resource": ""
} |
q29857 | FromReader | train | func FromReader(in io.Reader, configType string, opts ...Option) core.ConfigProvider {
return func() ([]core.ConfigBackend, error) {
return initFromReader(in, configType, opts...)
}
} | go | {
"resource": ""
} |
q29858 | FromFile | train | func FromFile(name string, opts ...Option) core.ConfigProvider {
return func() ([]core.ConfigBackend, error) {
backend, err := newBackend(opts...)
if err != nil {
return nil, err
}
if name == "" {
return nil, errors.New("filename is required")
}
// create new viper
backend.configViper.SetConfigFi... | go | {
"resource": ""
} |
q29859 | FromRaw | train | func FromRaw(configBytes []byte, configType string, opts ...Option) core.ConfigProvider {
return func() ([]core.ConfigBackend, error) {
buf := bytes.NewBuffer(configBytes)
return initFromReader(buf, configType, opts...)
}
} | go | {
"resource": ""
} |
q29860 | WithEnvPrefix | train | func WithEnvPrefix(prefix string) Option {
return func(opts *options) error {
opts.envPrefix = prefix
return nil
}
} | go | {
"resource": ""
} |
q29861 | setLogLevel | train | func setLogLevel(backend core.ConfigBackend) {
loggingLevelString, _ := backend.Lookup("client.logging.level")
logLevel := logging.INFO
if loggingLevelString != nil {
var err error
logLevel, err = logging.LogLevel(loggingLevelString.(string))
if err != nil {
panic(err)
}
}
// TODO: allow separate setti... | go | {
"resource": ""
} |
q29862 | CreateLocalDiscoveryProvider | train | func (f *ProviderFactory) CreateLocalDiscoveryProvider(config fab.EndpointConfig) (fab.LocalDiscoveryProvider, error) {
return discovery.NewLocalProvider(config)
} | go | {
"resource": ""
} |
q29863 | CreateChannelProvider | train | func (f *ProviderFactory) CreateChannelProvider(config fab.EndpointConfig, opts ...options.Opt) (fab.ChannelProvider, error) {
return chpvdr.New(config, opts...)
} | go | {
"resource": ""
} |
q29864 | New | train | func New(configProvider core.ConfigProvider, opts ...Option) (*FabricSDK, error) {
pkgSuite := defPkgSuite{}
return fromPkgSuite(configProvider, &pkgSuite, opts...)
} | go | {
"resource": ""
} |
q29865 | WithCorePkg | train | func WithCorePkg(core sdkApi.CoreProviderFactory) Option {
return func(opts *options) error {
opts.Core = core
return nil
}
} | go | {
"resource": ""
} |
q29866 | WithMSPPkg | train | func WithMSPPkg(msp sdkApi.MSPProviderFactory) Option {
return func(opts *options) error {
opts.MSP = msp
return nil
}
} | go | {
"resource": ""
} |
q29867 | WithServicePkg | train | func WithServicePkg(service sdkApi.ServiceProviderFactory) Option {
return func(opts *options) error {
opts.Service = service
return nil
}
} | go | {
"resource": ""
} |
q29868 | WithLoggerPkg | train | func WithLoggerPkg(logger api.LoggerProvider) Option {
return func(opts *options) error {
opts.Logger = logger
return nil
}
} | go | {
"resource": ""
} |
q29869 | WithProviderOpts | train | func WithProviderOpts(sopts ...coptions.Opt) Option {
return func(opts *options) error {
opts.ProviderOpts = append(opts.ProviderOpts, sopts...)
return nil
}
} | go | {
"resource": ""
} |
q29870 | Close | train | func (sdk *FabricSDK) Close() {
logger.Debug("SDK closing")
if pvdr, ok := sdk.provider.LocalDiscoveryProvider().(closeable); ok {
pvdr.Close()
}
if pvdr, ok := sdk.provider.ChannelProvider().(closeable); ok {
pvdr.Close()
}
sdk.provider.InfraProvider().Close()
} | go | {
"resource": ""
} |
q29871 | CloseContext | train | func (sdk *FabricSDK) CloseContext(ctxt fab.ClientContext) {
logger.Debug("Closing clients for the given context...")
if pvdr, ok := sdk.provider.LocalDiscoveryProvider().(contextCloseable); ok {
logger.Debugf("Closing local discovery provider...")
pvdr.CloseContext(ctxt)
}
if pvdr, ok := sdk.provider.ChannelPr... | go | {
"resource": ""
} |
q29872 | Config | train | func (sdk *FabricSDK) Config() (core.ConfigBackend, error) {
if sdk.opts.ConfigBackend == nil {
return nil, errors.New("unable to find config backend")
}
return lookup.New(sdk.opts.ConfigBackend...), nil
} | go | {
"resource": ""
} |
q29873 | Context | train | func (sdk *FabricSDK) Context(options ...ContextOption) contextApi.ClientProvider {
clientProvider := func() (contextApi.Client, error) {
identity, err := sdk.newIdentity(options...)
if err == ErrAnonymousIdentity {
identity = nil
err = nil
}
return &context.Client{Providers: sdk.provider, SigningIdenti... | go | {
"resource": ""
} |
q29874 | ChannelContext | train | func (sdk *FabricSDK) ChannelContext(channelID string, options ...ContextOption) contextApi.ChannelProvider {
channelProvider := func() (contextApi.Channel, error) {
clientCtxProvider := sdk.Context(options...)
return context.NewChannel(clientCtxProvider, channelID)
}
return channelProvider
} | go | {
"resource": ""
} |
q29875 | initializeCryptoSuite | train | func (sdk *FabricSDK) initializeCryptoSuite(cryptoSuiteConfig core.CryptoSuiteConfig) error {
var err error
sdk.cryptoSuite, err = sdk.opts.Core.CreateCryptoSuiteProvider(cryptoSuiteConfig)
if err != nil {
return errors.WithMessage(err, "failed to initialize crypto suite")
}
// Setting this cryptosuite as the f... | go | {
"resource": ""
} |
q29876 | loadConfigs | train | func (sdk *FabricSDK) loadConfigs(configProvider core.ConfigProvider) (*configs, error) {
c := &configs{
identityConfig: sdk.opts.IdentityConfig,
endpointConfig: sdk.opts.endpointConfig,
cryptoSuiteConfig: sdk.opts.CryptoSuiteConfig,
metricsConfig: sdk.opts.metricsConfig,
}
var configBackend []cor... | go | {
"resource": ""
} |
q29877 | loadEndpointConfig | train | func (sdk *FabricSDK) loadEndpointConfig(configBackend ...core.ConfigBackend) (fab.EndpointConfig, error) {
endpointConfigOpt, ok := sdk.opts.endpointConfig.(*fabImpl.EndpointConfigOptions)
// if optional endpoint was nil or not all of its sub interface functions were overridden,
// then get default endpoint config... | go | {
"resource": ""
} |
q29878 | NewRef | train | func NewRef(refresh time.Duration, context Context, chConfigRef *lazyref.Reference) *Ref {
ref := &Ref{
chConfigRef: chConfigRef,
context: context,
}
ref.Reference = lazyref.New(
ref.initializer(),
lazyref.WithRefreshInterval(lazyref.InitImmediately, refresh),
)
return ref
} | go | {
"resource": ""
} |
q29879 | Validate | train | func (ref *Ref) Validate(serializedID []byte) error {
membership, err := ref.get()
if err != nil {
return err
}
return membership.Validate(serializedID)
} | go | {
"resource": ""
} |
q29880 | Verify | train | func (ref *Ref) Verify(serializedID []byte, msg []byte, sig []byte) error {
membership, err := ref.get()
if err != nil {
return err
}
return membership.Verify(serializedID, msg, sig)
} | go | {
"resource": ""
} |
q29881 | ContainsMSP | train | func (ref *Ref) ContainsMSP(msp string) bool {
membership, err := ref.get()
if err != nil {
logger.Debugf("Failed to check ContainsMSP, err: %s", err)
return false
}
return membership.ContainsMSP(msp)
} | go | {
"resource": ""
} |
q29882 | CreateChaincodeInvokeProposal | train | func CreateChaincodeInvokeProposal(txh fab.TransactionHeader, request fab.ChaincodeInvokeRequest) (*fab.TransactionProposal, error) {
if request.ChaincodeID == "" {
return nil, errors.New("ChaincodeID is required")
}
if request.Fcn == "" {
return nil, errors.New("Fcn is required")
}
// Add function name to a... | go | {
"resource": ""
} |
q29883 | signProposal | train | func signProposal(ctx contextApi.Client, proposal *pb.Proposal) (*pb.SignedProposal, error) {
proposalBytes, err := proto.Marshal(proposal)
if err != nil {
return nil, errors.Wrap(err, "mashal proposal failed")
}
signingMgr := ctx.SigningManager()
if signingMgr == nil {
return nil, errors.New("signing manager... | go | {
"resource": ""
} |
q29884 | SendProposal | train | func SendProposal(reqCtx reqContext.Context, proposal *fab.TransactionProposal, targets []fab.ProposalProcessor) ([]*fab.TransactionProposalResponse, error) {
if proposal == nil {
return nil, errors.New("proposal is required")
}
if len(targets) < 1 {
return nil, errors.New("targets is required")
}
for _, p ... | go | {
"resource": ""
} |
q29885 | getTargetsWithoutDuplicates | train | func getTargetsWithoutDuplicates(targets []fab.ProposalProcessor) []fab.ProposalProcessor {
peerUrlsToTargets := map[string]fab.ProposalProcessor{}
var uniqueTargets []fab.ProposalProcessor
for i := range targets {
peer, ok := targets[i].(fab.Peer)
if !ok {
// ProposalProcessor is not a fab.Peer... cannot re... | go | {
"resource": ""
} |
q29886 | IsTLSEnabled | train | func IsTLSEnabled(url string) bool {
tlsURL := strings.ToLower(url)
if strings.HasPrefix(tlsURL, "https://") || strings.HasPrefix(tlsURL, "grpcs://") {
return true
}
return false
} | go | {
"resource": ""
} |
q29887 | ToAddress | train | func ToAddress(url string) string {
if strings.HasPrefix(url, "grpc://") {
return strings.TrimPrefix(url, "grpc://")
}
if strings.HasPrefix(url, "grpcs://") {
return strings.TrimPrefix(url, "grpcs://")
}
return url
} | go | {
"resource": ""
} |
q29888 | AttemptSecured | train | func AttemptSecured(url string, allowInSecure bool) bool {
ok, err := regexp.MatchString(".*(?i)s://", url)
if ok && err == nil {
return true
} else if strings.Contains(url, "://") {
return false
} else {
return !allowInSecure
}
} | go | {
"resource": ""
} |
q29889 | WithCA | train | func WithCA(caname string) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
o.CA = caname
return nil
}
} | go | {
"resource": ""
} |
q29890 | New | train | func New(clientProvider context.ClientProvider, opts ...ClientOption) (*Client, error) {
ctx, err := clientProvider()
if err != nil {
return nil, errors.WithMessage(err, "failed to create Client")
}
msp := Client{
ctx: ctx,
}
for _, param := range opts {
err := param(&msp)
if err != nil {
return nil... | go | {
"resource": ""
} |
q29891 | WithSecret | train | func WithSecret(secret string) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.secret = secret
return nil
}
} | go | {
"resource": ""
} |
q29892 | WithProfile | train | func WithProfile(profile string) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.profile = profile
return nil
}
} | go | {
"resource": ""
} |
q29893 | WithType | train | func WithType(typ string) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.typ = typ
return nil
}
} | go | {
"resource": ""
} |
q29894 | WithLabel | train | func WithLabel(label string) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.label = label
return nil
}
} | go | {
"resource": ""
} |
q29895 | WithAttributeRequests | train | func WithAttributeRequests(attrReqs []*AttributeRequest) EnrollmentOption {
return func(o *enrollmentOptions) error {
o.attrReqs = attrReqs
return nil
}
} | go | {
"resource": ""
} |
q29896 | prepareOptsFromOptions | train | func (c *Client) prepareOptsFromOptions(ctx context.Client, options ...RequestOption) (requestOptions, error) {
opts := requestOptions{}
for _, option := range options {
err := option(ctx, &opts)
if err != nil {
return opts, errors.WithMessage(err, "Failed to read opts")
}
}
return opts, nil
} | go | {
"resource": ""
} |
q29897 | ModifyAffiliation | train | func (c *Client) ModifyAffiliation(request *ModifyAffiliationRequest) (*AffiliationResponse, error) {
ca, err := newCAClient(c.ctx, c.orgName)
if err != nil {
return nil, err
}
req := &mspapi.ModifyAffiliationRequest{
NewName: request.NewName,
AffiliationRequest: mspapi.AffiliationRequest{
Name: request... | go | {
"resource": ""
} |
q29898 | WithSeekType | train | func WithSeekType(value seek.Type) options.Opt {
return func(p options.Params) {
if setter, ok := p.(seekTypeSetter); ok {
setter.SetSeekType(value)
}
}
} | go | {
"resource": ""
} |
q29899 | WithBlockNum | train | func WithBlockNum(value uint64) options.Opt {
return func(p options.Params) {
if setter, ok := p.(fromBlockSetter); ok {
setter.SetFromBlock(value)
}
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.