Method PakeProtocol.onKeyExchange has 72 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (p *PakeProtocol) onKeyExchange(s network.Stream) {
    defer s.Close()
    defer p.node.ResetOnShutdown(s)()

    log.Infor("Authenticating peer...")

Method TransferProtocol.Transfer has 65 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (t *TransferProtocol) Transfer(ctx context.Context, peerID peer.ID, basePath string) error {
    // Open a new stream to our peer.
    s, err := t.node.NewStream(ctx, peerID, ProtocolTransfer)
    if err != nil {
        return err

Method TransferProtocol.Transfer has 16 return statements (exceeds 4 allowed).

Open

func (t *TransferProtocol) Transfer(ctx context.Context, peerID peer.ID, basePath string) error {
    // Open a new stream to our peer.
    s, err := t.node.NewStream(ctx, peerID, ProtocolTransfer)
    if err != nil {
        return err

Function main has 56 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func main() {
    // ShortCommit version tag
    verTag := fmt.Sprintf("v%s+%s", RawVersion, ShortCommit)

    app := &cli.App{

Method PakeProtocol.StartKeyExchange has 12 return statements (exceeds 4 allowed).

Open

func (p *PakeProtocol) StartKeyExchange(ctx context.Context, peerID peer.ID) ([]byte, error) {
    s, err := p.node.NewStream(ctx, peerID, ProtocolPake)
    if err != nil {
        return nil, err
    }

Method PakeProtocol.StartKeyExchange has 54 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (p *PakeProtocol) StartKeyExchange(ctx context.Context, peerID peer.ID) ([]byte, error) {
    s, err := p.node.NewStream(ctx, peerID, ProtocolPake)
    if err != nil {
        return nil, err
    }

Method PakeProtocol.onKeyExchange has 11 return statements (exceeds 4 allowed).

Open

func (p *PakeProtocol) onKeyExchange(s network.Stream) {
    defer s.Close()
    defer p.node.ResetOnShutdown(s)()

    log.Infor("Authenticating peer...")

Function Action has 7 return statements (exceeds 4 allowed).

Open

func Action(c *cli.Context) error {
    // Read config file and fill context with it.
    c, err := config.FillContext(c)
    if err != nil {
        return err

Method Node.authenticateMessage has 7 return statements (exceeds 4 allowed).

Open

func (n *Node) authenticateMessage(msg p2p.HeaderMessage) (bool, error) {
    // This will be set to true during unit test runs as the
    // generated peers from mocknet won't have proper keys.
    if skipMessageAuth {
        return true, nil

Function TransferStatus has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func TransferStatus(fn string, iteration int, twidth int, p float64, eta time.Duration, bytesPerS int64) string {

Function New has 7 return statements (exceeds 4 allowed).

Open

func New(c *cli.Context, wrds []string, opts ...libp2p.Option) (*Node, error) {
    log.Debugln("Initialising local node...")

    if c.Bool("homebrew") {
        wrds = words.HomebrewList()

Method Node.Send has 7 return statements (exceeds 4 allowed).

Open

func (n *Node) Send(s network.Stream, msg p2p.HeaderMessage) error {
    defer func() {
        if err := s.CloseWrite(); err != nil {
            log.Warningln("Error closing writer part of stream after sending", err)
        }

Method TransferProtocol.onTransfer has 6 return statements (exceeds 4 allowed).

Open

func (t *TransferProtocol) onTransfer(s network.Stream) {
    defer t.th.Done()
    defer t.node.ResetOnShutdown(s)()

    // Get PAKE session key for stream decryption

Method Node.HandlePeer has 6 return statements (exceeds 4 allowed).

Open

func (n *Node) HandlePeer(pi peer.AddrInfo) {
    if n.GetState() != pcpnode.Discovering {
        log.Debugln("Received a peer from the discoverer although we're not discovering")
        return
    }

Method Node.Read has 6 return statements (exceeds 4 allowed).

Open

func (n *Node) Read(s network.Stream, buf p2p.HeaderMessage) error {
    defer s.CloseRead()

    data, err := ioutil.ReadAll(s)
    if err != nil {

Method PushProtocol.SendPushRequest has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

func (p *PushProtocol) SendPushRequest(ctx context.Context, peerID peer.ID, filename string, size int64, isDir bool) (bool, error) {

Method TransferProtocol.Transfer has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (t *TransferProtocol) Transfer(ctx context.Context, peerID peer.ID, basePath string) error {
    // Open a new stream to our peer.
    s, err := t.node.NewStream(ctx, peerID, ProtocolTransfer)
    if err != nil {
        return err

• Read up
  Read up

Function Bytes has 5 return statements (exceeds 4 allowed).

Open

func Bytes(bytes int64) string {
    if bytes >= 1e12 {
        return fmt.Sprintf("%dTB", bytes/1e12)
    } else if bytes >= 1e9 {
        return fmt.Sprintf("%dGB", bytes/1e9)

Method PakeProtocol.ReceiveVerifyProof has 5 return statements (exceeds 4 allowed).

Open

func (p *PakeProtocol) ReceiveVerifyProof(s network.Stream, key []byte) error {
    response, err := p.node.ReadBytes(s)
    if err != nil {
        return err
    }

Method Node.Transfer has 5 return statements (exceeds 4 allowed).

Open

func (n *Node) Transfer(peerID peer.ID) error {
    filename := path.Base(n.filepath)
    size, err := totalSize(n.filepath)
    if err != nil {
        return err