werf/trdl

Function updateCmd has 9 return statements (exceeds 4 allowed).

Open

func updateCmd() *cobra.Command {
    var noSelfUpdate bool
    var autoclean bool
    var inBackground bool
    var backgroundStdoutFile string

Function buildReleaseArtifacts has 9 return statements (exceeds 4 allowed).

Open

func buildReleaseArtifacts(ctx context.Context, tarWriter *nio.PipeWriter, gitRepo *git.Repository, fromImage string, runCommands []string, logger hclog.Logger) (error, func() error) {
    cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
    if err != nil {
        return fmt.Errorf("unable to create docker client: %w", err), nil
    }

Function VerifyTagSignatures has 9 return statements (exceeds 4 allowed).

Open

func VerifyTagSignatures(repo *git.Repository, tagName string, trustedPGPPublicKeys []string, requiredNumberOfVerifiedSignatures int, logger hclog.Logger) error {
    tr, err := repo.Tag(tagName)
    if err != nil {
        return fmt.Errorf("unable to get tag: %w", err)
    }

Method Publisher.setRepositoryKeys has 9 return statements (exceeds 4 allowed).

Open

func (publisher *Publisher) setRepositoryKeys(ctx context.Context, storage logical.Storage, repository RepositoryInterface, opts setRepositoryKeysOptions) error {
    entry, err := storage.Get(ctx, storageKeyTufRepositoryKeys)
    if err != nil {
        return fmt.Errorf("error getting storage private keys json entry by the key %q: %w", storageKeyTufRepositoryKeys, err)
    }

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

Open

func getConfiguration(ctx context.Context, storage logical.Storage) (*configuration, error) {
    raw, err := storage.Get(ctx, storageKeyConfiguration)
    if err != nil {
        return nil, err
    }

• Read up
  Read up

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

Open

func getConfiguration(ctx context.Context, storage logical.Storage) (*configuration, error) {
    raw, err := storage.Get(ctx, storageKeyConfiguration)
    if err != nil {
        return nil, err
    }

• Read up
  Read up

Method Publisher.fetchPGPSigningKey has 8 return statements (exceeds 4 allowed).

Open

func (publisher *Publisher) fetchPGPSigningKey(ctx context.Context, storage logical.Storage, initializeKey bool) (*pgp.RSASigningKey, error) {
    entry, err := storage.Get(ctx, storageKeyPGPSigningKey)
    if err != nil {
        return nil, fmt.Errorf("error getting storage pgp signing key json entry by storage key %q: %w", storageKeyPGPSigningKey, err)
    }

Function switchTaskToCompletedInStorage has 8 return statements (exceeds 4 allowed).

Open

func switchTaskToCompletedInStorage(ctx context.Context, storage logical.Storage, status taskStatus, uuid string, opts switchTaskToCompletedInStorageOptions) error {
    // validate new status
    if !isCompletedTaskStatus(status) {
        return fmt.Errorf("runtime error: task in completed state cannot be with status %q", status)
    }

Method Client.DoSelfUpdate has 8 return statements (exceeds 4 allowed).

Open

func (c Client) DoSelfUpdate(autocleanReleases bool) error {
    acquired, lock, err := c.locker.Acquire(selfUpdateLockFilename, lockgate.AcquireOptions{Shared: false, NonBlocking: true})
    if err != nil {
        return fmt.Errorf("unable to acquire lock: %w", err)
    }

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

Open

    {
        rotateAt, err := rotator.GetTargetsRotateAt()
        if err != nil {
            return fmt.Errorf("unable to get targets.json rotation time: %w", err)
        }

• Read up
  Read up

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

Open

    {
        rotateAt, err := rotator.GetRootRotateAt()
        if err != nil {
            return fmt.Errorf("unable to get root.json rotation time: %w", err)
        }

• Read up
  Read up

Function ValidatePublishConfig has 8 return statements (exceeds 4 allowed).

Open

func ValidatePublishConfig(ctx context.Context, publisher publisher.Interface, publisherRepository publisher.RepositoryInterface, config *config.TrdlChannels, logger hclog.Logger) error {
    existingReleases, err := publisher.GetExistingReleases(ctx, publisherRepository)
    if err != nil {
        return fmt.Errorf("error getting existing targets: %w", err)
    }

Function useCmd has 8 return statements (exceeds 4 allowed).

Open

func useCmd() *cobra.Command {
    var noSelfUpdate bool
    var shell string

    cmd := &cobra.Command{

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

Open

    if now.Sub(w.LastProgressAt) > time.Second && durSecs > 0 {
        logboek.Context(w.Context).Default().LogF("[%s] Writer processed durSecs=%d %d bytes, speed %d Mb/min\n", w.LogName, durSecs, w.ProcessedBytes, int(60*(float64(w.ProcessedBytes)/float64(durSecs))/1024.0/1024.0))
        w.LastProgressAt = now
    }

• Read up
  Read up

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

Open

        if now.Sub(r.LastProgressAt) > time.Second && durSecs > 0 {
            logboek.Context(r.Context).Default().LogF("[%s] Reader processed durSecs=%d %d bytes, speed %d Mb/min\n", r.LogName, durSecs, r.ProcessedBytes, int(60*(float64(r.ProcessedBytes)/float64(durSecs))/1024.0/1024.0))
            r.LastProgressAt = now
        }

• Read up
  Read up

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

Open

func binPathCmd() *cobra.Command {
    cmd := &cobra.Command{
        Use:                   "bin-path REPO GROUP [CHANNEL]",
        Short:                 "Get the directory with software binaries",
        DisableFlagsInUseLine: true,

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

Open

func objectSignaturesFromNotes(repo *git.Repository, objectID string) ([]string, error) {
    ref, err := repo.Reference(notesReferenceName, true)
    if err != nil {
        if err == plumbing.ErrReferenceNotFound {
            return nil, nil

Avoid deeply nested control flow statements.

Open

                        if len(artifactsTarStopReadCode) > codeCursor+1 {
                            codeCursor++
                        } else {
                            return nil
                        }

Avoid deeply nested control flow statements.

Open

                        if len(artifactsTarStartReadCode) > codeCursor+1 {
                            codeCursor++

                            startReadCodeSuspectedBytes = append(startReadCodeSuspectedBytes, b)
                        } else {

Method Publisher.StageReleaseTarget has 7 return statements (exceeds 4 allowed).

Open

func (publisher *Publisher) StageReleaseTarget(ctx context.Context, repository RepositoryInterface, releaseName, releaseFilePath string, data io.Reader) error {
    publisher.mu.Lock()
    defer publisher.mu.Unlock()

    pathParts := SplitFilepath(filepath.Clean(releaseFilePath))