Sign upLogin

ipfs/ipfs-cluster

View on GitHub
Star

Showing 105 of 124 total issues

Method API.listPins has 91 lines of code (exceeds 80 allowed). Consider refactoring.
Open

func (api *API) listPins(w http.ResponseWriter, r *http.Request) {
    opts := &pinsvc.ListOptions{}
    err := opts.FromQuery(r.URL.Query())
    if err != nil {
        api.SendResponse(w, common.SetStatusAutomatically, err, nil)
Severity: Major
Found in api/pinsvcapi/pinsvcapi.go - About 1 hr to fix

    Function partitionMetrics has a Cognitive Complexity of 22 (exceeds 15 allowed). Consider refactoring.
    Open

    func partitionMetrics(set api.MetricsSet, by []string) *partitionedMetric {
    rootMetric := by[0]
    pnedMetric := &partitionedMetric{
        metricName: rootMetric,
        partitions: partitionValues(set[rootMetric]),
    Severity: Minor
    Found in allocator/balanced/balanced.go - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Open

    func (cfg *Config) toJSONConfig() *jsonConfig {
    jCfg := &jsonConfig{}

    if cfg.Folder != DefaultSubFolder {
        jCfg.Folder = cfg.Folder
    Severity: Major
    Found in datastore/badger3/config.go and 1 other location - About 1 hr to fix
    datastore/badger/config.go on lines 257..273

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 155.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Open

    func (cfg *Config) toJSONConfig() *jsonConfig {
    jCfg := &jsonConfig{}

    if cfg.Folder != DefaultSubFolder {
        jCfg.Folder = cfg.Folder
    Severity: Major
    Found in datastore/badger/config.go and 1 other location - About 1 hr to fix
    datastore/badger3/config.go on lines 330..346

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 155.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Function NewCluster has 13 arguments (exceeds 6 allowed). Consider refactoring.
    Open

        ctx context.Context,
    host host.Host,
    dht *dual.DHT,
    cfg *Config,
    datastore ds.Datastore,
    Severity: Major
    Found in cluster.go - About 1 hr to fix

      Function runCmd has 20 return statements (exceeds 10 allowed).
      Open

      func runCmd(c *cli.Context) error {
    clusterName := c.String(clusterNameFlag)

    if cfgURL := c.String("init"); cfgURL != "" {
        err := initCluster(c, true, cfgURL)
      Severity: Major
      Found in cmd/ipfs-cluster-follow/commands.go - About 1 hr to fix

        Method dotWriter.print has 87 lines of code (exceeds 80 allowed). Consider refactoring.
        Open

        func (dW *dotWriter) print() error {
    dW.dotGraph.AddComment("The nodes of the connectivity graph")
    dW.dotGraph.AddComment("The cluster-service peers")
    // Write cluster nodes, use sorted order for consistent labels
    sGraphCluster := dot.NewGraph("")
        Severity: Major
        Found in cmd/ipfs-cluster-ctl/graph.go - About 1 hr to fix

          Method PinOptions.Equals has a Cognitive Complexity of 21 (exceeds 15 allowed). Consider refactoring.
          Open

          func (po PinOptions) Equals(po2 PinOptions) bool {
    if po.Name != po2.Name {
        return false
    }
          Severity: Minor
          Found in api/types.go - About 1 hr to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Method Cluster.globalPinInfoCid has a Cognitive Complexity of 21 (exceeds 15 allowed). Consider refactoring.
          Open

          func (c *Cluster) globalPinInfoCid(ctx context.Context, comp, method string, h api.Cid) (api.GlobalPinInfo, error) {
    ctx, span := trace.StartSpan(ctx, "cluster/globalPinInfoCid")
    defer span.End()

    // The object we will return
          Severity: Minor
          Found in cluster.go - About 1 hr to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Method Connector.PinLs has a Cognitive Complexity of 20 (exceeds 15 allowed). Consider refactoring.
          Open

          func (ipfs *Connector) PinLs(ctx context.Context, typeFilters []string, out chan<- api.IPFSPinInfo) error {
    defer close(out)
    bodies := make([]io.ReadCloser, len(typeFilters))

    ctx, span := trace.StartSpan(ctx, "ipfsconn/ipfshttp/PinLs")
          Severity: Minor
          Found in ipfsconn/ipfshttp/ipfshttp.go - About 1 hr to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function RandomizePorts has a Cognitive Complexity of 20 (exceeds 15 allowed). Consider refactoring.
          Open

          func RandomizePorts(addrs []ma.Multiaddr) ([]ma.Multiaddr, error) {
    results := make([]ma.Multiaddr, 0, len(addrs))

    for _, m := range addrs {
        var prev string
          Severity: Minor
          Found in cmdutils/cmdutils.go - About 1 hr to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function main has 16 return statements (exceeds 10 allowed).
          Open

          func main() {
    app := cli.NewApp()
    app.Name = programName
    app.Usage = "IPFS Cluster peer"
    app.Description = Description
          Severity: Major
          Found in cmd/ipfs-cluster-service/main.go - About 1 hr to fix

            Method API.allocationsHandler has a Cognitive Complexity of 19 (exceeds 15 allowed). Consider refactoring.
            Open

            func (api *API) allocationsHandler(w http.ResponseWriter, r *http.Request) {
    queryValues := r.URL.Query()
    filterStr := queryValues.Get("filter")
    var filter types.PinType
    for _, f := range strings.Split(filterStr, ",") {
            Severity: Minor
            Found in api/rest/restapi.go - About 55 mins to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Method Cluster.Join has a Cognitive Complexity of 19 (exceeds 15 allowed). Consider refactoring.
            Open

            func (c *Cluster) Join(ctx context.Context, addr ma.Multiaddr) error {
    ctx, span := trace.StartSpan(ctx, "cluster/Join")
    defer span.End()

    logger.Debugf("Join(%s)", addr)
            Severity: Minor
            Found in cluster.go - About 55 mins to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Avoid deeply nested control flow statements.
            Open

                                if !decodeWarningPrinted {
                        logger.Warning("Peers in versions <= v0.13.3 detected. These peers will not receive metrics from this or other newer peers. Please upgrade them.")
                        decodeWarningPrinted = true
                    }
            Severity: Major
            Found in monitor/pubsubmon/pubsubmon.go - About 45 mins to fix

              Method carAdder.Add has a Cognitive Complexity of 18 (exceeds 15 allowed). Consider refactoring.
              Open

              func (ca *carAdder) Add(name string, fn files.Node) (api.Cid, error) {
    if ca.params.Wrap {
        return api.CidUndef, errors.New("cannot wrap a CAR file upload")
    }
              Severity: Minor
              Found in adder/adder.go - About 45 mins to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Avoid deeply nested control flow statements.
              Open

                                  if err != nil {
                        logger.Error(err)
                        continue
                    }
              Severity: Major
              Found in monitor/pubsubmon/pubsubmon.go - About 45 mins to fix

                Function createCluster has 8 arguments (exceeds 6 allowed). Consider refactoring.
                Open

                    ctx context.Context,
    c *cli.Context,
    cfgHelper *cmdutils.ConfigHelper,
    host host.Host,
    pubsub *pubsub.PubSub,
                Severity: Major
                Found in cmd/ipfs-cluster-service/daemon.go - About 45 mins to fix

                  Method Cluster.watchPeers has a Cognitive Complexity of 18 (exceeds 15 allowed). Consider refactoring.
                  Open

                  func (c *Cluster) watchPeers() {
    ticker := time.NewTicker(c.config.PeerWatchInterval)
    defer ticker.Stop()

    for {
                  Severity: Minor
                  Found in cluster.go - About 45 mins to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

                  Method raftWrapper.WaitForPeer has a Cognitive Complexity of 18 (exceeds 15 allowed). Consider refactoring.
                  Open

                  func (rw *raftWrapper) WaitForPeer(ctx context.Context, pid string, depart bool) error {
    ctx, span := trace.StartSpan(ctx, "consensus/raft/WaitForPeer")
    defer span.End()

    for {
                  Severity: Minor
                  Found in consensus/raft/raft.go - About 45 mins to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

                  Severity
                  Category
                  Status
                  Source
                  Language