asteris-llc/converge

Method Unarchive.evaluateDuplicates has 7 return statements (exceeds 4 allowed).

Open

func (u *Unarchive) evaluateDuplicates() error {
    // determine which directory has fewer items in order to minimize operations
    dirA := u.destDir.Name()
    dirB := u.fetchDir.Name()
    filesA := u.destContents

Avoid deeply nested control flow statements.

Open

                    if err != nil {
                        status.RaiseLevel(resource.StatusFatal)
                        status.Output = append(status.Output, fmt.Sprintf("error modifying group %s", g.Name))
                        return status, errors.Wrap(err, "group modify")
                    }

Avoid deeply nested control flow statements.

Open

                    if err != nil {
                        status.RaiseLevel(resource.StatusFatal)
                        status.Output = append(status.Output, fmt.Sprintf("error adding group %s with gid %s", g.Name, g.GID))
                        return status, errors.Wrap(err, "group add")
                    }

Method User.DiffMod has 7 return statements (exceeds 4 allowed).

Open

func (u *User) DiffMod(status *resource.Status, currUser *user.User) (*ModUserOptions, error) {
    options := new(ModUserOptions)

    // Check for differences between currUser and the desired modifications
    if u.NewUsername != "" {

Avoid deeply nested control flow statements.

Open

                    if err != nil {
                        status.RaiseLevel(resource.StatusFatal)
                        status.Output = append(status.Output, fmt.Sprintf("error modifying group %s with new gid %s", g.Name, g.GID))
                        return status, errors.Wrap(err, "group modify")
                    }

Function simpleCheckSuccess has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func simpleCheckSuccess(t *testing.T, lvm lowlevel.LVM, group string, devs []string, remove bool, forceRemove bool) (resource.TaskStatus, resource.Task) {

Function simpleCheckFailure has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func simpleCheckFailure(t *testing.T, lvm lowlevel.LVM, group string, devs []string, remove bool, forceRemove bool) resource.TaskStatus {

Method ExportExtractor.Visit has 7 return statements (exceeds 4 allowed).

Open

func (e *ExportExtractor) Visit(node ast.Node) (w ast.Visitor) {
    switch n := node.(type) {
    case *ast.File, *ast.TypeSpec, *ast.FieldList:
        return e
    case *ast.StructType:

Function simpleApplyFailure has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func simpleApplyFailure(t *testing.T, lvm lowlevel.LVM, group string, devs []string, remove bool, forceRemove bool) resource.TaskStatus {

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

Open

func isValidHash(hashType, hash string) bool {
    switch hashType {
    case string(HashMD5):
        return len(hash) == 32
    case string(HashSHA1):

• Read up
  Read up

Function simpleApplySuccess has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func simpleApplySuccess(t *testing.T, lvm lowlevel.LVM, group string, devs []string, remove bool, forceRemove bool) resource.TaskStatus {

Method Fetch.applyWithContext has 7 return statements (exceeds 4 allowed).

Open

func (f *Fetch) applyWithContext(context.Context) (resource.TaskStatus, error) {
    var (
        hsh      hash.Hash
        err      error
        status   = resource.NewStatus()

Function getFailedReason has 7 return statements (exceeds 4 allowed).

Open

func getFailedReason(u *Unit) (string, error) {
    err := errors.New("unable to determine cause of failure: no properties available")
    var reason string
    switch u.Type {
    case UnitTypeService:

Method Fetch.DiffFile has 7 return statements (exceeds 4 allowed).

Open

func (f *Fetch) DiffFile(status *resource.Status, hsh hash.Hash) (*resource.Status, error) {
    // the destination should be a file if fetching without an unarchive
    // if unarchiving, the destination should be a directory
    stat, err := os.Stat(f.Destination)
    if err == nil {

Function ResolveDependencies has 7 return statements (exceeds 4 allowed).

Open

func ResolveDependencies(ctx context.Context, g *graph.Graph) (*graph.Graph, error) {
    logger := logging.GetLogger(ctx).WithField("function", "ResolveDependencies")
    logger.Debug("resolving dependencies")

    groupLock := new(sync.Mutex)

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

Open

func isValidHash(hashType, hash string) bool {
    switch hashType {
    case string(HashMD5):
        return len(hash) == 32
    case string(HashSHA1):

• Read up
  Read up

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

Open

func (m *mockClient) CreateNetwork(opts dc.CreateNetworkOptions) (*dc.Network, error) {
    args := m.Called(opts)
    ret := args.Get(0)
    if ret == nil {
        return nil, args.Error(1)

• Read up
  Read up

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

Open

func (m *mockClient) CreateVolume(opts dc.CreateVolumeOptions) (*dc.Volume, error) {
    args := m.Called(opts)
    ret := args.Get(0)
    if ret == nil {
        return nil, args.Error(1)

• Read up
  Read up

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

Open

        assert.True(t, strings.Contains(act[0], exp[1]) || strings.Contains(act[1], exp[1]) || strings.Contains(act[2], exp[1]) || strings.Contains(act[3], exp[1]) || strings.Contains(act[4], exp[1]))

• Read up
  Read up

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

Open

        assert.True(t, strings.Contains(act[0], exp[2]) || strings.Contains(act[1], exp[2]) || strings.Contains(act[2], exp[2]) || strings.Contains(act[3], exp[2]) || strings.Contains(act[4], exp[2]))

• Read up
  Read up