_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q29900 | SetConnectionProvider | train | func (p *params) SetConnectionProvider(connProvider api.ConnectionProvider) {
logger.Debugf("ConnectionProvider: %#v", connProvider)
p.connProvider = connProvider
} | go | {
"resource": ""
} |
q29901 | NewMockLedger | train | func NewMockLedger(eventFactory EventFactory, sourceURL string) *MockLedger {
return &MockLedger{
eventFactory: eventFactory,
blockProducer: NewBlockProducer(),
sourceURL: sourceURL,
}
} | go | {
"resource": ""
} |
q29902 | Register | train | func (l *MockLedger) Register(consumer Consumer) {
l.Lock()
defer l.Unlock()
l.consumers = append(l.consumers, consumer)
} | go | {
"resource": ""
} |
q29903 | Unregister | train | func (l *MockLedger) Unregister(Consumer Consumer) {
l.Lock()
defer l.Unlock()
for i, p := range l.consumers {
if p == Consumer {
if i != 0 {
l.consumers = l.consumers[1:]
}
l.consumers = l.consumers[1:]
break
}
}
} | go | {
"resource": ""
} |
q29904 | NewBlock | train | func (l *MockLedger) NewBlock(channelID string, transactions ...*TxInfo) Block {
l.Lock()
defer l.Unlock()
block := NewBlockWrapper(l.blockProducer.NewBlock(channelID, transactions...))
l.Store(block)
return block
} | go | {
"resource": ""
} |
q29905 | NewFilteredBlock | train | func (l *MockLedger) NewFilteredBlock(channelID string, filteredTx ...*pb.FilteredTransaction) {
l.Lock()
defer l.Unlock()
l.Store(NewFilteredBlockWrapper(l.blockProducer.NewFilteredBlock(channelID, filteredTx...)))
} | go | {
"resource": ""
} |
q29906 | Store | train | func (l *MockLedger) Store(block Block) {
l.blocks = append(l.blocks, block)
for _, p := range l.consumers {
blockEvent := l.eventFactory(block, l.sourceURL)
p <- blockEvent
}
} | go | {
"resource": ""
} |
q29907 | SendFrom | train | func (l *MockLedger) SendFrom(blockNum uint64) {
l.RLock()
defer l.RUnlock()
if blockNum >= uint64(len(l.blocks)) {
return
}
for _, block := range l.blocks[blockNum:] {
for _, p := range l.consumers {
p <- l.eventFactory(block, l.sourceURL)
}
}
} | go | {
"resource": ""
} |
q29908 | newLocalService | train | func newLocalService(config fab.EndpointConfig, mspID string, opts ...coptions.Opt) *LocalService {
logger.Debug("Creating new local discovery service")
s := &LocalService{mspID: mspID}
s.service = newService(config, s.queryPeers, opts...)
return s
} | go | {
"resource": ""
} |
q29909 | Initialize | train | func (s *LocalService) Initialize(ctx contextAPI.Local) error {
if ctx.Identifier().MSPID != s.mspID {
return errors.Errorf("expecting context for MSP [%s] but got [%s]", s.mspID, ctx.Identifier().MSPID)
}
return s.service.initialize(ctx)
} | go | {
"resource": ""
} |
q29910 | filterLocalMSP | train | func (s *LocalService) filterLocalMSP(peers []fab.Peer) []fab.Peer {
localMSPID := s.ctx.Identifier().MSPID
var filteredPeers []fab.Peer
for _, p := range peers {
if p.MSPID() != localMSPID {
logger.Debugf("Peer [%s] is not part of the local MSP [%s] but in MSP [%s]", p.URL(), localMSPID, p.MSPID())
} else {
... | go | {
"resource": ""
} |
q29911 | NewTransactor | train | func NewTransactor(reqCtx reqContext.Context, cfg fab.ChannelCfg) (*Transactor, error) {
ctx, ok := contextImpl.RequestClientContext(reqCtx)
if !ok {
return nil, errors.New("failed get client context from reqContext for create new transactor")
}
orderers, err := orderersFromChannelCfg(ctx, cfg)
if err != nil {... | go | {
"resource": ""
} |
q29912 | orderersFromChannel | train | func orderersFromChannel(ctx context.Client, channelID string) ([]fab.Orderer, error) {
chNetworkConfig := ctx.EndpointConfig().ChannelConfig(channelID)
orderers := []fab.Orderer{}
for _, chOrderer := range chNetworkConfig.Orderers {
ordererConfig, found := ctx.EndpointConfig().OrdererConfig(chOrderer)
if !fou... | go | {
"resource": ""
} |
q29913 | NewParams | train | func NewParams(opts []copts.Opt) *Params {
params := &Params{}
copts.Apply(params, opts)
return params
} | go | {
"resource": ""
} |
q29914 | WithPeerFilter | train | func WithPeerFilter(value PeerFilter) copts.Opt {
return func(p copts.Params) {
logger.Debugf("Checking PeerFilter: %#+v", value)
if setter, ok := p.(peerFilterSetter); ok {
setter.SetPeerFilter(value)
}
}
} | go | {
"resource": ""
} |
q29915 | WithPeerSorter | train | func WithPeerSorter(value PeerSorter) copts.Opt {
return func(p copts.Params) {
if setter, ok := p.(peerSorterSetter); ok {
setter.SetPeerSorter(value)
}
}
} | go | {
"resource": ""
} |
q29916 | WithPrioritySelector | train | func WithPrioritySelector(value PrioritySelector) copts.Opt {
return WithPeerSorter(func(peers []fab.Peer) []fab.Peer {
return sortPeers(peers, value)
})
} | go | {
"resource": ""
} |
q29917 | WithRetryOpts | train | func WithRetryOpts(value retry.Opts) copts.Opt {
return func(p copts.Params) {
if setter, ok := p.(retryOptsSetter); ok {
setter.SetRetryOpts(value)
}
}
} | go | {
"resource": ""
} |
q29918 | SetPeerFilter | train | func (p *Params) SetPeerFilter(value PeerFilter) {
logger.Debugf("PeerFilter: %#+v", value)
p.PeerFilter = value
} | go | {
"resource": ""
} |
q29919 | SetPeerSorter | train | func (p *Params) SetPeerSorter(value PeerSorter) {
logger.Debugf("PeerSorter: %#+v", value)
p.PeerSorter = value
} | go | {
"resource": ""
} |
q29920 | SetRetryOpts | train | func (p *Params) SetRetryOpts(value retry.Opts) {
logger.Debugf("RetryOpts: %#+v", value)
p.RetryOpts = value
} | go | {
"resource": ""
} |
q29921 | NewInvoker | train | func NewInvoker(handler Handler, opts ...InvokerOpt) *RetryableInvoker {
invoker := &RetryableInvoker{
handler: handler,
}
for _, opt := range opts {
opt(invoker)
}
return invoker
} | go | {
"resource": ""
} |
q29922 | Invoke | train | func (ri *RetryableInvoker) Invoke(invocation Invocation) (interface{}, error) {
attemptNum := 0
var lastErr error
for {
attemptNum++
if attemptNum > 1 {
logger.Debugf("Retry attempt #%d on error [%s]", attemptNum, lastErr)
}
retval, err := invocation()
if err == nil {
if attemptNum > 1 {
logge... | go | {
"resource": ""
} |
q29923 | GetLogger | train | func (p *Provider) GetLogger(module string) api.Logger {
newDefLogger := log.New(os.Stdout, fmt.Sprintf(logPrefixFormatter, module), log.Ldate|log.Ltime|log.LUTC)
return &Log{deflogger: newDefLogger, module: module}
} | go | {
"resource": ""
} |
q29924 | InitLogger | train | func InitLogger(l api.LoggerProvider) {
loggerProviderOnce.Do(func() {
loggerProviderInstance = l
atomic.StoreInt32(&useCustomLogger, 1)
})
} | go | {
"resource": ""
} |
q29925 | SetLevel | train | func SetLevel(module string, level api.Level) {
rwmutex.Lock()
defer rwmutex.Unlock()
moduleLevels.SetLevel(module, level)
} | go | {
"resource": ""
} |
q29926 | GetLevel | train | func GetLevel(module string) api.Level {
rwmutex.RLock()
defer rwmutex.RUnlock()
return moduleLevels.GetLevel(module)
} | go | {
"resource": ""
} |
q29927 | IsEnabledFor | train | func IsEnabledFor(module string, level api.Level) bool {
rwmutex.RLock()
defer rwmutex.RUnlock()
return moduleLevels.IsEnabledFor(module, level)
} | go | {
"resource": ""
} |
q29928 | HideCallerInfo | train | func HideCallerInfo(module string, level api.Level) {
rwmutex.Lock()
defer rwmutex.Unlock()
callerInfos.HideCallerInfo(module, level)
} | go | {
"resource": ""
} |
q29929 | getLoggerOpts | train | func getLoggerOpts(module string, level api.Level) *loggerOpts {
rwmutex.RLock()
defer rwmutex.RUnlock()
return &loggerOpts{
levelEnabled: moduleLevels.IsEnabledFor(module, level),
callerInfoEnabled: callerInfos.IsCallerInfoEnabled(module, level),
}
} | go | {
"resource": ""
} |
q29930 | Print | train | func (l *Log) Print(args ...interface{}) {
if l.loadCustomLogger() {
l.customLogger.Print(args...)
return
}
l.deflogger.Print(args...)
} | go | {
"resource": ""
} |
q29931 | Printf | train | func (l *Log) Printf(format string, args ...interface{}) {
if l.loadCustomLogger() {
l.customLogger.Printf(format, args...)
return
}
l.deflogger.Printf(format, args...)
} | go | {
"resource": ""
} |
q29932 | Println | train | func (l *Log) Println(args ...interface{}) {
if l.loadCustomLogger() {
l.customLogger.Println(args...)
return
}
l.deflogger.Println(args...)
} | go | {
"resource": ""
} |
q29933 | Debug | train | func (l *Log) Debug(args ...interface{}) {
opts := getLoggerOpts(l.module, api.DEBUG)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Debug(args...)
return
}
l.log(opts, api.DEBUG, args...)
} | go | {
"resource": ""
} |
q29934 | Debugf | train | func (l *Log) Debugf(format string, args ...interface{}) {
opts := getLoggerOpts(l.module, api.DEBUG)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Debugf(format, args...)
return
}
l.logf(opts, api.DEBUG, format, args...)
} | go | {
"resource": ""
} |
q29935 | Debugln | train | func (l *Log) Debugln(args ...interface{}) {
opts := getLoggerOpts(l.module, api.DEBUG)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Debugln(args...)
return
}
l.logln(opts, api.DEBUG, args...)
} | go | {
"resource": ""
} |
q29936 | Info | train | func (l *Log) Info(args ...interface{}) {
opts := getLoggerOpts(l.module, api.INFO)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Info(args...)
return
}
l.log(opts, api.INFO, args...)
} | go | {
"resource": ""
} |
q29937 | Infof | train | func (l *Log) Infof(format string, args ...interface{}) {
opts := getLoggerOpts(l.module, api.INFO)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Infof(format, args...)
return
}
l.logf(opts, api.INFO, format, args...)
} | go | {
"resource": ""
} |
q29938 | Infoln | train | func (l *Log) Infoln(args ...interface{}) {
opts := getLoggerOpts(l.module, api.INFO)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Infoln(args...)
return
}
l.logln(opts, api.INFO, args...)
} | go | {
"resource": ""
} |
q29939 | Warn | train | func (l *Log) Warn(args ...interface{}) {
opts := getLoggerOpts(l.module, api.WARNING)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Warn(args...)
return
}
l.log(opts, api.WARNING, args...)
} | go | {
"resource": ""
} |
q29940 | Warnf | train | func (l *Log) Warnf(format string, args ...interface{}) {
opts := getLoggerOpts(l.module, api.WARNING)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Warnf(format, args...)
return
}
l.logf(opts, api.WARNING, format, args...)
} | go | {
"resource": ""
} |
q29941 | Warnln | train | func (l *Log) Warnln(args ...interface{}) {
opts := getLoggerOpts(l.module, api.WARNING)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Warnln(args...)
return
}
l.logln(opts, api.WARNING, args...)
} | go | {
"resource": ""
} |
q29942 | Error | train | func (l *Log) Error(args ...interface{}) {
opts := getLoggerOpts(l.module, api.ERROR)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Error(args...)
return
}
l.log(opts, api.ERROR, args...)
} | go | {
"resource": ""
} |
q29943 | Errorf | train | func (l *Log) Errorf(format string, args ...interface{}) {
opts := getLoggerOpts(l.module, api.ERROR)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Errorf(format, args...)
return
}
l.logf(opts, api.ERROR, format, args...)
} | go | {
"resource": ""
} |
q29944 | Errorln | train | func (l *Log) Errorln(args ...interface{}) {
opts := getLoggerOpts(l.module, api.ERROR)
if !opts.levelEnabled {
return
}
if l.loadCustomLogger() {
l.customLogger.Errorln(args...)
return
}
l.logln(opts, api.ERROR, args...)
} | go | {
"resource": ""
} |
q29945 | ChangeOutput | train | func (l *Log) ChangeOutput(output io.Writer) {
l.deflogger.SetOutput(output)
} | go | {
"resource": ""
} |
q29946 | Accept | train | func (b *Filter) Accept(peer fab.Peer) bool {
peerAddress := endpoint.ToAddress(peer.URL())
value, ok := b.greylistURLs.Load(peerAddress)
if ok {
timeAdded, ok := value.(time.Time)
if ok && timeAdded.Add(b.expiryInterval).After(time.Now()) {
logger.Infof("Rejecting peer %s", peer.URL())
return false
}
... | go | {
"resource": ""
} |
q29947 | Greylist | train | func (b *Filter) Greylist(err error) {
s, ok := status.FromError(err)
if !ok {
return
}
if ok, peerURL := required(s); ok && peerURL != "" {
logger.Infof("Greylisting peer %s", peerURL)
b.greylistURLs.Store(peerURL, time.Now())
}
} | go | {
"resource": ""
} |
q29948 | required | train | func required(s *status.Status) (bool, string) {
if s.Group == status.EndorserClientStatus && s.Code == status.ConnectionFailed.ToInt32() {
return true, peerURLFromConnectionFailedStatus(s.Details)
}
return false, ""
} | go | {
"resource": ""
} |
q29949 | peerURLFromConnectionFailedStatus | train | func peerURLFromConnectionFailedStatus(details []interface{}) string {
if len(details) != 0 {
url, ok := details[0].(string)
if ok {
return endpoint.ToAddress(url)
}
}
return ""
} | go | {
"resource": ""
} |
q29950 | initialize | train | func (s *service) initialize(ctx contextAPI.Client) error {
s.lock.Lock()
defer s.lock.Unlock()
if s.ctx != nil {
// Already initialized
logger.Debugf("Already initialized with context: %#v", s.ctx)
return nil
}
discoveryClient, err := clientProvider(ctx)
if err != nil {
return errors.Wrap(err, "error c... | go | {
"resource": ""
} |
q29951 | GetPeers | train | func (s *service) GetPeers() ([]fab.Peer, error) {
if s.peersRef.IsClosed() {
return nil, errors.Errorf("Discovery client has been closed")
}
refValue, err := s.peersRef.Get()
if err != nil {
return nil, err
}
peers, ok := refValue.([]fab.Peer)
if !ok {
return nil, errors.New("get peersRef didn't return P... | go | {
"resource": ""
} |
q29952 | createChaincodeDeployProposal | train | func createChaincodeDeployProposal(txh fab.TransactionHeader, deploy chaincodeProposalType, channelID string, chaincode chaincodeDeployRequest) (*fab.TransactionProposal, error) {
// Generate arguments for deploy (channel, marshaled CCDS, marshaled chaincode policy, marshaled collection policy)
args := [][]byte{}
a... | go | {
"resource": ""
} |
q29953 | NewMockChannel | train | func NewMockChannel(channelID string) (*Channel, error) {
ctx := &mockClientContext{
Providers: NewMockProviderContext(),
SigningIdentity: mspmocks.NewMockSigningIdentity("user", "Org1MSP"),
}
// Set up mock channel service
chProvider, err := NewMockChannelProvider(ctx)
if err != nil {
return nil, er... | go | {
"resource": ""
} |
q29954 | String | train | func (c Code) String() string {
if s, ok := CodeName[c.ToInt32()]; ok {
return s
}
return strconv.Itoa(int(c))
} | go | {
"resource": ""
} |
q29955 | GetDefault | train | func GetDefault() core.CryptoSuite {
if atomic.LoadInt32(&initialized) > 0 {
return defaultCryptoSuite
}
//Set default suite
logger.Info("No default cryptosuite found, using default SW implementation")
// Use SW as the default cryptosuite when not initialized properly - should be for testing only
s, err := sw.... | go | {
"resource": ""
} |
q29956 | WithRetry | train | func WithRetry(retry retry.Opts) Opt {
return func(options *options) {
options.retry = retry
}
} | go | {
"resource": ""
} |
q29957 | SignChannelConfig | train | func SignChannelConfig(ctx context.Client, config []byte, signer msp.SigningIdentity) (*common.ConfigSignature, error) {
logger.Debug("SignChannelConfig - start")
if config == nil {
return nil, errors.New("channel configuration required")
}
signingUser := signer
// If signing user is not provided default to cl... | go | {
"resource": ""
} |
q29958 | CreateChannel | train | func CreateChannel(reqCtx reqContext.Context, request CreateChannelRequest, opts ...Opt) (fab.TransactionID, error) {
if request.Orderer == nil {
return fab.EmptyTransactionID, errors.New("missing orderer request parameter for the initialize channel")
}
if request.Name == "" {
return fab.EmptyTransactionID, err... | go | {
"resource": ""
} |
q29959 | GenesisBlockFromOrderer | train | func GenesisBlockFromOrderer(reqCtx reqContext.Context, channelName string, orderer fab.Orderer, opts ...Opt) (*common.Block, error) {
optionsValue := getOpts(opts...)
return retrieveBlock(reqCtx, []fab.Orderer{orderer}, channelName, newSpecificSeekPosition(0), optionsValue)
} | go | {
"resource": ""
} |
q29960 | LastConfigFromOrderer | train | func LastConfigFromOrderer(reqCtx reqContext.Context, channelName string, orderer fab.Orderer, opts ...Opt) (*common.Block, error) {
logger.Debugf("channelConfig - start for channel %s", channelName)
optionsValue := getOpts(opts...)
// Get the newest block
block, err := retrieveBlock(reqCtx, []fab.Orderer{orderer... | go | {
"resource": ""
} |
q29961 | createOrUpdateChannel | train | func createOrUpdateChannel(reqCtx reqContext.Context, txh *txn.TransactionHeader, request CreateChannelRequest) error {
configUpdateEnvelope := &common.ConfigUpdateEnvelope{
ConfigUpdate: request.Config,
Signatures: request.Signatures,
}
configUpdateEnvelopeBytes, err := proto.Marshal(configUpdateEnvelope)
i... | go | {
"resource": ""
} |
q29962 | QueryChannels | train | func QueryChannels(reqCtx reqContext.Context, peer fab.ProposalProcessor, opts ...Opt) (*pb.ChannelQueryResponse, error) {
if peer == nil {
return nil, errors.New("peer required")
}
optionsValue := getOpts(opts...)
cir := createChannelsInvokeRequest()
payload, err := queryChaincodeWithTarget(reqCtx, cir, peer... | go | {
"resource": ""
} |
q29963 | InstallChaincode | train | func InstallChaincode(reqCtx reqContext.Context, req InstallChaincodeRequest, targets []fab.ProposalProcessor, opts ...Opt) ([]*fab.TransactionProposalResponse, fab.TransactionID, error) {
if req.Name == "" {
return nil, fab.EmptyTransactionID, errors.New("chaincode name required")
}
if req.Path == "" {
return ... | go | {
"resource": ""
} |
q29964 | WithHostOverride | train | func WithHostOverride(value string) options.Opt {
return func(p options.Params) {
if setter, ok := p.(hostOverrideSetter); ok {
setter.SetHostOverride(value)
}
}
} | go | {
"resource": ""
} |
q29965 | WithCertificate | train | func WithCertificate(value *x509.Certificate) options.Opt {
return func(p options.Params) {
if setter, ok := p.(certificateSetter); ok {
setter.SetCertificate(value)
}
}
} | go | {
"resource": ""
} |
q29966 | WithKeepAliveParams | train | func WithKeepAliveParams(value keepalive.ClientParameters) options.Opt {
return func(p options.Params) {
if setter, ok := p.(keepAliveParamsSetter); ok {
setter.SetKeepAliveParams(value)
}
}
} | go | {
"resource": ""
} |
q29967 | WithFailFast | train | func WithFailFast(value bool) options.Opt {
return func(p options.Params) {
if setter, ok := p.(failFastSetter); ok {
setter.SetFailFast(value)
}
}
} | go | {
"resource": ""
} |
q29968 | WithConnectTimeout | train | func WithConnectTimeout(value time.Duration) options.Opt {
return func(p options.Params) {
if setter, ok := p.(connectTimeoutSetter); ok {
setter.SetConnectTimeout(value)
}
}
} | go | {
"resource": ""
} |
q29969 | WithInsecure | train | func WithInsecure() options.Opt {
return func(p options.Params) {
if setter, ok := p.(insecureSetter); ok {
setter.SetInsecure(true)
}
}
} | go | {
"resource": ""
} |
q29970 | OptsFromPeerConfig | train | func OptsFromPeerConfig(peerCfg *fab.PeerConfig) []options.Opt {
opts := []options.Opt{
WithHostOverride(getServerNameOverride(peerCfg)),
WithFailFast(getFailFast(peerCfg)),
WithKeepAliveParams(getKeepAliveOptions(peerCfg)),
WithCertificate(peerCfg.TLSCACert),
}
if isInsecureAllowed(peerCfg) {
opts = appe... | go | {
"resource": ""
} |
q29971 | New | train | func New(dispatcher service.Dispatcher, context context.Client, channelID string, preferredPeers []string, opts ...options.Opt) *PeerResolver {
params := defaultParams(context, channelID)
options.Apply(params, opts)
logger.Debugf("Creating new PreferPeer peer resolver with options: Preferred Peers [%s]", preferredP... | go | {
"resource": ""
} |
q29972 | Resolve | train | func (r *PeerResolver) Resolve(peers []fab.Peer) (fab.Peer, error) {
preferredPeers := r.getPreferredPeers(r.minBlockHeightResolver.Filter(peers))
if len(preferredPeers) > 0 {
// At least one of our preferred peers is suitable. Use the default balancer to balance between them.
logger.Debugf("Choosing a peer from ... | go | {
"resource": ""
} |
q29973 | ShouldDisconnect | train | func (r *PeerResolver) ShouldDisconnect(peers []fab.Peer, connectedPeer fab.Peer) bool {
if !r.isPreferred(connectedPeer) {
// We're not connected to a preferred peer. Check if we can connect back to one.
logger.Debugf("Currently connected to [%s]. Checking if any of the preferred peers [%s] is suitable to connect... | go | {
"resource": ""
} |
q29974 | WithLoadBalancePolicy | train | func WithLoadBalancePolicy(value lbp.LoadBalancePolicy) options.Opt {
return func(p options.Params) {
if setter, ok := p.(loadBalancePolicySetter); ok {
setter.SetLoadBalancePolicy(value)
}
}
} | go | {
"resource": ""
} |
q29975 | WithPeerMonitorPeriod | train | func WithPeerMonitorPeriod(value time.Duration) options.Opt {
return func(p options.Params) {
if setter, ok := p.(peerMonitorPeriodSetter); ok {
setter.SetPeerMonitorPeriod(value)
}
}
} | go | {
"resource": ""
} |
q29976 | WithPeerResolver | train | func WithPeerResolver(value peerresolver.Provider) options.Opt {
return func(p options.Params) {
if setter, ok := p.(peerResolverSetter); ok {
setter.SetPeerResolver(value)
}
}
} | go | {
"resource": ""
} |
q29977 | NewPrincipal | train | func NewPrincipal(name string, classification mb.MSPPrincipal_Classification) (*mb.MSPPrincipal, error) {
member1Role, err := proto.Marshal(&mb.MSPRole{Role: mb.MSPRole_MEMBER, MspIdentifier: name})
if err != nil {
return nil, errors.WithMessage(err, "Error marshal MSPRole")
}
return &mb.MSPPrincipal{
Principal... | go | {
"resource": ""
} |
q29978 | NewSignedByPolicy | train | func NewSignedByPolicy(index int32) *common.SignaturePolicy {
return &common.SignaturePolicy{
Type: &common.SignaturePolicy_SignedBy{
SignedBy: index,
}}
} | go | {
"resource": ""
} |
q29979 | NewNOutOfPolicy | train | func NewNOutOfPolicy(n int32, signedBy ...*common.SignaturePolicy) *common.SignaturePolicy {
return &common.SignaturePolicy{
Type: &common.SignaturePolicy_NOutOf_{
NOutOf: &common.SignaturePolicy_NOutOf{
N: n,
Rules: signedBy,
}}}
} | go | {
"resource": ""
} |
q29980 | GetPolicies | train | func GetPolicies(mspIDs ...string) (signedBy []*common.SignaturePolicy, identities []*mb.MSPPrincipal, err error) {
for i, mspID := range mspIDs {
signedBy = append(signedBy, NewSignedByPolicy(int32(i)))
principal, err := NewPrincipal(mspID, mb.MSPPrincipal_ROLE)
if err != nil {
return nil, nil, err
}
ide... | go | {
"resource": ""
} |
q29981 | NewIdentityManager | train | func NewIdentityManager(orgName string, userStore msp.UserStore, cryptoSuite core.CryptoSuite, endpointConfig fab.EndpointConfig) (*IdentityManager, error) {
netConfig := endpointConfig.NetworkConfig()
// viper keys are case insensitive
orgConfig, ok := netConfig.Organizations[strings.ToLower(orgName)]
if !ok {
... | go | {
"resource": ""
} |
q29982 | NewMockMSPManagerWithError | train | func NewMockMSPManagerWithError(msps map[string]msp.MSP, err error) *MockMSPManager {
return &MockMSPManager{MSPs: msps, Err: err}
} | go | {
"resource": ""
} |
q29983 | GetMSPs | train | func (mgr *MockMSPManager) GetMSPs() (map[string]msp.MSP, error) {
if mgr.Err != nil && mgr.Err.Error() == "GetMSPs" {
return nil, mgr.Err
}
return mgr.MSPs, nil
} | go | {
"resource": ""
} |
q29984 | NewMockIdentityManager | train | func NewMockIdentityManager(opts ...UsersOption) msp.IdentityManager {
manager := MockIdentityManager{}
usersOptions := UsersOptions{}
for _, param := range opts {
err := param(&usersOptions)
if err != nil {
panic(fmt.Errorf("failed to create IdentityManager: %s", err))
}
}
if usersOptions.users != nil... | go | {
"resource": ""
} |
q29985 | GetSigningIdentity | train | func (mgr *MockIdentityManager) GetSigningIdentity(id string) (msp.SigningIdentity, error) {
si, ok := mgr.users[id]
if !ok {
return nil, msp.ErrUserNotFound
}
return si, nil
} | go | {
"resource": ""
} |
q29986 | SendBroadcast | train | func (o *MockOrderer) SendBroadcast(ctx reqContext.Context, envelope *fab.SignedEnvelope) (*common.Status, error) {
// Report this call to the listener
if o.BroadcastListener != nil {
o.BroadcastQueue <- envelope
}
select {
case err := <-o.BroadcastErrors:
return nil, err
default:
return nil, nil
}
} | go | {
"resource": ""
} |
q29987 | NewBlock | train | func NewBlock(channelID string, transactions ...*TxInfo) *cb.Block {
var data [][]byte
txValidationFlags := make([]uint8, len(transactions))
for i, txInfo := range transactions {
envBytes, err := proto.Marshal(newEnvelope(channelID, txInfo))
if err != nil {
panic(err)
}
data = append(data, envBytes)
txV... | go | {
"resource": ""
} |
q29988 | NewTransaction | train | func NewTransaction(txID string, txValidationCode pb.TxValidationCode, headerType cb.HeaderType) *TxInfo {
return &TxInfo{
TxID: txID,
TxValidationCode: txValidationCode,
HeaderType: headerType,
}
} | go | {
"resource": ""
} |
q29989 | NewTransactionWithCCEvent | train | func NewTransactionWithCCEvent(txID string, txValidationCode pb.TxValidationCode, ccID string, eventName string, payload []byte) *TxInfo {
return &TxInfo{
TxID: txID,
TxValidationCode: txValidationCode,
ChaincodeID: ccID,
EventName: eventName,
Payload: payload,
HeaderType: ... | go | {
"resource": ""
} |
q29990 | NewFilteredBlock | train | func NewFilteredBlock(channelID string, filteredTx ...*pb.FilteredTransaction) *pb.FilteredBlock {
return &pb.FilteredBlock{
ChannelId: channelID,
FilteredTransactions: filteredTx,
}
} | go | {
"resource": ""
} |
q29991 | NewFilteredTx | train | func NewFilteredTx(txID string, txValidationCode pb.TxValidationCode) *pb.FilteredTransaction {
return &pb.FilteredTransaction{
Txid: txID,
TxValidationCode: txValidationCode,
}
} | go | {
"resource": ""
} |
q29992 | NewFilteredTxWithCCEvent | train | func NewFilteredTxWithCCEvent(txID, ccID, event string) *pb.FilteredTransaction {
return &pb.FilteredTransaction{
Txid: txID,
Data: &pb.FilteredTransaction_TransactionActions{
TransactionActions: &pb.FilteredTransactionActions{
ChaincodeActions: []*pb.FilteredChaincodeAction{
{
ChaincodeEvent: &p... | go | {
"resource": ""
} |
q29993 | New | train | func New(config fab.EndpointConfig, opts ...Option) (*Orderer, error) {
orderer := &Orderer{
config: config,
commManager: &defCommManager{},
}
for _, opt := range opts {
err := opt(orderer)
if err != nil {
return nil, err
}
}
var grpcOpts []grpc.DialOption
if orderer.kap.Time > 0 {
grpcOpts ... | go | {
"resource": ""
} |
q29994 | WithURL | train | func WithURL(url string) Option {
return func(o *Orderer) error {
o.url = url
return nil
}
} | go | {
"resource": ""
} |
q29995 | WithTLSCert | train | func WithTLSCert(tlsCACert *x509.Certificate) Option {
return func(o *Orderer) error {
o.tlsCACert = tlsCACert
return nil
}
} | go | {
"resource": ""
} |
q29996 | WithServerName | train | func WithServerName(serverName string) Option {
return func(o *Orderer) error {
o.serverName = serverName
return nil
}
} | go | {
"resource": ""
} |
q29997 | FromOrdererConfig | train | func FromOrdererConfig(ordererCfg *fab.OrdererConfig) Option {
return func(o *Orderer) error {
o.url = ordererCfg.URL
o.tlsCACert = ordererCfg.TLSCACert
if ordererCfg.GRPCOptions["allow-insecure"] == false {
//verify if certificate was expired or not yet valid
err := verifier.ValidateCertificateDates(o.tl... | go | {
"resource": ""
} |
q29998 | FromOrdererName | train | func FromOrdererName(name string) Option {
return func(o *Orderer) error {
ordererCfg, found := o.config.OrdererConfig(name)
if !found {
return errors.Errorf("orderer config not found for orderer : %s", name)
}
return FromOrdererConfig(ordererCfg)(o)
}
} | go | {
"resource": ""
} |
q29999 | SendBroadcast | train | func (o *Orderer) SendBroadcast(ctx reqContext.Context, envelope *fab.SignedEnvelope) (*common.Status, error) {
conn, err := o.conn(ctx)
if err != nil {
rpcStatus, ok := grpcstatus.FromError(err)
if ok {
return nil, errors.WithMessage(status.NewFromGRPCStatus(rpcStatus), "connection failed")
}
return nil,... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.