asteris-llc/converge

View on GitHub

Showing 247 of 572 total issues

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

func (p pipelineGen) prepareNode(ctx context.Context, idi interface{}) (interface{}, error) {
    var metadataErr error

    res, ok := idi.(resource.Resource)
    if !ok {
Severity: Major
Found in render/render.go - About 35 mins to fix

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

    func (g *pipelineGen) GetTask(ctx context.Context, idi interface{}) (interface{}, error) {
        if thunk, ok := idi.(*render.PrepareThunk); ok {
            thunked, err := thunk.Thunk(g.RenderingPlant)
            if err != nil {
                return nil, err
    Severity: Major
    Found in plan/pipeline.go - About 35 mins to fix

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

      func (p *Preparer) convertMap(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 ResolveTask has 5 return statements (exceeds 4 allowed).
        Open

        func ResolveTask(w interface{}) (Task, bool) {
            if w == nil {
                return nil, false
            }
            if tasker, ok := w.(Tasker); ok {
        Severity: Major
        Found in resource/resource.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

            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 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 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

                    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 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 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 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

                            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

                              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 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 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

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

                                    func RenderPredicate(meta *node.Node, renderFunc func(string, string) (string, error)) (string, error) {
                                        rendered, ok := meta.LookupMetadata(MetaRenderedPredicate)
                                        if ok {
                                            return rendered.(string), nil
                                        }
                                    Severity: Major
                                    Found in graph/node/conditional/conditional.go - About 35 mins to fix

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

                                      func (g *pipelineGen) DependencyCheck(ctx context.Context, taskI interface{}) (interface{}, error) {
                                          result, ok := taskI.(resultWrapper)
                                          if !ok {
                                              return nil, errors.New("input node is not a task wrapper")
                                          }
                                      Severity: Major
                                      Found in apply/pipeline.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
                                          Severity
                                          Category
                                          Status
                                          Source
                                          Language