_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q29600 | RegisterFilteredBlockEvent | train | func (s *Service) RegisterFilteredBlockEvent() (fab.Registration, <-chan *fab.FilteredBlockEvent, error) {
eventch := make(chan *fab.FilteredBlockEvent, s.eventConsumerBufferSize)
regch := make(chan fab.Registration)
errch := make(chan error)
if err := s.Submit(dispatcher.NewRegisterFilteredBlockEvent(eventch, reg... | go | {
"resource": ""
} |
q29601 | RegisterChaincodeEvent | train | func (s *Service) RegisterChaincodeEvent(ccID, eventFilter string) (fab.Registration, <-chan *fab.CCEvent, error) {
if ccID == "" {
return nil, nil, errors.New("chaincode ID is required")
}
if eventFilter == "" {
return nil, nil, errors.New("event filter is required")
}
eventch := make(chan *fab.CCEvent, s.ev... | go | {
"resource": ""
} |
q29602 | RegisterTxStatusEvent | train | func (s *Service) RegisterTxStatusEvent(txID string) (fab.Registration, <-chan *fab.TxStatusEvent, error) {
if txID == "" {
return nil, nil, errors.New("txID must be provided")
}
eventch := make(chan *fab.TxStatusEvent, s.eventConsumerBufferSize)
regch := make(chan fab.Registration)
errch := make(chan error)
... | go | {
"resource": ""
} |
q29603 | Unregister | train | func (s *Service) Unregister(reg fab.Registration) {
if err := s.Submit(dispatcher.NewUnregisterEvent(reg)); err != nil {
logger.Warnf("Error unregistering: %s", err)
}
} | go | {
"resource": ""
} |
q29604 | NewBlock | train | func (p *BlockProducer) NewBlock(channelID string, transactions ...*TxInfo) *cb.Block {
block := NewBlock(channelID, transactions...)
block.Header.Number = p.blockNum
atomic.AddUint64(&p.blockNum, 1)
return block
} | go | {
"resource": ""
} |
q29605 | NewFilteredBlock | train | func (p *BlockProducer) NewFilteredBlock(channelID string, filteredTx ...*pb.FilteredTransaction) *pb.FilteredBlock {
block := NewFilteredBlock(channelID, filteredTx...)
block.Number = p.blockNum
atomic.AddUint64(&p.blockNum, 1)
return block
} | go | {
"resource": ""
} |
q29606 | New | train | func New(ctx Context, cfg fab.ChannelCfg) (fab.ChannelMembership, error) {
mspManager, mspNames, err := createMSPManager(ctx, cfg)
if err != nil {
return nil, err
}
return &identityImpl{mspManager: mspManager, msps: mspNames}, nil
} | go | {
"resource": ""
} |
q29607 | addCertsToConfig | train | func addCertsToConfig(config fab.EndpointConfig, pemCertsList [][]byte) {
if len(pemCertsList) == 0 {
return
}
var certs []*x509.Certificate
for _, pemCerts := range pemCertsList {
for len(pemCerts) > 0 {
var block *pem.Block
block, pemCerts = pem.Decode(pemCerts)
if block == nil {
break
}
... | go | {
"resource": ""
} |
q29608 | DialContext | train | func (m *MockCommManager) DialContext(ctx context.Context, target string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
return grpc.DialContext(ctx, target, opts...)
} | go | {
"resource": ""
} |
q29609 | ReleaseConn | train | func (m *MockCommManager) ReleaseConn(conn *grpc.ClientConn) {
if err := conn.Close(); err != nil {
logger.Warnf("Error closing connection: %s", err)
}
} | go | {
"resource": ""
} |
q29610 | NewCCPackage | train | func NewCCPackage(chaincodePath string, goPath string) (*resource.CCPackage, error) {
if chaincodePath == "" {
return nil, errors.New("chaincode path must be provided")
}
var projDir string
gp := goPath
if gp == "" {
gp = defaultGoPath()
if gp == "" {
return nil, errors.New("GOPATH not defined")
}
l... | go | {
"resource": ""
} |
q29611 | defaultGoPath | train | func defaultGoPath() string {
gpDefault := build.Default.GOPATH
gps := filepath.SplitList(gpDefault)
return gps[0]
} | go | {
"resource": ""
} |
q29612 | NewMockProducer | train | func NewMockProducer(ledger Ledger) *MockProducer {
c := &MockProducer{
rcvch: make(chan interface{}, 100),
ledger: ledger,
}
go c.listen()
ledger.Register(c.rcvch)
return c
} | go | {
"resource": ""
} |
q29613 | Close | train | func (c *MockProducer) Close() {
if !atomic.CompareAndSwapInt32(&c.closed, 0, 1) {
// Already closed
return
}
c.ledger.Unregister(c.rcvch)
close(c.rcvch)
} | go | {
"resource": ""
} |
q29614 | Register | train | func (c *MockProducer) Register() <-chan interface{} {
c.Lock()
defer c.Unlock()
eventch := make(chan interface{})
c.eventChannels = append(c.eventChannels, eventch)
return eventch
} | go | {
"resource": ""
} |
q29615 | Unregister | train | func (c *MockProducer) Unregister(eventch chan<- interface{}) {
c.Lock()
defer c.Unlock()
for i, e := range c.eventChannels {
if e == eventch {
if i != 0 {
c.eventChannels = c.eventChannels[1:]
}
c.eventChannels = c.eventChannels[1:]
close(eventch)
return
}
}
} | go | {
"resource": ""
} |
q29616 | New | train | func New(config fab.EndpointConfig, opts ...options.Opt) (*ChannelProvider, error) {
return &ChannelProvider{
ctxtCaches: lazycache.New(
"Client_Context_Cache",
func(key lazycache.Key) (interface{}, error) {
ck := key.(*ctxtCacheKey)
return newContextCache(ck.context, opts), nil
},
),
}, nil
} | go | {
"resource": ""
} |
q29617 | ChannelService | train | func (cp *ChannelProvider) ChannelService(ctx fab.ClientContext, channelID string) (fab.ChannelService, error) {
key, err := newCtxtCacheKey(ctx)
if err != nil {
return nil, err
}
ctxtCache, err := cp.ctxtCaches.Get(key)
if err != nil {
// This should never happen since the creation of a cache never returns a... | go | {
"resource": ""
} |
q29618 | Config | train | func (cs *ChannelService) Config() (fab.ChannelConfig, error) {
return chconfig.New(cs.channelID)
} | go | {
"resource": ""
} |
q29619 | EventService | train | func (cs *ChannelService) EventService(opts ...options.Opt) (fab.EventService, error) {
return cs.ctxtCache.GetEventService(cs.channelID, opts...)
} | go | {
"resource": ""
} |
q29620 | Membership | train | func (cs *ChannelService) Membership() (fab.ChannelMembership, error) {
return cs.ctxtCache.GetMembership(cs.channelID)
} | go | {
"resource": ""
} |
q29621 | ChannelConfig | train | func (cs *ChannelService) ChannelConfig() (fab.ChannelCfg, error) {
return cs.ctxtCache.GetChannelConfig(cs.channelID)
} | go | {
"resource": ""
} |
q29622 | Transactor | train | func (cs *ChannelService) Transactor(reqCtx reqContext.Context) (fab.Transactor, error) {
cfg, err := cs.ChannelConfig()
if err != nil {
return nil, err
}
return channelImpl.NewTransactor(reqCtx, cfg)
} | go | {
"resource": ""
} |
q29623 | Discovery | train | func (cs *ChannelService) Discovery() (fab.DiscoveryService, error) {
return cs.ctxtCache.GetDiscoveryService(cs.channelID)
} | go | {
"resource": ""
} |
q29624 | Selection | train | func (cs *ChannelService) Selection() (fab.SelectionService, error) {
return cs.ctxtCache.GetSelectionService(cs.channelID)
} | go | {
"resource": ""
} |
q29625 | GetPrivateKeyFromCert | train | func GetPrivateKeyFromCert(cert []byte, cs core.CryptoSuite) (core.Key, error) {
// get the public key in the right format
certPubK, err := GetPublicKeyFromCert(cert, cs)
if err != nil {
return nil, errors.WithMessage(err, "Failed to import certificate's public key")
}
if certPubK == nil || certPubK.SKI() == n... | go | {
"resource": ""
} |
q29626 | GetPublicKeyFromCert | train | func GetPublicKeyFromCert(cert []byte, cs core.CryptoSuite) (core.Key, error) {
dcert, _ := pem.Decode(cert)
if dcert == nil {
return nil, errors.Errorf("Unable to decode cert bytes [%v]", cert)
}
x509Cert, err := x509.ParseCertificate(dcert.Bytes)
if err != nil {
return nil, errors.Errorf("Unable to parse c... | go | {
"resource": ""
} |
q29627 | NewMockDiscoveryProvider | train | func NewMockDiscoveryProvider(err error, peers []fab.Peer) (*MockStaticDiscoveryProvider, error) {
return &MockStaticDiscoveryProvider{Error: err, Peers: peers}, nil
} | go | {
"resource": ""
} |
q29628 | CreateLocalDiscoveryService | train | func (dp *MockStaticDiscoveryProvider) CreateLocalDiscoveryService(mspID string) (fab.DiscoveryService, error) {
return &MockStaticDiscoveryService{Error: dp.Error, Peers: dp.Peers}, nil
} | go | {
"resource": ""
} |
q29629 | NewMockDiscoveryService | train | func NewMockDiscoveryService(err error, peers ...fab.Peer) *MockStaticDiscoveryService {
return &MockStaticDiscoveryService{Error: err, Peers: peers}
} | go | {
"resource": ""
} |
q29630 | New | train | func New(name string, initializer EntryInitializer, opts ...options.Opt) *Cache {
return NewWithData(name,
func(key Key, data interface{}) (interface{}, error) {
return initializer(key)
},
opts...,
)
} | go | {
"resource": ""
} |
q29631 | Get | train | func (c *Cache) Get(key Key, data ...interface{}) (interface{}, error) {
keyStr := key.String()
f, ok := c.m.Load(keyStr)
if ok {
v, err := f.(future).Get()
if err != nil {
return nil, err
}
return c.value(v, first(data))
}
// The key wasn't found. Attempt to add one.
newFuture := futurevalue.New(
... | go | {
"resource": ""
} |
q29632 | MustGet | train | func (c *Cache) MustGet(key Key) interface{} {
value, err := c.Get(key)
if err != nil {
panic(fmt.Sprintf("error returned from Get: %s", err))
}
return value
} | go | {
"resource": ""
} |
q29633 | useLazyRef | train | func useLazyRef(opts ...options.Opt) bool {
chk := &refOptCheck{}
options.Apply(chk, opts)
return chk.useRef
} | go | {
"resource": ""
} |
q29634 | New | train | func New(opts Opts) Handler {
if len(opts.RetryableCodes) == 0 {
opts.RetryableCodes = DefaultRetryableCodes
}
return &impl{opts: opts}
} | go | {
"resource": ""
} |
q29635 | WithAttempts | train | func WithAttempts(attempts int) Handler {
opts := DefaultOpts
opts.Attempts = attempts
return &impl{opts: opts}
} | go | {
"resource": ""
} |
q29636 | backoffPeriod | train | func (i *impl) backoffPeriod() time.Duration {
backoff, max := float64(i.opts.InitialBackoff), float64(i.opts.MaxBackoff)
for j := 0; j < i.retries && backoff < max; j++ {
backoff *= i.opts.BackoffFactor
}
if backoff > max {
backoff = max
}
return time.Duration(backoff)
} | go | {
"resource": ""
} |
q29637 | isRetryable | train | func (i *impl) isRetryable(g status.Group, c int32) bool {
for group, codes := range i.opts.RetryableCodes {
if g != group {
continue
}
for _, code := range codes {
if status.Code(c) == code {
return true
}
}
}
return false
} | go | {
"resource": ""
} |
q29638 | NewConnection | train | func NewConnection(ctx fabcontext.Client, url string, opts ...options.Opt) (*GRPCConnection, error) {
if url == "" {
return nil, errors.New("server URL not specified")
}
params := defaultParams()
options.Apply(params, opts)
dialOpts, err := newDialOpts(ctx.EndpointConfig(), url, params)
if err != nil {
retu... | go | {
"resource": ""
} |
q29639 | NewMockLocalContext | train | func NewMockLocalContext(client *MockContext, discoveryProvider fab.LocalDiscoveryProvider) *LocalContext {
var localDiscovery fab.DiscoveryService
if discoveryProvider != nil {
var err error
localDiscovery, err = discoveryProvider.CreateLocalDiscoveryService(client.Identifier().MSPID)
if err != nil {
panic(... | go | {
"resource": ""
} |
q29640 | Choose | train | func (lbp *Random) Choose(peers []fab.Peer) (fab.Peer, error) {
if len(peers) == 0 {
logger.Warn("No peers to choose from!")
return nil, nil
}
index := rand.Intn(len(peers))
logger.Debugf("Choosing peer at index %d", index)
return peers[index], nil
} | go | {
"resource": ""
} |
q29641 | WithIdleExpiration | train | func WithIdleExpiration(value time.Duration) options.Opt {
return func(p options.Params) {
logger.Debug("Checking idleExpirationSetter")
if setter, ok := p.(idleExpirationSetter); ok {
setter.SetIdleExpiration(value)
}
}
} | go | {
"resource": ""
} |
q29642 | WithAbsoluteExpiration | train | func WithAbsoluteExpiration(value time.Duration) options.Opt {
return func(p options.Params) {
logger.Debug("Checking absoluteExpirationSetter")
if setter, ok := p.(absoluteExpirationSetter); ok {
setter.SetAbsoluteExpiration(value)
}
}
} | go | {
"resource": ""
} |
q29643 | WithExpirationProvider | train | func WithExpirationProvider(expirationProvider ExpirationProvider, expiryType ExpirationType) options.Opt {
return func(p options.Params) {
logger.Debug("Checking expirationProviderSetter")
if setter, ok := p.(expirationProviderSetter); ok {
setter.SetExpirationProvider(expirationProvider, expiryType)
}
}
} | go | {
"resource": ""
} |
q29644 | WithFinalizer | train | func WithFinalizer(finalizer Finalizer) options.Opt {
return func(p options.Params) {
logger.Debug("Checking finalizerSetter")
if setter, ok := p.(finalizerSetter); ok {
setter.SetFinalizer(finalizer)
}
}
} | go | {
"resource": ""
} |
q29645 | WithRefreshInterval | train | func WithRefreshInterval(initialInit, refreshPeriod time.Duration) options.Opt {
return func(p options.Params) {
logger.Debug("Checking refreshIntervalSetter")
if setter, ok := p.(refreshIntervalSetter); ok {
setter.SetRefreshInterval(initialInit, refreshPeriod)
}
}
} | go | {
"resource": ""
} |
q29646 | SearchPeerConfigFromURL | train | func SearchPeerConfigFromURL(cfg fab.EndpointConfig, url string) (*fab.PeerConfig, error) {
peerCfg, ok := cfg.PeerConfig(url)
if ok {
return peerCfg, nil
}
//If the given url is already parsed URL through entity matcher, then 'cfg.PeerConfig()'
//may return NoMatchingPeerEntity error. So retry with network pe... | go | {
"resource": ""
} |
q29647 | MSPID | train | func MSPID(cfg fab.EndpointConfig, org string) (string, bool) {
networkConfig := cfg.NetworkConfig()
//check for nil since any endpointconfig implementation can be passed here
if networkConfig == nil {
return "", false
}
// viper lowercases all key maps, org is lower case
mspID := networkConfig.Organizations[st... | go | {
"resource": ""
} |
q29648 | NewLocalProvider | train | func NewLocalProvider(config fab.EndpointConfig, opts ...coptions.Opt) *LocalProvider {
return &LocalProvider{
cache: lazycache.New("Local_Discovery_Service_Cache", func(key lazycache.Key) (interface{}, error) {
return newLocalService(config, key.String(), opts...), nil
}),
}
} | go | {
"resource": ""
} |
q29649 | CreateLocalDiscoveryService | train | func (p *LocalProvider) CreateLocalDiscoveryService(mspID string) (fab.DiscoveryService, error) {
ref, err := p.cache.Get(lazycache.NewStringKey(mspID))
if err != nil {
return nil, errors.WithMessage(err, "failed to get local discovery service from cache")
}
return ref.(fab.DiscoveryService), nil
} | go | {
"resource": ""
} |
q29650 | FromError | train | func FromError(err error) (s *Status, ok bool) {
if err == nil {
return &Status{Code: int32(OK)}, true
}
if s, ok := err.(*Status); ok {
return s, true
}
unwrappedErr := errors.Cause(err)
if s, ok := unwrappedErr.(*Status); ok {
return s, true
}
if m, ok := unwrappedErr.(multi.Errors); ok {
// Return al... | go | {
"resource": ""
} |
q29651 | New | train | func New(group Group, code int32, msg string, details []interface{}) *Status {
return &Status{Group: group, Code: code, Message: msg, Details: details}
} | go | {
"resource": ""
} |
q29652 | NewFromProposalResponse | train | func NewFromProposalResponse(res *pb.ProposalResponse, endorser string) *Status {
if res == nil {
return nil
}
details := []interface{}{endorser, res.Response.Payload}
return New(EndorserServerStatus, res.Response.Status, res.Response.Message, details)
} | go | {
"resource": ""
} |
q29653 | NewFromGRPCStatus | train | func NewFromGRPCStatus(s *grpcstatus.Status) *Status {
if s == nil {
return nil
}
details := make([]interface{}, len(s.Proto().Details))
for i, detail := range s.Proto().Details {
details[i] = detail
}
return &Status{Group: GRPCTransportStatus, Code: s.Proto().Code,
Message: s.Message(), Details: details}
... | go | {
"resource": ""
} |
q29654 | NewFromExtractedChaincodeError | train | func NewFromExtractedChaincodeError(code int, message string) *Status {
return &Status{Group: ChaincodeStatus, Code: int32(code),
Message: message, Details: nil}
} | go | {
"resource": ""
} |
q29655 | New | train | func New(config fab.EndpointConfig) *InfraProvider {
idleTime := config.Timeout(fab.ConnectionIdle)
sweepTime := config.Timeout(fab.CacheSweepInterval)
return &InfraProvider{
commManager: comm.NewCachingConnector(sweepTime, idleTime),
}
} | go | {
"resource": ""
} |
q29656 | NewGroupOfGroups | train | func NewGroupOfGroups(groups []Group) GroupOfGroups {
items := make([]Item, len(groups))
for i, g := range groups {
items[i] = g
}
return &groupsImpl{groupImpl: groupImpl{Itms: items}}
} | go | {
"resource": ""
} |
q29657 | NewMSPPeerGroup | train | func NewMSPPeerGroup(mspID string, peerRetriever MSPPeerRetriever) PeerGroup {
return &mspPeerGroup{
mspID: mspID,
peerRetriever: peerRetriever,
}
} | go | {
"resource": ""
} |
q29658 | asGroupsOrPanic | train | func asGroupsOrPanic(items []Item) []Group {
groups := make([]Group, len(items))
for i, item := range items {
if grp, ok := item.(Group); ok {
groups[i] = grp
} else {
panic(fmt.Sprintf("item is not a group: %s", reflect.TypeOf(item)))
}
}
return groups
} | go | {
"resource": ""
} |
q29659 | KeyGen | train | func (c *CryptoSuite) KeyGen(opts core.KeyGenOpts) (k core.Key, err error) {
key, err := c.BCCSP.KeyGen(opts)
return GetKey(key), err
} | go | {
"resource": ""
} |
q29660 | KeyImport | train | func (c *CryptoSuite) KeyImport(raw interface{}, opts core.KeyImportOpts) (k core.Key, err error) {
key, err := c.BCCSP.KeyImport(raw, opts)
return GetKey(key), err
} | go | {
"resource": ""
} |
q29661 | GetKey | train | func (c *CryptoSuite) GetKey(ski []byte) (k core.Key, err error) {
key, err := c.BCCSP.GetKey(ski)
return GetKey(key), err
} | go | {
"resource": ""
} |
q29662 | Hash | train | func (c *CryptoSuite) Hash(msg []byte, opts core.HashOpts) (hash []byte, err error) {
return c.BCCSP.Hash(msg, opts)
} | go | {
"resource": ""
} |
q29663 | GetHash | train | func (c *CryptoSuite) GetHash(opts core.HashOpts) (h hash.Hash, err error) {
return c.BCCSP.GetHash(opts)
} | go | {
"resource": ""
} |
q29664 | Sign | train | func (c *CryptoSuite) Sign(k core.Key, digest []byte, opts core.SignerOpts) (signature []byte, err error) {
return c.BCCSP.Sign(k.(*key).key, digest, opts)
} | go | {
"resource": ""
} |
q29665 | Verify | train | func (c *CryptoSuite) Verify(k core.Key, signature, digest []byte, opts core.SignerOpts) (valid bool, err error) {
return c.BCCSP.Verify(k.(*key).key, signature, digest, opts)
} | go | {
"resource": ""
} |
q29666 | NewBlockEvent | train | func NewBlockEvent(block *cb.Block, sourceURL string) *connection.Event {
return connection.NewEvent(
&pb.DeliverResponse{
Type: &pb.DeliverResponse_Block{
Block: block,
},
}, sourceURL,
)
} | go | {
"resource": ""
} |
q29667 | NewFilteredBlockEvent | train | func NewFilteredBlockEvent(fblock *pb.FilteredBlock, sourceURL string) *connection.Event {
return connection.NewEvent(
&pb.DeliverResponse{
Type: &pb.DeliverResponse_FilteredBlock{
FilteredBlock: fblock,
},
}, sourceURL,
)
} | go | {
"resource": ""
} |
q29668 | WithTargetFilter | train | func WithTargetFilter(filter fab.TargetFilter) Opt {
return func(p *DiscoveryWrapper) {
p.filter = filter
}
} | go | {
"resource": ""
} |
q29669 | NewEndpointDiscoveryWrapper | train | func NewEndpointDiscoveryWrapper(ctx context.Client, channelID string, target fab.DiscoveryService, opts ...Opt) (*DiscoveryWrapper, error) {
chpeers := ctx.EndpointConfig().ChannelPeers(channelID)
if len(chpeers) == 0 {
return nil, errors.Errorf("no channel peers for channel [%s]", channelID)
}
s := &DiscoveryW... | go | {
"resource": ""
} |
q29670 | GetPeers | train | func (s *DiscoveryWrapper) GetPeers() ([]fab.Peer, error) {
var eventEndpoints []fab.Peer
peers, err := s.DiscoveryService.GetPeers()
if err != nil {
return nil, err
}
for _, peer := range peers {
var peerConfig *fab.PeerConfig
var found bool
chPeer := s.getChannelPeer(peer.URL())
if chPeer != nil {
... | go | {
"resource": ""
} |
q29671 | NewMockCAClient | train | func NewMockCAClient(orgName string, cryptoProvider core.CryptoSuite) (api.CAClient, error) {
mcm := MockCAClient{}
return &mcm, nil
} | go | {
"resource": ""
} |
q29672 | Register | train | func (mgr *MockCAClient) Register(request *api.RegistrationRequest) (string, error) {
return "", errors.New("not implemented")
} | go | {
"resource": ""
} |
q29673 | Revoke | train | func (mgr *MockCAClient) Revoke(request *api.RevocationRequest) (*api.RevocationResponse, error) {
return nil, errors.New("not implemented")
} | go | {
"resource": ""
} |
q29674 | CreateIdentity | train | func (mgr *MockCAClient) CreateIdentity(request *api.IdentityRequest) (*api.IdentityResponse, error) {
return nil, errors.New("not implemented")
} | go | {
"resource": ""
} |
q29675 | GetIdentity | train | func (mgr *MockCAClient) GetIdentity(id, caname string) (*api.IdentityResponse, error) {
return nil, errors.New("not implemented")
} | go | {
"resource": ""
} |
q29676 | GetAllIdentities | train | func (mgr *MockCAClient) GetAllIdentities(caname string) ([]*api.IdentityResponse, error) {
return nil, errors.New("not implemented")
} | go | {
"resource": ""
} |
q29677 | RemoveIdentity | train | func (mgr *MockCAClient) RemoveIdentity(request *api.RemoveIdentityRequest) (*api.IdentityResponse, error) {
return nil, errors.New("not implemented")
} | go | {
"resource": ""
} |
q29678 | GetAllAffiliations | train | func (mgr *MockCAClient) GetAllAffiliations(caname string) (*api.AffiliationResponse, error) {
return nil, errors.New("not implemented")
} | go | {
"resource": ""
} |
q29679 | GetAffiliation | train | func (mgr *MockCAClient) GetAffiliation(affiliation, caname string) (*api.AffiliationResponse, error) {
return nil, errors.New("not implemented")
} | go | {
"resource": ""
} |
q29680 | ModifyAffiliation | train | func (mgr *MockCAClient) ModifyAffiliation(request *api.ModifyAffiliationRequest) (*api.AffiliationResponse, error) {
return nil, errors.New("not implemented")
} | go | {
"resource": ""
} |
q29681 | RemoveAffiliation | train | func (mgr *MockCAClient) RemoveAffiliation(request *api.AffiliationRequest) (*api.AffiliationResponse, error) {
return nil, errors.New("not implemented")
} | go | {
"resource": ""
} |
q29682 | KeyGen | train | func (m *MockCryptoSuite) KeyGen(opts core.KeyGenOpts) (k core.Key, err error) {
return nil, nil
} | go | {
"resource": ""
} |
q29683 | KeyImport | train | func (m *MockCryptoSuite) KeyImport(raw interface{},
opts core.KeyImportOpts) (k core.Key, err error) {
return nil, nil
} | go | {
"resource": ""
} |
q29684 | GetKey | train | func (m *MockCryptoSuite) GetKey(ski []byte) (k core.Key, err error) {
return nil, nil
} | go | {
"resource": ""
} |
q29685 | Hash | train | func (m *MockCryptoSuite) Hash(msg []byte, opts core.HashOpts) (hash []byte, err error) {
return nil, nil
} | go | {
"resource": ""
} |
q29686 | GetHash | train | func (m *MockCryptoSuite) GetHash(opts core.HashOpts) (hash.Hash, error) {
return sha256.New(), nil
} | go | {
"resource": ""
} |
q29687 | Sign | train | func (m *MockCryptoSuite) Sign(k core.Key, digest []byte,
opts core.SignerOpts) (signature []byte, err error) {
return []byte("testSignature"), nil
} | go | {
"resource": ""
} |
q29688 | Verify | train | func (m *MockCryptoSuite) Verify(k core.Key, signature, digest []byte, opts core.SignerOpts) (valid bool, err error) {
return true, nil
} | go | {
"resource": ""
} |
q29689 | CAConfig | train | func (c *IdentityConfig) CAConfig(org string) (*msp.CAConfig, bool) {
caConfigs, ok := c.caConfigsByOrg[strings.ToLower(org)]
if ok {
//for now, we're only loading the first Cert Authority by default.
return caConfigs[0], true
}
return nil, false
} | go | {
"resource": ""
} |
q29690 | CAClientCert | train | func (c *IdentityConfig) CAClientCert(org string) ([]byte, bool) {
caConfigs, ok := c.caConfigsByOrg[strings.ToLower(org)]
if ok {
//for now, we're only loading the first Cert Authority by default.
return caConfigs[0].TLSCAClientCert, true
}
return nil, false
} | go | {
"resource": ""
} |
q29691 | CAClientKey | train | func (c *IdentityConfig) CAClientKey(org string) ([]byte, bool) {
caConfigs, ok := c.caConfigsByOrg[strings.ToLower(org)]
if ok {
//for now, we're only loading the first Cert Authority by default.
return caConfigs[0].TLSCAClientKey, true
}
return nil, false
} | go | {
"resource": ""
} |
q29692 | CAServerCerts | train | func (c *IdentityConfig) CAServerCerts(org string) ([][]byte, bool) {
caConfigs, ok := c.caConfigsByOrg[strings.ToLower(org)]
if ok {
//for now, we're only loading the first Cert Authority by default.
return caConfigs[0].TLSCAServerCerts, true
}
return nil, false
} | go | {
"resource": ""
} |
q29693 | loadIdentityConfigEntities | train | func (c *IdentityConfig) loadIdentityConfigEntities() error {
configEntity := identityConfigEntity{}
err := c.backend.UnmarshalKey("client", &configEntity.Client)
logger.Debugf("Client is: %+v", configEntity.Client)
if err != nil {
return errors.WithMessage(err, "failed to parse 'client' config item to identityC... | go | {
"resource": ""
} |
q29694 | loadCATLSConfig | train | func (c *IdentityConfig) loadCATLSConfig(configEntity *identityConfigEntity) error {
//CA Config
for ca, caConfig := range configEntity.CertificateAuthorities {
//resolve paths
caConfig.TLSCACerts.Path = pathvar.Subst(caConfig.TLSCACerts.Path)
caConfig.TLSCACerts.Client.Key.Path = pathvar.Subst(caConfig.TLSCACe... | go | {
"resource": ""
} |
q29695 | NewEventClientRef | train | func NewEventClientRef(idleTimeout time.Duration, evtClientProvider eventClientProvider) *EventClientRef {
clientRef := &EventClientRef{
provider: evtClientProvider,
}
if idleTimeout == 0 {
idleTimeout = defaultTimeout
}
clientRef.ref = lazyref.New(
clientRef.initializer(),
lazyref.WithFinalizer(clientRe... | go | {
"resource": ""
} |
q29696 | Close | train | func (ref *EventClientRef) Close() {
if !atomic.CompareAndSwapInt32(&ref.closed, 0, 1) {
// Already closed
return
}
logger.Debug("Closing the event client")
ref.ref.Close()
} | go | {
"resource": ""
} |
q29697 | Unregister | train | func (ref *EventClientRef) Unregister(reg fab.Registration) {
if service, err := ref.get(); err != nil {
logger.Warnf("Error unregistering event registration: %s", err)
} else {
service.Unregister(reg)
}
} | go | {
"resource": ""
} |
q29698 | NewEndpointFilter | train | func NewEndpointFilter(ctx context.Channel, et EndpointType) *EndpointFilter {
// Retrieve channel peers
chPeers := ctx.EndpointConfig().ChannelPeers(ctx.ChannelID())
return &EndpointFilter{endpointType: et, ctx: ctx, chPeers: chPeers}
} | go | {
"resource": ""
} |
q29699 | Accept | train | func (f *EndpointFilter) Accept(peer fab.Peer) bool {
peerConfig, err := comm.SearchPeerConfigFromURL(f.ctx.EndpointConfig(), peer.URL())
if err != nil {
return true
}
chPeer := f.getChannelPeer(peerConfig)
if chPeer == nil {
return true
}
switch t := f.endpointType; t {
case ChaincodeQuery:
return chP... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.