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

Open

func newExportedField(input interface{}, index int) (*ExportedField, bool) {
    if nil == input {
        return nil, false
    }

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

Method GrapherClient.Graph has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

Open

func (gc *GrapherClient) Graph(ctx context.Context, loc *pb.LoadRequest, opts ...grpc.CallOption) (*graph.Graph, error) {
    stream, err := gc.client.Graph(ctx, loc, opts...)
    if err != nil {
        return nil, errors.Wrap(err, "could not open stream")
    }

• Read up
  Read up

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

Open

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

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

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 {

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

Open

func (r *resourceVG) Check(context.Context, resource.Renderer) (resource.TaskStatus, error) {
    status := &resource.Status{}

    if err := r.lvm.Check(); err != nil {
        return nil, errors.Wrap(err, "lvm.volumegroup")

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

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

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
    }

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

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)

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
    }

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

Open

func (t *Content) Check(context.Context, resource.Renderer) (resource.TaskStatus, error) {
    diffs := make(map[string]resource.Diff)
    contentDiff := resource.TextDiff{Values: [2]string{"", t.Content}}
    stat, err := os.Stat(t.Destination)
    if os.IsNotExist(err) {

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
    }

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

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
    }

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

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

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

Open

func (r *resourceLV) Apply(context.Context) (resource.TaskStatus, error) {
    status := &Status{}
    if _, err := r.checkVG(true); err != nil {
        return nil, err
    }