aergoio/aergo

View on GitHub

Showing 1,051 of 1,052 total issues

Avoid deeply nested control flow statements.
Open

                if logger.IsDebugEnabled() {
                    logger.Debug().Msg("stop gathering tx due to size limit")
                }
Severity: Major
Found in consensus/chain/tx.go - About 45 mins to fix

    Method AergoRPCService.GetBlock has 7 return statements (exceeds 4 allowed).
    Open

    func (rpc *AergoRPCService) GetBlock(ctx context.Context, in *types.SingleBytes) (*types.Block, error) {
        if err := rpc.checkAuth(ctx, ReadBlockChain); err != nil {
            return nil, err
        }
        var result interface{}
    Severity: Major
    Found in rpc/grpcserver.go - About 45 mins to fix

      Method getHashRequestHandler.Handle has 7 return statements (exceeds 4 allowed).
      Open

      func (bh *getHashRequestHandler) Handle(msg p2pcommon.Message, msgBody p2pcommon.MessageBody) {
          remotePeer := bh.peer
          data := msgBody.(*types.GetHashesRequest)
          p2putil.DebugLogReceive(bh.logger, bh.protocol, msg.ID().String(), remotePeer, data)
          chainAccessor := bh.actor.GetChainAccessor()
      Severity: Major
      Found in p2p/subproto/blockhash.go - About 45 mins to fix

        Avoid deeply nested control flow statements.
        Open

                            if err != nil {
                                mp.Warn().Err(err).Msg("failed to init whitelist")
                            }
        Severity: Major
        Found in mempool/mempool.go - About 45 mins to fix

          Avoid deeply nested control flow statements.
          Open

                              if err != nil {
                                  mp.Warn().Err(err).Msg("failed to get whitelist")
                              }
          Severity: Major
          Found in mempool/mempool.go - About 45 mins to fix

            Method MemPool.getUnconfirmed has 7 return statements (exceeds 4 allowed).
            Open

            func (mp *MemPool) getUnconfirmed(accounts []types.Address, countOnly bool) []*unconfirmedTxs {
                mp.RLock()
                defer mp.RUnlock()
            
                getTxList := func(acc types.Address) (*txList, *time.Time) {
            Severity: Major
            Found in mempool/mempool.go - About 45 mins to fix

              Method WalDB.ReadAll has 7 return statements (exceeds 4 allowed).
              Open

              func (wal *WalDB) ReadAll(snapshot *raftpb.Snapshot) (id *consensus.RaftIdentity, state *raftpb.HardState, ents []raftpb.Entry, err error) {
                  if id, err = wal.GetIdentity(); err != nil {
                      return nil, state, ents, err
                  }
              
              
              Severity: Major
              Found in consensus/impl/raftv2/waldb.go - About 45 mins to fix

                Method V030ReadWriter.WriteMsg has 7 return statements (exceeds 4 allowed).
                Open

                func (rw *V030ReadWriter) WriteMsg(msg p2pcommon.Message) error {
                    writeN := 0
                    if msg.Length() != uint32(len(msg.Payload())) {
                        return fmt.Errorf("Invalid payload size")
                    }
                Severity: Major
                Found in p2p/v030/v030io.go - About 45 mins to fix

                  Avoid deeply nested control flow statements.
                  Open

                                  } else if err != nil {
                                      logger.Info().Err(err).Msg("failed to produce block")
                                      continue
                                  }
                  Severity: Major
                  Found in consensus/impl/sbp/sbp.go - About 45 mins to fix

                    Avoid deeply nested control flow statements.
                    Open

                                        if i == start {
                                            err = futureErr
                                        }
                    Severity: Major
                    Found in rpc/grpcserver.go - About 45 mins to fix

                      Method BlocksChunkReceiver.handleInWaiting has 7 return statements (exceeds 4 allowed).
                      Open

                      func (br *BlocksChunkReceiver) handleInWaiting(msg p2pcommon.Message, msgBody p2pcommon.MessageBody) {
                          // consuming request id when timeout, no more resp expected (i.e. hasNext == false ) or malformed body.
                          // timeout
                          if br.timeout.Before(time.Now()) {
                              // silently ignore already status job
                      Severity: Major
                      Found in p2p/blkreceiver.go - About 45 mins to fix

                        Avoid deeply nested control flow statements.
                        Open

                                    } else if err != nil {
                                        logger.Debug().Err(err).Int("idx", i).Stringer("hash", types.LogBase58(tx.GetHash())).Msg("skip error tx")
                        
                                        //FIXME handling system error (panic?)
                                        // ex) gas error/nonce error skip, but other system error panic
                        Severity: Major
                        Found in consensus/chain/tx.go - About 45 mins to fix

                          Method raftServer.GetClusterProgress has 7 return statements (exceeds 4 allowed).
                          Open

                          func (rs *raftServer) GetClusterProgress() (*ClusterProgress, error) {
                              getProgressState := func(raftProgress *raftlib.Progress, lastLeaderIndex uint64, nodeID uint64, leadID uint64) MemberProgressState {
                                  isLeader := nodeID == leadID
                          
                                  if !isLeader {
                          Severity: Major
                          Found in consensus/impl/raftv2/raftserver.go - About 45 mins to fix

                            Method BlockFactory.controller has 7 return statements (exceeds 4 allowed).
                            Open

                            func (bf *BlockFactory) controller() {
                                defer shutdownMsg("block factory controller")
                            
                                beginBlock := func(bpi *bpInfo) error {
                                    // This is only for draining an unconsumed message, which means
                            Severity: Major
                            Found in consensus/impl/dpos/blockfactory.go - About 45 mins to fix

                              Method OutboundWireHandshaker.handleOutboundPeer has 7 return statements (exceeds 4 allowed).
                              Open

                              func (h *OutboundWireHandshaker) handleOutboundPeer(ctx context.Context, rwc io.ReadWriteCloser) (*p2pcommon.HandshakeResult, error) {
                                  // send initial hs message
                                  versions := p2pcommon.AttemptingOutboundVersions
                              
                                  hsHeader := p2pcommon.HSHeadReq{Magic: p2pcommon.MAGICMain, Versions: versions}
                              Severity: Major
                              Found in p2p/handshakev2.go - About 45 mins to fix

                                Method Cluster.ChangeMembership has 7 return statements (exceeds 4 allowed).
                                Open

                                func (cl *Cluster) ChangeMembership(req *types.MembershipChange, nowait bool) (*consensus.Member, error) {
                                    var (
                                        proposal *consensus.ConfChangePropose
                                        err      error
                                    )
                                Severity: Major
                                Found in consensus/impl/raftv2/cluster.go - About 45 mins to fix

                                  Avoid deeply nested control flow statements.
                                  Open

                                                      if i == end {
                                                          err = futureErr
                                                      }
                                  Severity: Major
                                  Found in rpc/grpcserver.go - About 45 mins to fix

                                    Avoid deeply nested control flow statements.
                                    Open

                                                            if e.JsonArgs == "true" {
                                                                value = true
                                                            }
                                    Severity: Major
                                    Found in rpc/rpc.go - About 45 mins to fix

                                      Avoid deeply nested control flow statements.
                                      Open

                                                          } else if conf == enterprise.AccountWhite {
                                                              value := false
                                                              if e.JsonArgs == "true" {
                                                                  value = true
                                                              }
                                      Severity: Major
                                      Found in rpc/rpc.go - About 45 mins to fix

                                        Method Web3APIv1.GetVotes has 7 return statements (exceeds 4 allowed).
                                        Open

                                        func (api *Web3APIv1) GetVotes() (handler http.Handler, ok bool) {
                                            values, err := url.ParseQuery(api.request.URL.RawQuery)
                                            if err != nil {
                                                return commonResponseHandler(&types.Empty{}, err), true
                                            }
                                        Severity: Major
                                        Found in rpc/web3/v1.go - About 45 mins to fix
                                          Severity
                                          Category
                                          Status
                                          Source
                                          Language