_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q29700 | WithRefreshInterval | train | func WithRefreshInterval(value time.Duration) coptions.Opt {
return func(p coptions.Params) {
if setter, ok := p.(refreshIntervalSetter); ok {
setter.SetChConfigRefreshInterval(value)
}
}
} | go | {
"resource": ""
} |
q29701 | SetNumber | train | func (w *BlockWrapper) SetNumber(number uint64) {
w.block.Header.Number = number
} | go | {
"resource": ""
} |
q29702 | IdentityManager | train | func (c *Provider) IdentityManager(orgName string) (msp.IdentityManager, bool) {
return c.idMgmtProvider.IdentityManager(orgName)
} | go | {
"resource": ""
} |
q29703 | WithCryptoSuiteConfig | train | func WithCryptoSuiteConfig(cryptoSuiteConfig core.CryptoSuiteConfig) SDKContextParams {
return func(ctx *Provider) {
ctx.cryptoSuiteConfig = cryptoSuiteConfig
}
} | go | {
"resource": ""
} |
q29704 | WithEndpointConfig | train | func WithEndpointConfig(endpointConfig fab.EndpointConfig) SDKContextParams {
return func(ctx *Provider) {
ctx.endpointConfig = endpointConfig
}
} | go | {
"resource": ""
} |
q29705 | WithIdentityConfig | train | func WithIdentityConfig(identityConfig msp.IdentityConfig) SDKContextParams {
return func(ctx *Provider) {
ctx.identityConfig = identityConfig
}
} | go | {
"resource": ""
} |
q29706 | WithUserStore | train | func WithUserStore(userStore msp.UserStore) SDKContextParams {
return func(ctx *Provider) {
ctx.userStore = userStore
}
} | go | {
"resource": ""
} |
q29707 | WithCryptoSuite | train | func WithCryptoSuite(cryptoSuite core.CryptoSuite) SDKContextParams {
return func(ctx *Provider) {
ctx.cryptoSuite = cryptoSuite
}
} | go | {
"resource": ""
} |
q29708 | WithLocalDiscoveryProvider | train | func WithLocalDiscoveryProvider(discoveryProvider fab.LocalDiscoveryProvider) SDKContextParams {
return func(ctx *Provider) {
ctx.localDiscoveryProvider = discoveryProvider
}
} | go | {
"resource": ""
} |
q29709 | WithSigningManager | train | func WithSigningManager(signingManager core.SigningManager) SDKContextParams {
return func(ctx *Provider) {
ctx.signingManager = signingManager
}
} | go | {
"resource": ""
} |
q29710 | WithIdentityManagerProvider | train | func WithIdentityManagerProvider(provider msp.IdentityManagerProvider) SDKContextParams {
return func(ctx *Provider) {
ctx.idMgmtProvider = provider
}
} | go | {
"resource": ""
} |
q29711 | WithInfraProvider | train | func WithInfraProvider(infraProvider fab.InfraProvider) SDKContextParams {
return func(ctx *Provider) {
ctx.infraProvider = infraProvider
}
} | go | {
"resource": ""
} |
q29712 | WithChannelProvider | train | func WithChannelProvider(channelProvider fab.ChannelProvider) SDKContextParams {
return func(ctx *Provider) {
ctx.channelProvider = channelProvider
}
} | go | {
"resource": ""
} |
q29713 | WithClientMetrics | train | func WithClientMetrics(cm *metrics.ClientMetrics) SDKContextParams {
return func(ctx *Provider) {
ctx.clientMetrics = cm
}
} | go | {
"resource": ""
} |
q29714 | NewProvider | train | func NewProvider(params ...SDKContextParams) *Provider {
ctxProvider := Provider{}
for _, param := range params {
param(&ctxProvider)
}
return &ctxProvider
} | go | {
"resource": ""
} |
q29715 | NewLocal | train | func NewLocal(clientProvider context.ClientProvider) (*Local, error) {
client, err := clientProvider()
if err != nil {
return nil, errors.WithMessage(err, "failed to get client context to create local context")
}
discoveryService, err := client.LocalDiscoveryProvider().CreateLocalDiscoveryService(client.Identifi... | go | {
"resource": ""
} |
q29716 | NewChannel | train | func NewChannel(clientProvider context.ClientProvider, channelID string) (*Channel, error) {
client, err := clientProvider()
if err != nil {
return nil, errors.WithMessage(err, "failed to get client context to create channel client")
}
channelService, err := client.ChannelProvider().ChannelService(client, chann... | go | {
"resource": ""
} |
q29717 | WithTimeoutType | train | func WithTimeoutType(timeoutType fab.TimeoutType) ReqContextOptions {
return func(ctx *requestContextOpts) {
ctx.timeoutType = timeoutType
}
} | go | {
"resource": ""
} |
q29718 | WithTimeout | train | func WithTimeout(timeout time.Duration) ReqContextOptions {
return func(ctx *requestContextOpts) {
ctx.timeout = timeout
}
} | go | {
"resource": ""
} |
q29719 | WithParent | train | func WithParent(context reqContext.Context) ReqContextOptions {
return func(ctx *requestContextOpts) {
ctx.parentContext = context
}
} | go | {
"resource": ""
} |
q29720 | NewRequest | train | func NewRequest(client context.Client, options ...ReqContextOptions) (reqContext.Context, reqContext.CancelFunc) {
//'-1' to get default config timeout when timeout options not passed
reqCtxOpts := requestContextOpts{timeoutType: -1}
for _, option := range options {
option(&reqCtxOpts)
}
parentContext := reqCt... | go | {
"resource": ""
} |
q29721 | RequestCommManager | train | func RequestCommManager(ctx reqContext.Context) (fab.CommManager, bool) {
commManager, ok := ctx.Value(reqContextCommManager).(fab.CommManager)
return commManager, ok
} | go | {
"resource": ""
} |
q29722 | RequestClientContext | train | func RequestClientContext(ctx reqContext.Context) (context.Client, bool) {
clientContext, ok := ctx.Value(reqContextClient).(context.Client)
return clientContext, ok
} | go | {
"resource": ""
} |
q29723 | requestTimeoutOverride | train | func requestTimeoutOverride(ctx reqContext.Context, timeoutType fab.TimeoutType) time.Duration {
timeoutOverrides, ok := ctx.Value(ReqContextTimeoutOverrides).(map[fab.TimeoutType]time.Duration)
if !ok {
return 0
}
return timeoutOverrides[timeoutType]
} | go | {
"resource": ""
} |
q29724 | WithTargets | train | func WithTargets(targets ...fab.Peer) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
// Validate targets
for _, t := range targets {
if t == nil {
return errors.New("target is nil")
}
}
o.Targets = targets
return nil
}
} | go | {
"resource": ""
} |
q29725 | WithTargetFilter | train | func WithTargetFilter(filter fab.TargetFilter) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
o.TargetFilter = filter
return nil
}
} | go | {
"resource": ""
} |
q29726 | WithTargetSorter | train | func WithTargetSorter(sorter fab.TargetSorter) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
o.TargetSorter = sorter
return nil
}
} | go | {
"resource": ""
} |
q29727 | WithRetry | train | func WithRetry(retryOpt retry.Opts) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
o.Retry = retryOpt
return nil
}
} | go | {
"resource": ""
} |
q29728 | WithBeforeRetry | train | func WithBeforeRetry(beforeRetry retry.BeforeRetryHandler) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
o.BeforeRetry = beforeRetry
return nil
}
} | go | {
"resource": ""
} |
q29729 | WithChaincodeFilter | train | func WithChaincodeFilter(ccFilter invoke.CCFilter) RequestOption {
return func(ctx context.Client, o *requestOptions) error {
o.CCFilter = ccFilter
return nil
}
} | go | {
"resource": ""
} |
q29730 | New | train | func New(context fabcontext.Client, chConfig fab.ChannelCfg, discoveryService fab.DiscoveryService, opts ...options.Opt) (*Client, error) {
params := defaultParams()
options.Apply(params, opts)
// Use a custom Discovery Service which wraps the given discovery service
// and produces event endpoints containing addi... | go | {
"resource": ""
} |
q29731 | New | train | func New(channelProvider context.ChannelProvider, opts ...ClientOption) (*Client, error) {
channelContext, err := channelProvider()
if err != nil {
return nil, errors.WithMessage(err, "failed to create channel context")
}
eventClient := Client{}
for _, param := range opts {
err1 := param(&eventClient)
if ... | go | {
"resource": ""
} |
q29732 | New | train | func New(opts *FileKeyValueStoreOptions) (*FileKeyValueStore, error) {
if opts == nil {
return nil, errors.New("FileKeyValueStoreOptions is nil")
}
if opts.Path == "" {
return nil, errors.New("FileKeyValueStore path is empty")
}
if opts.KeySerializer == nil {
// Default key serializer
opts.KeySerializer = ... | go | {
"resource": ""
} |
q29733 | Store | train | func (fkvs *FileKeyValueStore) Store(key interface{}, value interface{}) error {
if key == nil {
return errors.New("key is nil")
}
if value == nil {
return errors.New("value is nil")
}
file, err := fkvs.keySerializer(key)
if err != nil {
return err
}
valueBytes, err := fkvs.marshaller(value)
if err != ni... | go | {
"resource": ""
} |
q29734 | Identifier | train | func (u *User) Identifier() *msp.IdentityIdentifier {
return &msp.IdentityIdentifier{MSPID: u.mspID, ID: u.id}
} | go | {
"resource": ""
} |
q29735 | NewResolver | train | func NewResolver() peerresolver.Provider {
return func(ed service.Dispatcher, context context.Client, channelID string, opts ...options.Opt) peerresolver.Resolver {
return New(ed, context, channelID, opts...)
}
} | go | {
"resource": ""
} |
q29736 | Filter | train | func (r *PeerResolver) Filter(peers []fab.Peer) []fab.Peer {
var minBlockHeight uint64
if r.minBlockHeight > 0 {
lastBlockReceived := r.dispatcher.LastBlockNum()
if lastBlockReceived == math.MaxUint64 {
// No blocks received yet
logger.Debugf("Min block height was specified: %d", r.minBlockHeight)
minBlo... | go | {
"resource": ""
} |
q29737 | ShouldDisconnect | train | func (r *PeerResolver) ShouldDisconnect(peers []fab.Peer, connectedPeer fab.Peer) bool {
// Check if the peer should be disconnected
peerState, ok := connectedPeer.(fab.PeerState)
if !ok {
logger.Debugf("Peer does not contain state")
return false
}
lastBlockReceived := r.dispatcher.LastBlockNum()
connectedPe... | go | {
"resource": ""
} |
q29738 | NewHeader | train | func NewHeader(ctx contextApi.Client, channelID string, opts ...fab.TxnHeaderOpt) (*TransactionHeader, error) {
var options fab.TxnHeaderOptions
for _, opt := range opts {
opt(&options)
}
nonce := options.Nonce
if nonce == nil {
// generate a random nonce
var err error
nonce, err = crypto.GetRandomNonce()... | go | {
"resource": ""
} |
q29739 | signPayload | train | func signPayload(ctx contextApi.Client, payload *common.Payload) (*fab.SignedEnvelope, error) {
payloadBytes, err := proto.Marshal(payload)
if err != nil {
return nil, errors.WithMessage(err, "marshaling of payload failed")
}
signingMgr := ctx.SigningManager()
signature, err := signingMgr.Sign(payloadBytes, ctx... | go | {
"resource": ""
} |
q29740 | createHeader | train | func createHeader(th *TransactionHeader, channelHeader *common.ChannelHeader) (*common.Header, error) { //nolint
signatureHeader := &common.SignatureHeader{
Creator: th.creator,
Nonce: th.nonce,
}
sh, err := proto.Marshal(signatureHeader)
if err != nil {
return nil, errors.Wrap(err, "marshal signatureHeade... | go | {
"resource": ""
} |
q29741 | CreatePayload | train | func CreatePayload(txh *TransactionHeader, channelHeader *common.ChannelHeader, data []byte) (*common.Payload, error) {
header, err := createHeader(txh, channelHeader)
if err != nil {
return nil, errors.Wrap(err, "header creation failed")
}
payload := common.Payload{
Header: header,
Data: data,
}
return... | go | {
"resource": ""
} |
q29742 | CreateSignatureHeader | train | func CreateSignatureHeader(txh *TransactionHeader) (*common.SignatureHeader, error) {
signatureHeader := common.SignatureHeader{
Creator: txh.creator,
Nonce: txh.nonce,
}
return &signatureHeader, nil
} | go | {
"resource": ""
} |
q29743 | WithOrdererEndpoint | train | func WithOrdererEndpoint(key string) RequestOption {
return func(ctx context.Client, opts *requestOptions) error {
ordererCfg, found := ctx.EndpointConfig().OrdererConfig(key)
if !found {
return errors.Errorf("orderer not found for url : %s", key)
}
orderer, err := ctx.InfraProvider().CreateOrdererFromCo... | go | {
"resource": ""
} |
q29744 | WithOrderer | train | func WithOrderer(orderer fab.Orderer) RequestOption {
return func(ctx context.Client, opts *requestOptions) error {
opts.Orderer = orderer
return nil
}
} | go | {
"resource": ""
} |
q29745 | WithConfigSignatures | train | func WithConfigSignatures(signatures ...*common.ConfigSignature) RequestOption {
return func(ctx context.Client, opts *requestOptions) error {
opts.Signatures = signatures
return nil
}
} | go | {
"resource": ""
} |
q29746 | New | train | func New(errs ...error) error {
errors := Errors{}
for _, err := range errs {
if err != nil {
errors = append(errors, err)
}
}
if len(errors) == 0 {
return nil
}
if len(errors) == 1 {
return errors[0]
}
return errors
} | go | {
"resource": ""
} |
q29747 | Append | train | func Append(errs error, err error) error {
m, ok := errs.(Errors)
if !ok {
return New(errs, err)
}
return append(m, err)
} | go | {
"resource": ""
} |
q29748 | ToError | train | func (errs Errors) ToError() error {
if len(errs) == 0 {
return nil
}
if len(errs) == 1 {
return errs[0]
}
return errs
} | go | {
"resource": ""
} |
q29749 | Error | train | func (errs Errors) Error() string {
if len(errs) == 0 {
return ""
}
if len(errs) == 1 {
return errs[0].Error()
}
errors := []string{fmt.Sprint("Multiple errors occurred:")}
for _, err := range errs {
errors = append(errors, err.Error())
}
return strings.Join(errors, " - ")
} | go | {
"resource": ""
} |
q29750 | substVar | train | func substVar(s string, noMatch string, sep string) (string, string) {
endPos := strings.Index(s, sep)
if endPos == -1 {
return noMatch, s
}
v, ok := lookupVar(s[:endPos])
if !ok {
return noMatch, s
}
return v, s[endPos+1:]
} | go | {
"resource": ""
} |
q29751 | lookupVar | train | func lookupVar(v string) (string, bool) {
// TODO: optimize if the number of variable names grows
switch v {
case "FABRIC_SDK_GO_PROJECT_PATH":
return metadata.GetProjectPath(), true
case "GOPATH":
return goPath(), true
case "CRYPTOCONFIG_FIXTURES_PATH":
return metadata.CryptoConfigPath, true
}
return os.L... | go | {
"resource": ""
} |
q29752 | New | train | func New(opts ...options.Opt) *Dispatcher {
logger.Debug("Creating new dispatcher.")
params := defaultParams()
options.Apply(params, opts)
return &Dispatcher{
params: *params,
handlers: make(map[reflect.Type]Handler),
eventch: make(chan interface{}, params.eventConsumerBufferSize),
... | go | {
"resource": ""
} |
q29753 | RegisterHandlers | train | func (ed *Dispatcher) RegisterHandlers() {
ed.RegisterHandler(&RegisterChaincodeEvent{}, ed.handleRegisterCCEvent)
ed.RegisterHandler(&RegisterTxStatusEvent{}, ed.handleRegisterTxStatusEvent)
ed.RegisterHandler(&RegisterBlockEvent{}, ed.handleRegisterBlockEvent)
ed.RegisterHandler(&RegisterFilteredBlockEvent{}, ed.... | go | {
"resource": ""
} |
q29754 | EventCh | train | func (ed *Dispatcher) EventCh() (chan<- interface{}, error) {
state := ed.getState()
if state == dispatcherStateStarted {
return ed.eventch, nil
}
return nil, errors.Errorf("dispatcher not started - Current state [%d]", state)
} | go | {
"resource": ""
} |
q29755 | Start | train | func (ed *Dispatcher) Start() error {
if !ed.setState(dispatcherStateInitial, dispatcherStateStarted) {
return errors.New("cannot start dispatcher since it's not in its initial state")
}
ed.RegisterHandlers()
if err := ed.initRegistrations(); err != nil {
return errors.WithMessage(err, "error initializing reg... | go | {
"resource": ""
} |
q29756 | updateLastBlockNum | train | func (ed *Dispatcher) updateLastBlockNum(blockNum uint64) error {
// The Deliver Service shouldn't be sending blocks out of order.
// Log an error if we detect this happening.
lastBlockNum := atomic.LoadUint64(&ed.lastBlockNum)
if lastBlockNum == math.MaxUint64 || blockNum > lastBlockNum {
atomic.StoreUint64(&ed.... | go | {
"resource": ""
} |
q29757 | clearBlockRegistrations | train | func (ed *Dispatcher) clearBlockRegistrations(closeChannel bool) {
if closeChannel {
for _, reg := range ed.blockRegistrations {
close(reg.Eventch)
}
}
ed.blockRegistrations = nil
} | go | {
"resource": ""
} |
q29758 | clearFilteredBlockRegistrations | train | func (ed *Dispatcher) clearFilteredBlockRegistrations(closeChannel bool) {
if closeChannel {
for _, reg := range ed.filteredBlockRegistrations {
close(reg.Eventch)
}
}
ed.filteredBlockRegistrations = nil
} | go | {
"resource": ""
} |
q29759 | clearTxRegistrations | train | func (ed *Dispatcher) clearTxRegistrations(closeChannel bool) {
if closeChannel {
for _, reg := range ed.txRegistrations {
logger.Debugf("Closing TX registration event channel for TxID [%s].", reg.TxID)
close(reg.Eventch)
}
}
ed.txRegistrations = make(map[string]*TxStatusReg)
} | go | {
"resource": ""
} |
q29760 | clearChaincodeRegistrations | train | func (ed *Dispatcher) clearChaincodeRegistrations(closeChannel bool) {
if closeChannel {
for _, reg := range ed.ccRegistrations {
logger.Debugf("Closing chaincode registration event channel for CC ID [%s] and event filter [%s].", reg.ChaincodeID, reg.EventFilter)
close(reg.Eventch)
}
}
ed.ccRegistrations =... | go | {
"resource": ""
} |
q29761 | HandleStopEvent | train | func (ed *Dispatcher) HandleStopEvent(e Event) {
event := e.(*StopEvent)
logger.Debugf("Stopping dispatcher...")
if !ed.setState(dispatcherStateStarted, dispatcherStateStopped) {
logger.Warn("Cannot stop event dispatcher since it's already stopped.")
event.ErrCh <- errors.New("dispatcher already stopped")
ret... | go | {
"resource": ""
} |
q29762 | HandleTransferEvent | train | func (ed *Dispatcher) HandleTransferEvent(e Event) {
event := e.(*TransferEvent)
event.SnapshotCh <- ed.newSnapshot()
// Remove all registrations but don't close the associated event channels
ed.clearRegistrations(false)
} | go | {
"resource": ""
} |
q29763 | HandleStopAndTransferEvent | train | func (ed *Dispatcher) HandleStopAndTransferEvent(e Event) {
event := e.(*StopAndTransferEvent)
logger.Debugf("Stopping dispatcher...")
if !ed.setState(dispatcherStateStarted, dispatcherStateStopped) {
logger.Warn("Cannot stop event dispatcher since it's already stopped.")
event.ErrCh <- errors.New("dispatcher a... | go | {
"resource": ""
} |
q29764 | HandleBlock | train | func (ed *Dispatcher) HandleBlock(block *cb.Block, sourceURL string) {
logger.Debugf("Handling block event - Block #%d", block.Header.Number)
if err := ed.updateLastBlockNum(block.Header.Number); err != nil {
logger.Error(err.Error())
return
}
if ed.updateLastBlockInfoOnly {
ed.updateLastBlockInfoOnly = fal... | go | {
"resource": ""
} |
q29765 | HandleFilteredBlock | train | func (ed *Dispatcher) HandleFilteredBlock(fblock *pb.FilteredBlock, sourceURL string) {
logger.Debugf("Handling filtered block event - Block #%d", fblock.Number)
if err := ed.updateLastBlockNum(fblock.Number); err != nil {
logger.Error(err.Error())
return
}
if ed.updateLastBlockInfoOnly {
ed.updateLastBlock... | go | {
"resource": ""
} |
q29766 | RegisterHandler | train | func (ed *Dispatcher) RegisterHandler(t interface{}, h Handler) {
htype := reflect.TypeOf(t)
if _, ok := ed.handlers[htype]; !ok {
logger.Debugf("Registering handler for %s on dispatcher %T", htype, ed)
ed.handlers[htype] = h
} else {
logger.Debugf("Cannot register handler %s on dispatcher %T since it's alread... | go | {
"resource": ""
} |
q29767 | NewCertPool | train | func NewCertPool(useSystemCertPool bool) (fab.CertPool, error) {
c, err := loadSystemCertPool(useSystemCertPool)
if err != nil {
return nil, err
}
newCertPool := &certPool{
certsByName: make(map[string][]int),
certPool: c,
systemCertPool: useSystemCertPool,
}
return newCertPool, nil
} | go | {
"resource": ""
} |
q29768 | filterCerts | train | func (c *certPool) filterCerts(certs ...*x509.Certificate) []*x509.Certificate {
c.lock.RLock()
defer c.lock.RUnlock()
filtered := []*x509.Certificate{}
CertLoop:
for _, cert := range certs {
if cert == nil {
continue
}
possibilities := c.certsByName[string(cert.RawSubject)]
for _, p := range possibili... | go | {
"resource": ""
} |
q29769 | New | train | func New(ctx fabcontext.Client) (*Client, error) {
authInfo, err := newAuthInfo(ctx)
if err != nil {
return nil, err
}
return &Client{
ctx: ctx,
authInfo: authInfo,
}, nil
} | go | {
"resource": ""
} |
q29770 | NewUser | train | func (mgr *IdentityManager) NewUser(userData *msp.UserData) (*User, error) {
return newUser(userData, mgr.cryptoSuite)
} | go | {
"resource": ""
} |
q29771 | GetSigningIdentity | train | func (mgr *IdentityManager) GetSigningIdentity(id string) (msp.SigningIdentity, error) {
user, err := mgr.GetUser(id)
if err != nil {
return nil, err
}
return user, nil
} | go | {
"resource": ""
} |
q29772 | GetUser | train | func (mgr *IdentityManager) GetUser(username string) (*User, error) { //nolint
u, err := mgr.loadUserFromStore(username)
if err != nil {
if err != msp.ErrUserNotFound {
return nil, errors.WithMessage(err, "loading user from store failed")
}
// Not found, continue
}
if u == nil {
certBytes := mgr.getEmb... | go | {
"resource": ""
} |
q29773 | NewMockChannelConfig | train | func NewMockChannelConfig(ctx context.Client, channelID string) (*MockChannelConfig, error) {
return &MockChannelConfig{channelID: channelID, ctx: ctx}, nil
} | go | {
"resource": ""
} |
q29774 | Query | train | func (c *MockChannelConfig) Query(reqCtx reqContext.Context) (fab.ChannelCfg, error) {
return NewMockChannelCfg(c.channelID), nil
} | go | {
"resource": ""
} |
q29775 | PickRandomNPeerConfigs | train | func PickRandomNPeerConfigs(chPeers []fab.ChannelPeer, n int) []fab.PeerConfig {
var result []fab.PeerConfig
for _, index := range rand.Perm(len(chPeers)) {
result = append(result, chPeers[index].PeerConfig)
if len(result) == n {
break
}
}
return result
} | go | {
"resource": ""
} |
q29776 | ProcessTransactionProposal | train | func (p *peerEndorser) ProcessTransactionProposal(ctx reqContext.Context, request fab.ProcessProposalRequest) (*fab.TransactionProposalResponse, error) {
logger.Debugf("Processing proposal using endorser: %s", p.target)
proposalResponse, err := p.sendProposal(ctx, request)
if err != nil {
tpr := fab.TransactionPr... | go | {
"resource": ""
} |
q29777 | extractChaincodeErrorFromResponse | train | func extractChaincodeErrorFromResponse(resp *pb.ProposalResponse) error {
if resp.Response.Status < int32(common.Status_SUCCESS) || resp.Response.Status >= int32(common.Status_BAD_REQUEST) {
details := []interface{}{resp.Endorsement, resp.Response.Payload}
if strings.Contains(resp.Response.Message, "premature exec... | go | {
"resource": ""
} |
q29778 | getChaincodeResponseStatus | train | func getChaincodeResponseStatus(response *pb.ProposalResponse) (int32, error) {
if response.Payload != nil {
payload, err := protoutil.GetProposalResponsePayload(response.Payload)
if err != nil {
return 0, errors.Wrap(err, "unmarshal of proposal response payload failed")
}
extension, err := protoutil.GetCh... | go | {
"resource": ""
} |
q29779 | CreateChaincodeInstallProposal | train | func CreateChaincodeInstallProposal(txh fab.TransactionHeader, request ChaincodeInstallRequest) (*fab.TransactionProposal, error) {
cir, err := createInstallInvokeRequest(request)
if err != nil {
return nil, errors.WithMessage(err, "creating lscc install invocation request failed")
}
return txn.CreateChaincodeIn... | go | {
"resource": ""
} |
q29780 | New | train | func New(dispatcher service.Dispatcher, context context.Client, channelID string, opts ...options.Opt) *PeerResolver {
params := defaultParams(context, channelID)
options.Apply(params, opts)
logger.Debugf("Creating new balanced peer resolver")
return &PeerResolver{
params: params,
}
} | go | {
"resource": ""
} |
q29781 | Resolve | train | func (r *PeerResolver) Resolve(peers []fab.Peer) (fab.Peer, error) {
return r.loadBalancePolicy.Choose(peers)
} | go | {
"resource": ""
} |
q29782 | NewLocalProvider | train | func NewLocalProvider(config fab.EndpointConfig) (*LocalProvider, error) {
return &LocalProvider{config: config}, nil
} | go | {
"resource": ""
} |
q29783 | Initialize | train | func (dp *LocalProvider) Initialize(fabPvdr contextAPI.Providers) error {
dp.fabPvdr = fabPvdr.InfraProvider()
return nil
} | go | {
"resource": ""
} |
q29784 | CreateLocalDiscoveryService | train | func (dp *LocalProvider) CreateLocalDiscoveryService(mspID string) (fab.DiscoveryService, error) {
peers := []fab.Peer{}
netPeers := dp.config.NetworkPeers()
logger.Debugf("Found %d peers", len(netPeers))
for _, p := range netPeers {
newPeer, err := dp.fabPvdr.CreatePeerFromConfig(&fab.NetworkPeer{PeerConfig: p... | go | {
"resource": ""
} |
q29785 | GetBalancer | train | func GetBalancer(policy fab.EventServicePolicy) lbp.LoadBalancePolicy {
switch policy.Balancer {
case fab.RoundRobin:
logger.Debugf("Using round-robin load balancer.")
return lbp.NewRoundRobin()
case fab.Random:
logger.Debugf("Using random load balancer.")
return lbp.NewRandom()
default:
logger.Debugf("Ba... | go | {
"resource": ""
} |
q29786 | New | train | func New(dispatcher service.Dispatcher, context context.Client, channelID string, opts ...options.Opt) *PeerResolver {
params := defaultParams(context, channelID)
options.Apply(params, opts)
mspID := context.Identifier().MSPID
logger.Debugf("Creating new PreferOrg peer resolver with options: MSP ID [%s]", mspID)
... | go | {
"resource": ""
} |
q29787 | Resolve | train | func (r *PeerResolver) Resolve(peers []fab.Peer) (fab.Peer, error) {
filteredPeers := r.blockHeightResolver.Filter(peers)
var orgPeers []fab.Peer
for _, p := range filteredPeers {
if p.MSPID() == r.mspID {
orgPeers = append(orgPeers, p)
}
}
if len(orgPeers) > 0 {
// Our org is in the list. Use the defau... | go | {
"resource": ""
} |
q29788 | ShouldDisconnect | train | func (r *PeerResolver) ShouldDisconnect(peers []fab.Peer, connectedPeer fab.Peer) bool {
if connectedPeer.MSPID() != r.mspID {
// We're connected to a peer not in our org. Check if we can connect back to one of our peers.
logger.Debugf("Currently connected to [%s]. Checking if there are any peers from [%s] that ar... | go | {
"resource": ""
} |
q29789 | NewRoundRobinPeerGroupResolver | train | func NewRoundRobinPeerGroupResolver(sigPolicyEnv *common.SignaturePolicyEnvelope) (PeerGroupResolver, error) {
groupRetriever, err := CompileSignaturePolicy(sigPolicyEnv)
if err != nil {
return nil, errors.WithMessage(err, "error evaluating signature policy")
}
return NewPeerGroupResolver(groupRetriever, NewRound... | go | {
"resource": ""
} |
q29790 | NewRandomPeerGroupResolver | train | func NewRandomPeerGroupResolver(sigPolicyEnv *common.SignaturePolicyEnvelope) (PeerGroupResolver, error) {
groupRetriever, err := CompileSignaturePolicy(sigPolicyEnv)
if err != nil {
return nil, errors.WithMessage(err, "error evaluating signature policy")
}
return NewPeerGroupResolver(groupRetriever, NewRandomLBP... | go | {
"resource": ""
} |
q29791 | NewPeerGroupResolver | train | func NewPeerGroupResolver(groupRetriever GroupRetriever, lbp LoadBalancePolicy) (PeerGroupResolver, error) {
return &peerGroupResolver{
groupRetriever: groupRetriever,
lbp: lbp,
}, nil
} | go | {
"resource": ""
} |
q29792 | CompileSignaturePolicy | train | func CompileSignaturePolicy(sigPolicyEnv *common.SignaturePolicyEnvelope) (GroupRetriever, error) {
compiler := &signaturePolicyCompiler{}
return compiler.Compile(sigPolicyEnv)
} | go | {
"resource": ""
} |
q29793 | Match | train | func (tprv *TransactionProposalResponseVerifier) Match(transactionProposalResponses []*fab.TransactionProposalResponse) error {
if tprv.MinResponses <= 0 {
return errors.New("minimum Responses has to be greater than zero")
}
if len(transactionProposalResponses) < tprv.MinResponses {
return errors.Errorf("requir... | go | {
"resource": ""
} |
q29794 | WithBlockEvents | train | func WithBlockEvents() options.Opt {
return func(p options.Params) {
if setter, ok := p.(permitBlockEventsSetter); ok {
setter.PermitBlockEvents()
}
}
} | go | {
"resource": ""
} |
q29795 | WithReconnect | train | func WithReconnect(value bool) options.Opt {
return func(p options.Params) {
if setter, ok := p.(reconnectSetter); ok {
setter.SetReconnect(value)
}
}
} | go | {
"resource": ""
} |
q29796 | WithMaxConnectAttempts | train | func WithMaxConnectAttempts(value uint) options.Opt {
return func(p options.Params) {
if setter, ok := p.(maxConnectAttemptsSetter); ok {
setter.SetMaxConnectAttempts(value)
}
}
} | go | {
"resource": ""
} |
q29797 | WithMaxReconnectAttempts | train | func WithMaxReconnectAttempts(value uint) options.Opt {
return func(p options.Params) {
if setter, ok := p.(maxReconnectAttemptsSetter); ok {
setter.SetMaxReconnectAttempts(value)
}
}
} | go | {
"resource": ""
} |
q29798 | WithReconnectInitialDelay | train | func WithReconnectInitialDelay(value time.Duration) options.Opt {
return func(p options.Params) {
if setter, ok := p.(reconnectInitialDelaySetter); ok {
setter.SetReconnectInitialDelay(value)
}
}
} | go | {
"resource": ""
} |
q29799 | WithTimeBetweenConnectAttempts | train | func WithTimeBetweenConnectAttempts(value time.Duration) options.Opt {
return func(p options.Params) {
if setter, ok := p.(timeBetweenConnectAttemptsSetter); ok {
setter.SetTimeBetweenConnectAttempts(value)
}
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.