asteris-llc/converge

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
    }

Similar blocks of code found in 6 locations. Consider refactoring.

Open

        t.Run("swap", func(t *testing.T) {
            t.Parallel()
            u := &Unit{Type: UnitTypeSwap, SwapProperties: &SwapTypeProperties{Result: "success"}}
            actual, err := getFailedReason(u)
            require.NoError(t, err)

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

        t.Run("timer", func(t *testing.T) {
            t.Parallel()
            u := &Unit{Type: UnitTypeTimer, TimerProperties: &TimerTypeProperties{Result: "success"}}
            actual, err := getFailedReason(u)
            require.NoError(t, err)

• Read up
  Read up

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

Open

        m.On("CreateLogicalVolume", mock.Anything, mock.Anything, mock.Anything).Return(nil).Run(func(args mock.Arguments) {
            // Put data about fresh "created" volume to `lvs`, to allow query device path from engine
            m.LvsOutput = map[string]*lowlevel.LogicalVolume{
                "data": &lowlevel.LogicalVolume{
                    Name:       "data",

• Read up
  Read up

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
    }

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

Open

        m.On("CreateLogicalVolume", mock.Anything, mock.Anything, mock.Anything).Return(nil).Run(func(args mock.Arguments) {
            // Put data about fresh "created" volume to `lvs`, to allow query device path from engine
            m.LvsOutput = map[string]*lowlevel.LogicalVolume{
                "data": &lowlevel.LogicalVolume{
                    Name:       "data",

• Read up
  Read up

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
    }

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 {

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
    }

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 {

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

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

Similar blocks of code found in 6 locations. Consider refactoring.

Open

        t.Run("service", func(t *testing.T) {
            t.Parallel()
            u := &Unit{Type: UnitTypeService, ServiceProperties: &ServiceTypeProperties{Result: "success"}}
            actual, err := getFailedReason(u)
            require.NoError(t, err)

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

        t.Run("socket", func(t *testing.T) {
            t.Parallel()
            u := &Unit{Type: UnitTypeSocket, SocketProperties: &SocketTypeProperties{Result: "success"}}
            actual, err := getFailedReason(u)
            require.NoError(t, err)

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

        t.Run("mount", func(t *testing.T) {
            t.Parallel()
            u := &Unit{Type: UnitTypeMount, MountProperties: &MountTypeProperties{Result: "success"}}
            actual, err := getFailedReason(u)
            require.NoError(t, err)

• Read up
  Read up