github.com/AlpineAIO/wails/v2@v2.0.0-beta.32.0.20240505041856-1047a8fa5fef/internal/system/packagemanager/packagemanager.go (about)

     1  //go:build linux
     2  // +build linux
     3  
     4  package packagemanager
     5  
     6  import (
     7  	"sort"
     8  	"strings"
     9  
    10  	"github.com/AlpineAIO/wails/v2/internal/shell"
    11  )
    12  
    13  // A list of package manager commands
    14  var pmcommands = []string{
    15  	"eopkg",
    16  	"apt",
    17  	"dnf",
    18  	"pacman",
    19  	"emerge",
    20  	"zypper",
    21  	"nix-env",
    22  }
    23  
    24  // Find will attempt to find the system package manager
    25  func Find(osid string) PackageManager {
    26  
    27  	// Loop over pmcommands
    28  	for _, pmname := range pmcommands {
    29  		if shell.CommandExists(pmname) {
    30  			return newPackageManager(pmname, osid)
    31  		}
    32  	}
    33  	return nil
    34  }
    35  
    36  func newPackageManager(pmname string, osid string) PackageManager {
    37  	switch pmname {
    38  	case "eopkg":
    39  		return NewEopkg(osid)
    40  	case "apt":
    41  		return NewApt(osid)
    42  	case "dnf":
    43  		return NewDnf(osid)
    44  	case "pacman":
    45  		return NewPacman(osid)
    46  	case "emerge":
    47  		return NewEmerge(osid)
    48  	case "zypper":
    49  		return NewZypper(osid)
    50  	case "nix-env":
    51  		return NewNixpkgs(osid)
    52  	}
    53  	return nil
    54  }
    55  
    56  // Dependencies scans the system for required dependencies
    57  // Returns a list of dependencies search for, whether they were found
    58  // and whether they were installed
    59  func Dependencies(p PackageManager) (DependencyList, error) {
    60  
    61  	var dependencies DependencyList
    62  
    63  	for name, packages := range p.Packages() {
    64  		dependency := &Dependency{Name: name}
    65  		for _, pkg := range packages {
    66  			dependency.Optional = pkg.Optional
    67  			dependency.External = !pkg.SystemPackage
    68  			dependency.InstallCommand = p.InstallCommand(pkg)
    69  			packageavailable, err := p.PackageAvailable(pkg)
    70  			if err != nil {
    71  				return nil, err
    72  			}
    73  			if packageavailable {
    74  				dependency.Version = pkg.Version
    75  				dependency.PackageName = pkg.Name
    76  				installed, err := p.PackageInstalled(pkg)
    77  				if err != nil {
    78  					return nil, err
    79  				}
    80  				if installed {
    81  					dependency.Installed = true
    82  					dependency.Version = pkg.Version
    83  					if !pkg.SystemPackage {
    84  						dependency.Version = AppVersion(name)
    85  					}
    86  				} else {
    87  					dependency.InstallCommand = p.InstallCommand(pkg)
    88  				}
    89  				break
    90  			}
    91  		}
    92  		dependencies = append(dependencies, dependency)
    93  	}
    94  
    95  	// Sort dependencies
    96  	sort.Slice(dependencies, func(i, j int) bool {
    97  		return dependencies[i].Name < dependencies[j].Name
    98  	})
    99  
   100  	return dependencies, nil
   101  }
   102  
   103  // AppVersion returns the version for application related to the given package
   104  func AppVersion(name string) string {
   105  
   106  	if name == "gcc" {
   107  		return gccVersion()
   108  	}
   109  
   110  	if name == "pkg-config" {
   111  		return pkgConfigVersion()
   112  	}
   113  
   114  	if name == "npm" {
   115  		return npmVersion()
   116  	}
   117  
   118  	if name == "docker" {
   119  		return dockerVersion()
   120  	}
   121  
   122  	return ""
   123  
   124  }
   125  
   126  func gccVersion() string {
   127  
   128  	var version string
   129  	var err error
   130  
   131  	// Try "-dumpfullversion"
   132  	version, _, err = shell.RunCommand(".", "gcc", "-dumpfullversion")
   133  	if err != nil {
   134  
   135  		// Try -dumpversion
   136  		// We ignore the error as this function is not for testing whether the
   137  		// application exists, only that we can get the version number
   138  		dumpversion, _, err := shell.RunCommand(".", "gcc", "-dumpversion")
   139  		if err == nil {
   140  			version = dumpversion
   141  		}
   142  	}
   143  	return strings.TrimSpace(version)
   144  }
   145  
   146  func pkgConfigVersion() string {
   147  	version, _, _ := shell.RunCommand(".", "pkg-config", "--version")
   148  	return strings.TrimSpace(version)
   149  }
   150  
   151  func npmVersion() string {
   152  	version, _, _ := shell.RunCommand(".", "npm", "--version")
   153  	return strings.TrimSpace(version)
   154  }
   155  
   156  func dockerVersion() string {
   157  	version, _, _ := shell.RunCommand(".", "docker", "--version")
   158  	version = strings.TrimPrefix(version, "Docker version ")
   159  	version = strings.ReplaceAll(version, ", build ", " (")
   160  	version = strings.TrimSpace(version) + ")"
   161  	return version
   162  }