vorteil/vorteil

View on GitHub

Showing 207 of 546 total issues

Function run has 92 lines of code (exceeds 50 allowed). Consider refactoring.
Open

func run(virt virtualizers.Virtualizer, diskpath string, cfg *vcfg.VCFG, name string) error {

    // Gather home directory for firecracker storage path
    home, err := homedir.Dir()
    if err != nil {
Severity: Major
Found in pkg/cli/run.go - About 2 hrs to fix

    Method Provisioner.Provision has 90 lines of code (exceeds 50 allowed). Consider refactoring.
    Open

    func (p *Provisioner) Provision(args *provisioners.ProvisionArgs) error {
    
        authHeader := fmt.Sprintf("Basic %s", base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%s", p.cfg.Username, p.cfg.Password))))
        if args.Description != "" {
            p.log.Warnf(`The 'description' field is ignored by Nutanix provision operation`)
    Severity: Major
    Found in pkg/provisioners/nutanix/nutanix.go - About 2 hrs to fix

      Method Provisioner.Provision has a Cognitive Complexity of 34 (exceeds 20 allowed). Consider refactoring.
      Open

      func (p *Provisioner) Provision(args *provisioners.ProvisionArgs) error {
          var err error
      
          // report that the 'description' flag is ignored if using this provisioner
          if args.Description != "" {
      Severity: Minor
      Found in pkg/provisioners/vcenter/vcenter.go - About 2 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Method StreamOptimizedWriter.flushGrain has 89 lines of code (exceeds 50 allowed). Consider refactoring.
      Open

      func (w *StreamOptimizedWriter) flushGrain() error {
          var err error
          defer func() {
              w.grainNo++
              w.cursor = w.grainNo * GrainSize
      Severity: Major
      Found in pkg/vmdk/stream-optimized.go - About 2 hrs to fix

        Function Backends has 86 lines of code (exceeds 50 allowed). Consider refactoring.
        Open

        func Backends() ([]string, error) {
            var installedVirtualizers []string
            path := os.Getenv("PATH")
            separated := ":"
            if runtime.GOOS == "windows" {
        Severity: Major
        Found in pkg/virtualizers/util.go - About 2 hrs to fix

          Method StreamOptimizedWriter.flushGrain has a Cognitive Complexity of 33 (exceeds 20 allowed). Consider refactoring.
          Open

          func (w *StreamOptimizedWriter) flushGrain() error {
              var err error
              defer func() {
                  w.grainNo++
                  w.cursor = w.grainNo * GrainSize
          Severity: Minor
          Found in pkg/vmdk/stream-optimized.go - About 2 hrs to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Method Virtualizer.Start has a Cognitive Complexity of 33 (exceeds 20 allowed). Consider refactoring.
          Open

          func (v *Virtualizer) Start() error {
              v.logger.Debugf("Starting VM")
              v.command = exec.Command(v.command.Args[0], v.command.Args[1:]...)
              v.command.SysProcAttr = &syscall.SysProcAttr{
                  Setpgid: true,
          Severity: Minor
          Found in pkg/virtualizers/qemu/virtualizer_notwindows.go - About 2 hrs to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Method SparseWriter.writeGrainData has 82 lines of code (exceeds 50 allowed). Consider refactoring.
          Open

          func (w *SparseWriter) writeGrainData() error {
              var err error
          
              firstDataSector := int64(w.hdr.OverHead) * SectorsPerGrain
          
          
          Severity: Major
          Found in pkg/vmdk/sparse.go - About 2 hrs to fix

            Function calculateMinimumSize has a Cognitive Complexity of 32 (exceeds 20 allowed). Consider refactoring.
            Open

            func calculateMinimumSize(ctx context.Context, minDataBlocks, minInodes, minInodesPer64 int64) (int64, error) {
            
                var err error
                var journalBlocks, contentBlocks, groups, groupsPerFlex int64
                var maxOverflowBlocks, inodesPerGroup, groupDescriptors int64
            Severity: Minor
            Found in pkg/ext4/layout.go - About 2 hrs to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function copyImageFileRecursive has a Cognitive Complexity of 32 (exceeds 20 allowed). Consider refactoring.
            Open

            func copyImageFileRecursive(vorteilImage *vdecompiler.IO, ino int, rpath string, destFilePath string) error {
                var f *os.File
                var rdr io.Reader
                var err error
                var entries []*vdecompiler.DirectoryEntry
            Severity: Minor
            Found in pkg/imagetools/cp.go - About 2 hrs to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function calculateMinimumSize has 80 lines of code (exceeds 50 allowed). Consider refactoring.
            Open

            func calculateMinimumSize(ctx context.Context, minDataBlocks, minInodes, minInodesPer64 int64) (int64, error) {
            
                var err error
                var journalBlocks, contentBlocks, groups, groupsPerFlex int64
                var maxOverflowBlocks, inodesPerGroup, groupDescriptors int64
            Severity: Major
            Found in pkg/ext4/layout.go - About 2 hrs to fix

              Method FixedWriter.writeFooter has 78 lines of code (exceeds 50 allowed). Consider refactoring.
              Open

              func (w *FixedWriter) writeFooter() error {
              
                  var err error
                  _, err = w.Seek(0, io.SeekEnd)
                  if err != nil {
              Severity: Major
              Found in pkg/vhd/fixed.go - About 2 hrs to fix

                Method RemoteManager.get has 78 lines of code (exceeds 50 allowed). Consider refactoring.
                Open

                func (mgr *RemoteManager) get(version CalVer) error {
                
                    Logger("Downloading kernel version: %s", version.String())
                
                    kernelName := filenameFromVersion(version)
                Severity: Major
                Found in pkg/vkern/manager-remote.go - About 2 hrs to fix

                  Method Bundle.Reader has 78 lines of code (exceeds 50 allowed). Consider refactoring.
                  Open

                  func (bundle *Bundle) Reader(tags ...string) io.ReadCloser {
                  
                      pr, pw := io.Pipe()
                  
                      go func(pw *io.PipeWriter) {
                  Severity: Major
                  Found in pkg/vkern/bundle.go - About 2 hrs to fix

                    Method SparseWriter.writeGrainData has a Cognitive Complexity of 31 (exceeds 20 allowed). Consider refactoring.
                    Open

                    func (w *SparseWriter) writeGrainData() error {
                        var err error
                    
                        firstDataSector := int64(w.hdr.OverHead) * SectorsPerGrain
                    
                    
                    Severity: Minor
                    Found in pkg/vmdk/sparse.go - About 2 hrs to fix

                    Cognitive Complexity

                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                    A method's cognitive complexity is based on a few simple rules:

                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                    • Code is considered more complex for each "break in the linear flow of the code"
                    • Code is considered more complex when "flow breaking structures are nested"

                    Further reading

                    Function BindPort has a Cognitive Complexity of 31 (exceeds 20 allowed). Consider refactoring.
                    Open

                    func BindPort(netType, protocol, port string) (string, string, error) {
                        var (
                            bind     string
                            netRoute string
                            isBound  bool
                    Severity: Minor
                    Found in pkg/virtualizers/util.go - About 2 hrs to fix

                    Cognitive Complexity

                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                    A method's cognitive complexity is based on a few simple rules:

                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                    • Code is considered more complex for each "break in the linear flow of the code"
                    • Code is considered more complex when "flow breaking structures are nested"

                    Further reading

                    Method fixedStreamWrapper.wrap has 74 lines of code (exceeds 50 allowed). Consider refactoring.
                    Open

                    func (w *fixedStreamWrapper) wrap() error {
                        _, err := io.Copy(w, w.raw)
                        if err != nil {
                            return err
                        }
                    Severity: Minor
                    Found in pkg/vhd/fixed.go - About 1 hr to fix

                      Method ContainerConverter.createVCFG has 73 lines of code (exceeds 50 allowed). Consider refactoring.
                      Open

                      func (cc *ContainerConverter) createVCFG(config v1.Config, targetDir string) error {
                      
                          if _, err := os.Stat(targetDir); err != nil {
                              return fmt.Errorf("directory %s does not exist", targetDir)
                          }
                      Severity: Minor
                      Found in pkg/vconvert/vconvert.go - About 1 hr to fix

                        Method Virtualizer.RemoveEntry has a Cognitive Complexity of 30 (exceeds 20 allowed). Consider refactoring.
                        Open

                        func (v *Virtualizer) RemoveEntry() error {
                            env, err := os.UserHomeDir()
                            if err != nil {
                                return err
                            }
                        Severity: Minor
                        Found in pkg/virtualizers/vmware/virtualizer.go - About 1 hr to fix

                        Cognitive Complexity

                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                        A method's cognitive complexity is based on a few simple rules:

                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                        • Code is considered more complex for each "break in the linear flow of the code"
                        • Code is considered more complex when "flow breaking structures are nested"

                        Further reading

                        Method DynamicWriter.writeRedundantFooter has 71 lines of code (exceeds 50 allowed). Consider refactoring.
                        Open

                        func (w *DynamicWriter) writeRedundantFooter() error {
                            conectix := uint64(0x636F6E6563746978)
                            timestamp := time.Now().Unix() - 946684800 // 2000 offset
                        
                            // CHS crap
                        Severity: Minor
                        Found in pkg/vhd/dynamic.go - About 1 hr to fix
                          Severity
                          Category
                          Status
                          Source
                          Language