asteris-llc/converge

View on GitHub

Showing 247 of 572 total issues

Method Preparer.convertDuration has 5 return statements (exceeds 4 allowed).
Open

func (p *Preparer) convertDuration(typ reflect.Type, r Renderer, name string, val interface{}, base int) (reflect.Value, error) {
    if val == nil {
        return reflect.Zero(typ), nil
    }

Severity: Major
Found in resource/preparer.go - About 35 mins to fix

    Function newSliceTypePropertiesFromMap has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.
    Open

    func newSliceTypePropertiesFromMap(m map[string]interface{}) *SliceTypeProperties {
        s := &SliceTypeProperties{}
    
        if val, ok := m["BlockIOAccounting"]; ok {
            s.BlockIOAccounting = val.(bool)
    Severity: Minor
    Found in resource/systemd/unit/systemd_properties.go - About 35 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 pipelineGen.DependencyCheck has 5 return statements (exceeds 4 allowed).
    Open

    func (g *pipelineGen) DependencyCheck(ctx context.Context, taskI interface{}) (interface{}, error) {
        task, ok := taskI.(taskWrapper)
        if !ok {
            return nil, errors.New("input node is not a task wrapper")
        }
    Severity: Major
    Found in plan/pipeline.go - About 35 mins to fix

      Function AssertDiff has 5 return statements (exceeds 4 allowed).
      Open

      func AssertDiff(t *testing.T, diffs map[string]resource.Diff, name, original, current string) bool {
          var ok bool
      
          if ok = assert.NotEmpty(t, diffs); !ok {
              return false
      Severity: Major
      Found in helpers/comparison/diff.go - About 35 mins to fix

        Method resourceFS.Check has 5 return statements (exceeds 4 allowed).
        Open

        func (r *resourceFS) Check(context.Context, resource.Renderer) (resource.TaskStatus, error) {
            status := &resource.Status{}
        
            if err := r.lvm.CheckFilesystemTools(r.mount.Type); err != nil {
                return nil, errors.Wrapf(err, "filesystem prerequisites for %s", r.mount.Type)
        Severity: Major
        Found in resource/lvm/fs/fs.go - About 35 mins to fix

          Function execPipeline has 5 return statements (exceeds 4 allowed).
          Open

          func execPipeline(ctx context.Context, in *graph.Graph, pipelineF MkPipelineF, renderingPlant *render.Factory, notify *graph.Notifier) (*graph.Graph, error) {
              var hasErrors error
          
              out, err := in.Transform(ctx,
                  notify.Transform(func(meta *node.Node, out *graph.Graph) error {
          Severity: Major
          Found in apply/apply.go - About 35 mins to fix

            Function ParseSize has 5 return statements (exceeds 4 allowed).
            Open

            func ParseSize(sizeToParse string) (*LvmSize, error) {
                var err error
                size := &LvmSize{}
                if m := pctRE.FindStringSubmatch(sizeToParse); m != nil {
                    size.Relative = true
            Severity: Major
            Found in resource/lvm/lowlevel/size.go - About 35 mins to fix

              Method resourceVG.Apply has 5 return statements (exceeds 4 allowed).
              Open

              func (r *resourceVG) Apply(context.Context) (status resource.TaskStatus, err error) {
                  if r.exists {
                      for _, d := range r.devicesToAdd {
                          if err := r.lvm.ExtendVolumeGroup(r.name, d); err != nil {
                              return nil, errors.Wrapf(err, "extending volume group")
              Severity: Major
              Found in resource/lvm/vg/vg.go - About 35 mins to fix

                Method Printer.DrawNode has 5 return statements (exceeds 4 allowed).
                Open

                func (p *Printer) DrawNode(g *graph.Graph, id string) (pp.Renderable, error) {
                    type printerNode struct {
                        ID string
                        *resource.HealthStatus
                    }
                Severity: Major
                Found in prettyprinters/health/health.go - About 35 mins to fix

                  Method Keystore.CheckSignature has 5 return statements (exceeds 4 allowed).
                  Open

                  func (ks *Keystore) CheckSignature(signed, signature io.Reader) error {
                      if ks.keyring == nil {
                          keyring, err := loadKeyring(ks)
                          if err != nil {
                              return errors.Wrap(err, "error loading keyring")
                  Severity: Major
                  Found in keystore/keystore.go - About 35 mins to fix

                    Method Graph.IsNibling has 5 return statements (exceeds 4 allowed).
                    Open

                    func (g *Graph) IsNibling(fst, snd string) bool {
                        sndID, sndHasParent := g.GetParentID(snd)
                        if !sndHasParent {
                            return false
                        }
                    Severity: Major
                    Found in graph/graph.go - About 35 mins to fix

                      Function getParentSubgraph has 5 return statements (exceeds 4 allowed).
                      Open

                      func getParentSubgraph(subgraphs SubgraphMap, thisSubgraph SubgraphID, id string) SubgraphID {
                          parent := graph.ParentID(id)
                          if thisSubgraph == SubgraphBottomID {
                              return SubgraphBottomID
                          }
                      Severity: Major
                      Found in prettyprinters/subgraph_printer.go - About 35 mins to fix

                        Method Printer.drawSubgraph has 5 return statements (exceeds 4 allowed).
                        Open

                        func (p Printer) drawSubgraph(g *graph.Graph, id SubgraphID, subgraph Subgraph) (Renderable, error) {
                            subgraphPrinter, spOK := p.pp.(SubgraphPrinter)
                            nodePrinter, npOK := p.pp.(NodePrinter)
                        
                            if !spOK && !npOK {
                        Severity: Major
                        Found in prettyprinters/subgraph_printer.go - About 35 mins to fix

                          Function HTTP has 5 return statements (exceeds 4 allowed).
                          Open

                          func HTTP(ctx context.Context, loc string) ([]byte, error) {
                              var client http.Client
                              req, err := http.NewRequest("GET", loc, nil)
                              if err != nil {
                                  return nil, err
                          Severity: Major
                          Found in fetch/http.go - About 35 mins to fix

                            Method Printer.drawEdges has 5 return statements (exceeds 4 allowed).
                            Open

                            func (p Printer) drawEdges(g *graph.Graph) (Renderable, error) {
                                edgePrinter, epOK := p.pp.(EdgePrinter)
                                edgeSectionPrinter, espOK := p.pp.(EdgeSectionPrinter)
                            
                                if !epOK && !espOK {
                            Severity: Major
                            Found in prettyprinters/prettyprinter.go - About 35 mins to fix

                              Method Printer.DrawEdge has 5 return statements (exceeds 4 allowed).
                              Open

                              func (p *Printer) DrawEdge(g *graph.Graph, id1, id2 string) (pp.Renderable, error) {
                                  var srcVal, destVal interface{}
                              
                                  if src, ok := g.Get(id1); ok {
                                      srcVal = src.Value()
                              Severity: Major
                              Found in prettyprinters/graphviz/graphviz.go - About 35 mins to fix

                                Method pipelineGen.maybeRunFinalCheck has 5 return statements (exceeds 4 allowed).
                                Open

                                func (g *pipelineGen) maybeRunFinalCheck(ctx context.Context, resultI interface{}) (interface{}, error) {
                                    result, ok := resultI.(*Result)
                                    if !ok {
                                        return nil, fmt.Errorf("expected *Result but got %T", resultI)
                                    }
                                Severity: Major
                                Found in apply/pipeline.go - About 35 mins to fix

                                  Function getParams has 5 return statements (exceeds 4 allowed).
                                  Open

                                  func getParams(g *graph.Graph, id string, node *parse.Node) (out []string, err error) {
                                      var nodeStrings []string
                                      nodeStrings, err = node.GetStrings()
                                      if err != nil {
                                          return nil, err
                                  Severity: Major
                                  Found in load/dependencyresolver.go - About 35 mins to fix

                                    Function getXrefs has 5 return statements (exceeds 4 allowed).
                                    Open

                                    func getXrefs(g *graph.Graph, id string, node *parse.Node) (out []string, err error) {
                                        var nodeStrings []string
                                        var calls []string
                                        nodeRefs := make(map[string]struct{})
                                        nodeStrings, err = node.GetStrings()
                                    Severity: Major
                                    Found in load/dependencyresolver.go - About 35 mins to fix

                                      Method Keystore.StoreTrustedKey has 5 return statements (exceeds 4 allowed).
                                      Open

                                      func (ks *Keystore) StoreTrustedKey(pubkeyBytes []byte) (string, error) {
                                          if err := os.MkdirAll(ks.UserPath, 0755); err != nil {
                                              return "", err
                                          }
                                      
                                      
                                      Severity: Major
                                      Found in keystore/keystore.go - About 35 mins to fix
                                        Severity
                                        Category
                                        Status
                                        Source
                                        Language