_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q29500 | NewMockPeer | train | func NewMockPeer(name string, url string) *MockPeer {
mp := &MockPeer{MockName: name, MockMSP: "Org1MSP", MockURL: url, Status: 200, RWLock: &sync.RWMutex{}}
return mp
} | go | {
"resource": ""
} |
q29501 | ProcessTransactionProposal | train | func (p *MockPeer) ProcessTransactionProposal(ctx reqContext.Context, tp fab.ProcessProposalRequest) (*fab.TransactionProposalResponse, error) {
if p.RWLock != nil {
p.RWLock.Lock()
defer p.RWLock.Unlock()
}
p.ProcessProposalCalls++
return &fab.TransactionProposalResponse{
Endorser: p.MockURL,
Status: p.... | go | {
"resource": ""
} |
q29502 | NewRwSet | train | func NewRwSet(ccID string) *rwsetutil.NsRwSet {
return &rwsetutil.NsRwSet{
NameSpace: ccID,
KvRwSet: &kvrwset.KVRWSet{},
CollHashedRwSets: nil,
}
} | go | {
"resource": ""
} |
q29503 | New | train | func New(request fab.TransactionRequest) (*fab.Transaction, error) {
if len(request.ProposalResponses) == 0 {
return nil, errors.New("at least one proposal response is necessary")
}
proposal := request.Proposal
// the original header
hdr, err := protoutil.GetHeader(proposal.Header)
if err != nil {
return ni... | go | {
"resource": ""
} |
q29504 | BroadcastPayload | train | func BroadcastPayload(reqCtx reqContext.Context, payload *common.Payload, orderers []fab.Orderer) (*fab.TransactionResponse, error) {
// Check if orderers are defined
if len(orderers) == 0 {
return nil, errors.New("orderers not set")
}
ctx, ok := context.RequestClientContext(reqCtx)
if !ok {
return nil, error... | go | {
"resource": ""
} |
q29505 | broadcastEnvelope | train | func broadcastEnvelope(reqCtx reqContext.Context, envelope *fab.SignedEnvelope, orderers []fab.Orderer) (*fab.TransactionResponse, error) {
// Check if orderers are defined
if len(orderers) == 0 {
return nil, errors.New("orderers not set")
}
// Copy aside the ordering service endpoints
randOrderers := []fab.Ord... | go | {
"resource": ""
} |
q29506 | SendPayload | train | func SendPayload(reqCtx reqContext.Context, payload *common.Payload, orderers []fab.Orderer) (*common.Block, error) {
if len(orderers) == 0 {
return nil, errors.New("orderers not set")
}
ctx, ok := context.RequestClientContext(reqCtx)
if !ok {
return nil, errors.New("failed get client context from reqContext f... | go | {
"resource": ""
} |
q29507 | sendEnvelope | train | func sendEnvelope(reqCtx reqContext.Context, envelope *fab.SignedEnvelope, orderer fab.Orderer) (*common.Block, error) {
logger.Debugf("Broadcasting envelope to orderer :%s\n", orderer.URL())
blocks, errs := orderer.SendDeliver(reqCtx, envelope)
// This function currently returns the last received block and error.... | go | {
"resource": ""
} |
q29508 | NewGraduatingExpirationProvider | train | func NewGraduatingExpirationProvider(initialExpiry, increments, maxExpiry time.Duration) ExpirationProvider {
var iteration uint32
return func() time.Duration {
expiry := initialExpiry + time.Duration(iteration)*increments
if expiry > maxExpiry {
return maxExpiry
}
iteration++
return expiry
}
} | go | {
"resource": ""
} |
q29509 | CreateUserStore | train | func (f *ProviderFactory) CreateUserStore(config msp.IdentityConfig) (msp.UserStore, error) {
stateStorePath := config.Client().CredentialStore.Path
var userStore msp.UserStore
if stateStorePath == "" {
userStore = mspimpl.NewMemoryUserStore()
} else {
stateStore, err := kvs.New(&kvs.FileKeyValueStoreOptions... | go | {
"resource": ""
} |
q29510 | CreateIdentityManagerProvider | train | func (f *ProviderFactory) CreateIdentityManagerProvider(endpointConfig fab.EndpointConfig, cryptoProvider core.CryptoSuite, userStore msp.UserStore) (msp.IdentityManagerProvider, error) {
return msppvdr.New(endpointConfig, cryptoProvider, userStore)
} | go | {
"resource": ""
} |
q29511 | addDefaultTargetFilter | train | func addDefaultTargetFilter(chCtx context.Channel, ft filter.EndpointType) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
if len(o.Targets) == 0 && o.TargetFilter == nil {
return WithTargetFilter(filter.NewEndpointFilter(chCtx, ft))(ctx, o)
}
return nil
}
} | go | {
"resource": ""
} |
q29512 | addDefaultTimeout | train | func addDefaultTimeout(tt fab.TimeoutType) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
if o.Timeouts[tt] == 0 {
return WithTimeout(tt, ctx.EndpointConfig().Timeout(tt))(ctx, o)
}
return nil
}
} | go | {
"resource": ""
} |
q29513 | createReqContext | train | func (cc *Client) createReqContext(txnOpts *requestOptions) (reqContext.Context, reqContext.CancelFunc) {
if txnOpts.Timeouts == nil {
txnOpts.Timeouts = make(map[fab.TimeoutType]time.Duration)
}
//setting default timeouts when not provided
if txnOpts.Timeouts[fab.Execute] == 0 {
txnOpts.Timeouts[fab.Execute]... | go | {
"resource": ""
} |
q29514 | prepareHandlerContexts | train | func (cc *Client) prepareHandlerContexts(reqCtx reqContext.Context, request Request, o requestOptions) (*invoke.RequestContext, *invoke.ClientContext, error) {
if request.ChaincodeID == "" || request.Fcn == "" {
return nil, nil, errors.New("ChaincodeID and Fcn are required")
}
transactor, err := cc.context.Chann... | go | {
"resource": ""
} |
q29515 | prepareOptsFromOptions | train | func (cc *Client) prepareOptsFromOptions(ctx context.Client, options ...RequestOption) (requestOptions, error) {
txnOpts := requestOptions{}
for _, option := range options {
err := option(ctx, &txnOpts)
if err != nil {
return txnOpts, errors.WithMessage(err, "Failed to read opts")
}
}
return txnOpts, nil
} | go | {
"resource": ""
} |
q29516 | New | train | func New(config fab.EndpointConfig, opts ...Option) (*Peer, error) {
peer := &Peer{
config: config,
commManager: &defCommManager{},
}
for _, opt := range opts {
err := opt(peer)
if err != nil {
return nil, err
}
}
if peer.processor == nil {
// TODO: config is declaring TLS but cert & serverH... | go | {
"resource": ""
} |
q29517 | WithURL | train | func WithURL(url string) Option {
return func(p *Peer) error {
p.url = url
return nil
}
} | go | {
"resource": ""
} |
q29518 | WithTLSCert | train | func WithTLSCert(certificate *x509.Certificate) Option {
return func(p *Peer) error {
p.certificate = certificate
return nil
}
} | go | {
"resource": ""
} |
q29519 | WithServerName | train | func WithServerName(serverName string) Option {
return func(p *Peer) error {
p.serverName = serverName
return nil
}
} | go | {
"resource": ""
} |
q29520 | WithMSPID | train | func WithMSPID(mspID string) Option {
return func(p *Peer) error {
p.mspID = mspID
return nil
}
} | go | {
"resource": ""
} |
q29521 | FromPeerConfig | train | func FromPeerConfig(peerCfg *fab.NetworkPeer) Option {
return func(p *Peer) error {
p.url = peerCfg.URL
p.serverName = getServerNameOverride(peerCfg)
p.inSecure = isInsecureConnectionAllowed(peerCfg)
var err error
p.certificate = peerCfg.TLSCACert
if peerCfg.GRPCOptions["allow-insecure"] == false {
//... | go | {
"resource": ""
} |
q29522 | WithPeerProcessor | train | func WithPeerProcessor(processor fab.ProposalProcessor) Option {
return func(p *Peer) error {
p.processor = processor
return nil
}
} | go | {
"resource": ""
} |
q29523 | ProcessTransactionProposal | train | func (p *Peer) ProcessTransactionProposal(ctx reqContext.Context, proposal fab.ProcessProposalRequest) (*fab.TransactionProposalResponse, error) {
return p.processor.ProcessTransactionProposal(ctx, proposal)
} | go | {
"resource": ""
} |
q29524 | PeersToTxnProcessors | train | func PeersToTxnProcessors(peers []fab.Peer) []fab.ProposalProcessor {
tpp := make([]fab.ProposalProcessor, len(peers))
for i := range peers {
tpp[i] = peers[i]
}
return tpp
} | go | {
"resource": ""
} |
q29525 | Close | train | func (s *snapshot) Close() {
for _, reg := range s.blockRegistrations {
close(reg.Eventch)
}
for _, reg := range s.filteredBlockRegistrations {
close(reg.Eventch)
}
for _, reg := range s.ccRegistrations {
close(reg.Eventch)
}
for _, reg := range s.txStatusRegistrations {
close(reg.Eventch)
}
} | go | {
"resource": ""
} |
q29526 | Enroll | train | func (c *fabricCAAdapter) Enroll(request *api.EnrollmentRequest) ([]byte, error) {
logger.Debugf("Enrolling user [%s]", request.Name)
// TODO add attributes
careq := &caapi.EnrollmentRequest{
CAName: c.caClient.Config.CAName,
Name: request.Name,
Secret: request.Secret,
Profile: request.Profile,
Type... | go | {
"resource": ""
} |
q29527 | Reenroll | train | func (c *fabricCAAdapter) Reenroll(key core.Key, cert []byte, request *api.ReenrollmentRequest) ([]byte, error) {
logger.Debugf("Re Enrolling user with provided key/cert pair for CA [%s]", c.caClient.Config.CAName)
careq := &caapi.ReenrollmentRequest{
CAName: c.caClient.Config.CAName,
Profile: request.Profile,... | go | {
"resource": ""
} |
q29528 | AddAffiliation | train | func (c *fabricCAAdapter) AddAffiliation(key core.Key, cert []byte, request *api.AffiliationRequest) (*api.AffiliationResponse, error) {
logger.Debugf("Add affiliation [%s]", request.Name)
req := caapi.AddAffiliationRequest{
CAName: request.CAName,
Name: request.Name,
Force: request.Force,
}
registrar, e... | go | {
"resource": ""
} |
q29529 | WithLoadBalancePolicy | train | func WithLoadBalancePolicy(lbp pgresolver.LoadBalancePolicy) Opt {
return func(s *SelectionService) {
s.pgLBP = lbp
}
} | go | {
"resource": ""
} |
q29530 | WithCacheTimeout | train | func WithCacheTimeout(timeout time.Duration) Opt {
return func(s *SelectionService) {
s.cacheTimeout = timeout
}
} | go | {
"resource": ""
} |
q29531 | NewService | train | func NewService(context context.Client, channelID string, discovery fab.DiscoveryService, opts ...Opt) (*SelectionService, error) {
return newService(context, channelID, discovery,
func() (CCPolicyProvider, error) {
return newCCPolicyProvider(context, discovery, channelID)
}, opts...)
} | go | {
"resource": ""
} |
q29532 | NewClientMetrics | train | func NewClientMetrics(p metrics.Provider) *ClientMetrics {
return &ClientMetrics{
QueriesReceived: p.NewCounter(queriesReceived),
QueriesFailed: p.NewCounter(queriesFailed),
QueryDuration: p.NewHistogram(queryDuration),
QueryTimeouts: p.NewCounter(queryTimeouts),
ExecutionsReceived: p.NewCo... | go | {
"resource": ""
} |
q29533 | NewService | train | func NewService(config fab.EndpointConfig, peerCreator peerCreator, channelID string) (*DiscoveryService, error) {
if channelID == "" {
return nil, errors.New("channel ID must be provided")
}
// Use configured channel peers
chPeers := config.ChannelPeers(channelID)
if len(chPeers) == 0 {
return nil, errors.Er... | go | {
"resource": ""
} |
q29534 | WithDefaultTargetFilter | train | func WithDefaultTargetFilter(filter fab.TargetFilter) ClientOption {
return func(rmc *Client) error {
rmc.filter = filter
return nil
}
} | go | {
"resource": ""
} |
q29535 | WithTargetEndpoints | train | func WithTargetEndpoints(keys ...string) RequestOption {
return func(ctx context.Client, opts *requestOptions) error {
var targets []fab.Peer
for _, url := range keys {
peerCfg, err := comm.NetworkPeerConfig(ctx.EndpointConfig(), url)
if err != nil {
return err
}
peer, err := ctx.InfraProvider(... | go | {
"resource": ""
} |
q29536 | WithTargetFilter | train | func WithTargetFilter(targetFilter fab.TargetFilter) RequestOption {
return func(ctx context.Client, opts *requestOptions) error {
opts.TargetFilter = targetFilter
return nil
}
} | go | {
"resource": ""
} |
q29537 | WithMaxTargets | train | func WithMaxTargets(maxTargets int) RequestOption {
return func(ctx context.Client, opts *requestOptions) error {
opts.MaxTargets = maxTargets
return nil
}
} | go | {
"resource": ""
} |
q29538 | WithTimeout | train | func WithTimeout(timeoutType fab.TimeoutType, timeout time.Duration) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
if o.Timeouts == nil {
o.Timeouts = make(map[fab.TimeoutType]time.Duration)
}
o.Timeouts[timeoutType] = timeout
return nil
}
} | go | {
"resource": ""
} |
q29539 | WithParentContext | train | func WithParentContext(parentContext reqContext.Context) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
o.ParentContext = parentContext
return nil
}
} | go | {
"resource": ""
} |
q29540 | Lookup | train | func (b *MockConfigBackend) Lookup(key string) (interface{}, bool) {
v, ok := b.KeyValueMap[key]
return v, ok
} | go | {
"resource": ""
} |
q29541 | WithPeers | train | func WithPeers(peers ...*MockDiscoveryPeerEndpoint) MockDiscoveryServerOpt {
return func(s *MockDiscoveryServer) {
s.peersByOrg = asPeersByOrg(peers)
}
} | go | {
"resource": ""
} |
q29542 | WithLocalPeers | train | func WithLocalPeers(peers ...*MockDiscoveryPeerEndpoint) MockDiscoveryServerOpt {
return func(s *MockDiscoveryServer) {
s.localPeersByOrg = asPeersByOrg(peers)
}
} | go | {
"resource": ""
} |
q29543 | NewServer | train | func NewServer(opts ...MockDiscoveryServerOpt) *MockDiscoveryServer {
s := &MockDiscoveryServer{}
for _, opt := range opts {
opt(s)
}
return s
} | go | {
"resource": ""
} |
q29544 | Discover | train | func (s *MockDiscoveryServer) Discover(ctx context.Context, request *discovery.SignedRequest) (*discovery.Response, error) {
if request == nil {
return nil, errors.New("nil request")
}
req := &discovery.Request{}
err := proto.Unmarshal(request.Payload, req)
if err != nil {
return nil, errors.Wrap(err, "failed... | go | {
"resource": ""
} |
q29545 | retrieveBlock | train | func retrieveBlock(reqCtx reqContext.Context, orderers []fab.Orderer, channel string, pos *ab.SeekPosition, opts options) (*common.Block, error) {
ctx, ok := contextImpl.RequestClientContext(reqCtx)
if !ok {
return nil, errors.New("failed get client context from reqContext for signPayload")
}
th, err := txn.NewHe... | go | {
"resource": ""
} |
q29546 | newNewestSeekPosition | train | func newNewestSeekPosition() *ab.SeekPosition {
return &ab.SeekPosition{Type: &ab.SeekPosition_Newest{Newest: &ab.SeekNewest{}}}
} | go | {
"resource": ""
} |
q29547 | newSpecificSeekPosition | train | func newSpecificSeekPosition(index uint64) *ab.SeekPosition {
return &ab.SeekPosition{Type: &ab.SeekPosition_Specified{Specified: &ab.SeekSpecified{Number: index}}}
} | go | {
"resource": ""
} |
q29548 | New | train | func New(endpointConfig fab.EndpointConfig, cryptoSuite core.CryptoSuite, userStore msp.UserStore) (*MSPProvider, error) {
identityManager := make(map[string]msp.IdentityManager)
netConfig := endpointConfig.NetworkConfig()
for orgName := range netConfig.Organizations {
mgr, err := mspimpl.NewIdentityManager(orgNa... | go | {
"resource": ""
} |
q29549 | IdentityManager | train | func (p *MSPProvider) IdentityManager(orgName string) (msp.IdentityManager, bool) {
im, ok := p.identityManager[strings.ToLower(orgName)]
if !ok {
return nil, false
}
return im, true
} | go | {
"resource": ""
} |
q29550 | Verify | train | func (m *MockMembership) Verify(serializedID []byte, msg []byte, sig []byte) error {
return m.VerifyErr
} | go | {
"resource": ""
} |
q29551 | ContainsMSP | train | func (m *MockMembership) ContainsMSP(msp string) bool {
for _, v := range m.excludeMSPs {
if v == msp {
return false
}
}
return true
} | go | {
"resource": ""
} |
q29552 | WithRefreshInterval | train | func WithRefreshInterval(value time.Duration) coptions.Opt {
return func(p coptions.Params) {
logger.Debug("Checking refreshIntervalSetter")
if setter, ok := p.(refreshIntervalSetter); ok {
setter.SetDiscoveryRefreshInterval(value)
}
}
} | go | {
"resource": ""
} |
q29553 | WithResponseTimeout | train | func WithResponseTimeout(value time.Duration) coptions.Opt {
return func(p coptions.Params) {
logger.Debug("Checking responseTimeoutSetter")
if setter, ok := p.(responseTimeoutSetter); ok {
setter.SetDiscoveryResponseTimeout(value)
}
}
} | go | {
"resource": ""
} |
q29554 | WithErrorHandler | train | func WithErrorHandler(value fab.ErrorHandler) coptions.Opt {
return func(p coptions.Params) {
logger.Debugf("Checking errHandlerSetter")
if setter, ok := p.(errHandlerSetter); ok {
logger.Debugf("... setting error handler")
setter.SetErrorHandler(value)
}
}
} | go | {
"resource": ""
} |
q29555 | WithPrivateKey | train | func WithPrivateKey(key []byte) SigningIdentityOption {
return func(o *IdentityOption) error {
o.PrivateKey = key
return nil
}
} | go | {
"resource": ""
} |
q29556 | WithCert | train | func WithCert(cert []byte) SigningIdentityOption {
return func(o *IdentityOption) error {
o.Cert = cert
return nil
}
} | go | {
"resource": ""
} |
q29557 | NewCAClient | train | func NewCAClient(orgName string, ctx contextApi.Client) (*CAClientImpl, error) {
if orgName == "" {
orgName = ctx.IdentityConfig().Client().Organization
}
if orgName == "" {
return nil, errors.New("organization is missing")
}
netConfig := ctx.EndpointConfig().NetworkConfig()
// viper keys are case insensit... | go | {
"resource": ""
} |
q29558 | Reenroll | train | func (c *CAClientImpl) Reenroll(request *api.ReenrollmentRequest) error {
if c.adapter == nil {
return fmt.Errorf("no CAs configured for organization: %s", c.orgName)
}
if request.Name == "" {
logger.Info("invalid re-enroll request, missing enrollmentID")
return errors.New("user name missing")
}
user, err ... | go | {
"resource": ""
} |
q29559 | GetAllAffiliations | train | func (c *CAClientImpl) GetAllAffiliations(caname string) (*api.AffiliationResponse, error) {
if c.adapter == nil {
return nil, fmt.Errorf("no CAs configured for organization %s", c.orgName)
}
registrar, err := c.getRegistrar(c.registrar.EnrollID, c.registrar.EnrollSecret)
if err != nil {
return nil, err
}
r... | go | {
"resource": ""
} |
q29560 | AddAffiliation | train | func (c *CAClientImpl) AddAffiliation(request *api.AffiliationRequest) (*api.AffiliationResponse, error) {
if c.adapter == nil {
return nil, fmt.Errorf("no CAs configured for organization: %s", c.orgName)
}
if request == nil {
return nil, errors.New("must provide affiliation request")
}
// Checke required pa... | go | {
"resource": ""
} |
q29561 | New | train | func New(ctx fabcontext.Client, chConfig fab.ChannelCfg, streamProvider StreamProvider, url string, opts ...options.Opt) (*DeliverConnection, error) {
logger.Debugf("Connecting to %s...", url)
connect, err := comm.NewStreamConnection(
ctx, chConfig,
func(grpcconn *grpc.ClientConn) (grpc.ClientStream, error) {
... | go | {
"resource": ""
} |
q29562 | Send | train | func (c *DeliverConnection) Send(seekInfo *ab.SeekInfo) error {
if c.Closed() {
return errors.New("connection is closed")
}
logger.Debugf("Sending %#v", seekInfo)
env, err := c.createSignedEnvelope(seekInfo)
if err != nil {
return err
}
return c.deliverStream().Send(env)
} | go | {
"resource": ""
} |
q29563 | Receive | train | func (c *DeliverConnection) Receive(eventch chan<- interface{}) {
for {
stream := c.deliverStream()
if stream == nil {
logger.Warn("The stream has closed. Terminating loop.")
break
}
in, err := stream.Recv()
logger.Debugf("Got deliver response: %#v", in)
if c.Closed() {
logger.Debugf("The conne... | go | {
"resource": ""
} |
q29564 | NewEvent | train | func NewEvent(event interface{}, sourceURL string) *Event {
return &Event{
SourceURL: sourceURL,
Event: event,
}
} | go | {
"resource": ""
} |
q29565 | TLSConfig | train | func TLSConfig(cert *x509.Certificate, serverName string, config fab.EndpointConfig) (*tls.Config, error) {
if cert != nil {
config.TLSCACertPool().Add(cert)
}
certPool, err := config.TLSCACertPool().Get()
if err != nil {
return nil, err
}
return &tls.Config{RootCAs: certPool, Certificates: config.TLSClient... | go | {
"resource": ""
} |
q29566 | computeHash | train | func computeHash(msg []byte) ([]byte, error) {
h, err := cryptosuite.GetDefault().Hash(msg, cryptosuite.GetSHA256Opts())
if err != nil {
return nil, errors.WithMessage(err, "failed to compute tls cert hash")
}
return h, err
} | go | {
"resource": ""
} |
q29567 | GetEventService | train | func (c *contextCache) GetEventService(channelID string, opts ...options.Opt) (fab.EventService, error) {
chnlCfg, err := c.GetChannelConfig(channelID)
if err != nil {
return nil, err
}
key, err := newEventCacheKey(chnlCfg, opts...)
if err != nil {
return nil, err
}
eventService, err := c.eventServiceCache.G... | go | {
"resource": ""
} |
q29568 | New | train | func New(context context.Client, chConfig fab.ChannelCfg, discoveryService fab.DiscoveryService, connectionProvider api.ConnectionProvider, opts ...options.Opt) *Dispatcher {
params := defaultParams(context, chConfig.ID())
options.Apply(params, opts)
dispatcher := &Dispatcher{
Dispatcher: esdispatcher.New... | go | {
"resource": ""
} |
q29569 | HandleStopEvent | train | func (ed *Dispatcher) HandleStopEvent(e esdispatcher.Event) {
// Remove all registrations and close the associated event channels
// so that the client is notified that the registration has been removed
ed.clearConnectionRegistration()
if ed.peerMonitorDone != nil {
close(ed.peerMonitorDone)
ed.peerMonitorDone ... | go | {
"resource": ""
} |
q29570 | HandleConnectEvent | train | func (ed *Dispatcher) HandleConnectEvent(e esdispatcher.Event) {
evt := e.(*ConnectEvent)
if ed.connection != nil {
// Already connected. No error.
evt.ErrCh <- nil
return
}
eventch, err := ed.EventCh()
if err != nil {
evt.ErrCh <- err
return
}
peers, err := ed.discoveryService.GetPeers()
if err !=... | go | {
"resource": ""
} |
q29571 | HandleDisconnectEvent | train | func (ed *Dispatcher) HandleDisconnectEvent(e esdispatcher.Event) {
evt := e.(*DisconnectEvent)
if ed.connection == nil {
evt.Errch <- errors.New("connection already closed")
return
}
logger.Debug("Closing connection due to disconnect event...")
ed.connection.Close()
ed.connection = nil
ed.setConnectedPee... | go | {
"resource": ""
} |
q29572 | HandleRegisterConnectionEvent | train | func (ed *Dispatcher) HandleRegisterConnectionEvent(e esdispatcher.Event) {
evt := e.(*RegisterConnectionEvent)
if ed.connectionRegistration != nil {
evt.ErrCh <- errors.New("registration already exists for connection event")
return
}
ed.connectionRegistration = evt.Reg
evt.RegCh <- evt.Reg
} | go | {
"resource": ""
} |
q29573 | HandleConnectedEvent | train | func (ed *Dispatcher) HandleConnectedEvent(e esdispatcher.Event) {
evt := e.(*ConnectedEvent)
logger.Debugf("Handling connected event: %+v", evt)
if ed.connectionRegistration != nil && ed.connectionRegistration.Eventch != nil {
select {
case ed.connectionRegistration.Eventch <- NewConnectionEvent(true, nil):
... | go | {
"resource": ""
} |
q29574 | HandleDisconnectedEvent | train | func (ed *Dispatcher) HandleDisconnectedEvent(e esdispatcher.Event) {
evt := e.(*DisconnectedEvent)
logger.Debugf("Disconnecting from event server: %s", evt.Err)
if ed.connection != nil {
ed.connection.Close()
ed.connection = nil
}
if ed.connectionRegistration != nil {
logger.Debugf("Disconnected from eve... | go | {
"resource": ""
} |
q29575 | disconnected | train | func (ed *Dispatcher) disconnected() bool {
connectedPeer := ed.ConnectedPeer()
if connectedPeer == nil {
logger.Debugf("Not connected yet")
return false
}
logger.Debugf("Checking if event client should disconnect from peer [%s] on channel [%s]...", connectedPeer.URL(), ed.chConfig.ID())
peers, err := ed.dis... | go | {
"resource": ""
} |
q29576 | ConnectedPeer | train | func (ed *Dispatcher) ConnectedPeer() fab.Peer {
ed.lock.RLock()
defer ed.lock.RUnlock()
return ed.peer
} | go | {
"resource": ""
} |
q29577 | Send | train | func (m *MockDiscoveryClient) Send(ctx reqcontext.Context, req *discclient.Request, targets ...fab.PeerConfig) ([]fabdiscovery.Response, error) {
return m.responses(), nil
} | go | {
"resource": ""
} |
q29578 | SetResponses | train | func (m *MockDiscoveryClient) SetResponses(responses ...MockResponseBuilder) {
m.lock.Lock()
defer m.lock.Unlock()
m.resp = nil
for _, resp := range responses {
m.resp = append(m.resp, resp.Build())
}
} | go | {
"resource": ""
} |
q29579 | Endorsers | train | func (cr *channelResponse) Endorsers(invocationChain discclient.InvocationChain, f discclient.Filter) (discclient.Endorsers, error) {
if cr.err != nil {
return nil, cr.err
}
return f.Filter(cr.peers), nil
} | go | {
"resource": ""
} |
q29580 | Build | train | func (b *MockDiscoverEndpointResponse) Build() fabdiscovery.Response {
var peers discclient.Endorsers
for _, endpoint := range b.PeerEndpoints {
peer := &discclient.Peer{
MSPID: endpoint.MSPID,
AliveMessage: newAliveMessage(endpoint),
StateInfoMessage: newStateInfoMessage(endpoint),
}
pe... | go | {
"resource": ""
} |
q29581 | NewConnection | train | func NewConnection(opts ...clientmocks.Opt) *MockConnection {
return &MockConnection{
MockConnection: *clientmocks.NewMockConnection(opts...),
}
} | go | {
"resource": ""
} |
q29582 | Send | train | func (c *MockConnection) Send(sinfo *ab.SeekInfo) error {
if c.Closed() {
return errors.New("mock connection is closed")
}
switch seek := sinfo.Start.Type.(type) {
case *ab.SeekPosition_Specified:
// Deliver all blocks from the given block number
fromBlock := seek.Specified.Number
c.Ledger().SendFrom(fromB... | go | {
"resource": ""
} |
q29583 | InitContext | train | func (p11w *Pkcs11Wrapper) InitContext() (err error) {
// check if lib file exists
if _, err = os.Stat(p11w.Library.Path); os.IsNotExist(err) {
return
}
// try to initialize
p11w.Context = pkcs11.New(p11w.Library.Path)
err = p11w.Context.Initialize()
if err != nil {
return
}
// get library info
p11w.Li... | go | {
"resource": ""
} |
q29584 | InitSession | train | func (p11w *Pkcs11Wrapper) InitSession() (err error) {
// Look for provided slot
slot, _, err := FindSlotByLabel(p11w.Context, p11w.SlotLabel)
if err != nil {
return
}
// Create session for matching slot
p11w.Session, err = p11w.Context.OpenSession(slot, pkcs11.CKF_SERIAL_SESSION|pkcs11.CKF_RW_SESSION)
retu... | go | {
"resource": ""
} |
q29585 | Login | train | func (p11w *Pkcs11Wrapper) Login() (err error) {
err = p11w.Context.Login(p11w.Session, pkcs11.CKU_USER, p11w.SlotPin)
return
} | go | {
"resource": ""
} |
q29586 | CloseContext | train | func (p11w *Pkcs11Wrapper) CloseContext() {
p11w.Context.Logout(p11w.Session)
p11w.Context.CloseSession(p11w.Session)
p11w.Context.Finalize()
p11w.Context.Destroy()
return
} | go | {
"resource": ""
} |
q29587 | FindObjects | train | func (p11w *Pkcs11Wrapper) FindObjects(template []*pkcs11.Attribute, max int) (p11ObjHandlers []pkcs11.ObjectHandle, moreThanMax bool, err error) {
// start the search for object
err = p11w.Context.FindObjectsInit(
p11w.Session,
template,
)
if err != nil {
return
}
// continue the search, get object handl... | go | {
"resource": ""
} |
q29588 | ListObjects | train | func (p11w *Pkcs11Wrapper) ListObjects(template []*pkcs11.Attribute, max int) {
// do an object search
objects, _, err := p11w.FindObjects(template, max)
if err != nil {
fmt.Println("Could not find any objects:", err)
} else {
// prepare table headers
table := tablewriter.NewWriter(os.Stdout)
table.SetHe... | go | {
"resource": ""
} |
q29589 | Accept | train | func (f *mspFilter) Accept(peer fab.Peer) bool {
return peer.MSPID() == f.mspID
} | go | {
"resource": ""
} |
q29590 | New | train | func New(ctxProvider context.ClientProvider, opts ...ClientOption) (*Client, error) {
ctx, err := ctxProvider()
if err != nil {
return nil, errors.WithMessage(err, "failed to create resmgmt client due to context error")
}
if ctx.Identifier().MSPID == "" {
return nil, errors.New("mspID not available in user co... | go | {
"resource": ""
} |
q29591 | getDefaultTargets | train | func (rc *Client) getDefaultTargets(discovery fab.DiscoveryService) ([]fab.Peer, error) {
// Default targets are discovery peers
peers, err := discovery.GetPeers()
if err != nil {
return nil, errors.WithMessage(err, "failed to discover peers")
}
// Apply default filter to discovery peers
targets := filterTarg... | go | {
"resource": ""
} |
q29592 | isChaincodeInstalled | train | func (rc *Client) isChaincodeInstalled(reqCtx reqContext.Context, req InstallCCRequest, peer fab.ProposalProcessor, retryOpts retry.Opts) (bool, error) {
chaincodeQueryResponse, err := resource.QueryInstalledChaincodes(reqCtx, peer, resource.WithRetry(retryOpts))
if err != nil {
return false, err
}
logger.Debug... | go | {
"resource": ""
} |
q29593 | sendCCProposal | train | func (rc *Client) sendCCProposal(reqCtx reqContext.Context, ccProposalType chaincodeProposalType, channelID string, req InstantiateCCRequest, opts requestOptions) (fab.TransactionID, error) {
if err := checkRequiredCCProposalParams(channelID, req); err != nil {
return fab.EmptyTransactionID, err
}
targets, err :=... | go | {
"resource": ""
} |
q29594 | prepareRequestOpts | train | func (rc *Client) prepareRequestOpts(options ...RequestOption) (requestOptions, error) {
opts := requestOptions{}
for _, option := range options {
err := option(rc.ctx, &opts)
if err != nil {
return opts, errors.WithMessage(err, "failed to read opts in resmgmt")
}
}
if len(opts.Targets) > 0 && opts.Target... | go | {
"resource": ""
} |
q29595 | resolveTimeouts | train | func (rc *Client) resolveTimeouts(opts *requestOptions) {
if opts.Timeouts == nil {
opts.Timeouts = make(map[fab.TimeoutType]time.Duration)
}
if opts.Timeouts[fab.ResMgmt] == 0 {
opts.Timeouts[fab.ResMgmt] = rc.ctx.EndpointConfig().Timeout(fab.ResMgmt)
}
if opts.Timeouts[fab.OrdererResponse] == 0 {
opts.T... | go | {
"resource": ""
} |
q29596 | New | train | func New(dispatcher Dispatcher, opts ...options.Opt) *Service {
params := defaultParams()
options.Apply(params, opts)
return &Service{
params: *params,
dispatcher: dispatcher,
}
} | go | {
"resource": ""
} |
q29597 | Stop | train | func (s *Service) Stop() {
eventch, err := s.dispatcher.EventCh()
if err != nil {
logger.Warnf("Error stopping event service: %s", err)
return
}
errch := make(chan error)
eventch <- dispatcher.NewStopEvent(errch)
select {
case err := <-errch:
if err != nil {
logger.Warnf("Error while stopping dispatch... | go | {
"resource": ""
} |
q29598 | StopAndTransfer | train | func (s *Service) StopAndTransfer() (fab.EventSnapshot, error) {
eventch, err := s.dispatcher.EventCh()
if err != nil {
logger.Warnf("Error stopping event service: %s", err)
return nil, err
}
snapshotch := make(chan fab.EventSnapshot)
errch := make(chan error)
eventch <- dispatcher.NewStopAndTransferEvent(sn... | go | {
"resource": ""
} |
q29599 | Submit | train | func (s *Service) Submit(event interface{}) error {
defer func() {
// During shutdown, events may still be produced and we may
// get a 'send on closed channel' panic. Just log and ignore the error.
if p := recover(); p != nil {
logger.Warnf("panic while submitting event: %s", p)
debug.PrintStack()
}
}(... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.