git/system_setup_tool
1
0
Fork 0
Code Issues Pull requests Projects Releases 8 Packages Wiki Activity Actions

feat(cli): add first implementation for install command

Browse source
This commit is contained in:
Patryk Hegenberg 2025-01-17 16:18:03 +01:00
parent c1e913641e
commit c0be9a6b43
11 changed files with 257 additions and 77 deletions
Download patch file Download diff file Expand all files Collapse all files

9
cargo.go
View file

@ -34,3 +34,12 @@ func (c *CargoManager) InstallPackage(pkg string) error {
cmd := execCommand("cargo", "install", pkg)
return cmd.Run()
}
func (c *CargoManager) RemovePackage(pkg string) error {
cmd := execCommand("cargo", "uninstall", pkg)
return cmd.Run()
}
func (c *CargoManager) SearchPackage(pkg string) []string {
return []string{}
}

83
cmd.go
View file

@ -2,10 +2,7 @@ package main
import (
"fmt"
"log"
"os"
"os/exec"
"strings"
"github.com/spf13/cobra"
"github.com/spf13/viper"
@ -17,24 +14,6 @@ var rootCmd = &cobra.Command{
Run: run,
}
var searchCmd = &cobra.Command{
Use: "search [package_name]",
Short: "Search for a package across package managers (will search in os|flatpak|homebrew)",
Args: cobra.ExactArgs(1),
Run: func(cmd *cobra.Command, args []string) {
packageName := args[0]
managers := []string{"brew", "os", "flatpak"}
for _, manager := range managers {
fmt.Printf("Searching in %s:\n", manager)
results := searchPackage(packageName, manager)
displayResults(results, manager)
fmt.Println()
}
},
}
func init() {
cobra.OnInitialize(initConfig)
rootCmd.PersistentFlags().StringP("config", "c", "", "Path to the configuration file")
@ -52,8 +31,14 @@ func init() {
enableCmd.Flags().Bool("value", true, "Set to true to enable, false to disable")
installCmd.Flags().StringP("manager", "m", "os", "The package manager you want to install a package with. (Options: os|homebrew|pipx|flatpak|cargo)")
removeCmd.Flags().StringP("manager", "m", "os", "The package manager you want to remove a package with. (Options: os|homebrew|pipx|flatpak|cargo)")
searchCmd.Flags().StringP("manager", "m", "", "The package manager you want to search a package with. (Options: os|homebrew|flatpak)")
packageCmd.AddCommand(addCmd, deleteCmd, showCmd, enableCmd)
rootCmd.AddCommand(packageCmd, searchCmd)
rootCmd.AddCommand(packageCmd, searchCmd, installCmd, removeCmd)
}
func initConfig() {
@ -70,57 +55,3 @@ func initConfig() {
os.Exit(1)
}
}
func displayResults(results []string, manager string) {
if len(results) == 0 {
fmt.Printf("No results found in %s\n", manager)
return
}
for _, result := range results {
fmt.Printf("- %s\n", result)
}
}
func searchPackage(packageName, manager string) []string {
switch manager {
case "brew":
cmd := exec.Command("brew", "search", packageName)
packages, err := cmd.Output()
if err != nil {
log.Printf("error fetching %s packages: %v", manager, err)
}
packageList := strings.Split(strings.TrimSpace(string(packages)), "\n")
return packageList
case "os":
opSys, err := getLinuxDistribution()
if err != nil {
log.Printf("Error getting OS information: %v", err)
return []string{}
}
cmdParts := strings.Fields(opSys.SearchCommand)
if len(cmdParts) == 0 {
log.Printf("Invalid search command for OS package manager")
return []string{}
}
cmd := exec.Command(cmdParts[0], append(cmdParts[1:], packageName)...)
packages, err := cmd.Output()
if err != nil {
log.Printf("Error fetching %s packages: %v", manager, err)
return []string{}
}
packageList := strings.Split(strings.TrimSpace(string(packages)), "\n")
return packageList
case "flatpak":
cmd := exec.Command("flatpak", "search", packageName)
packages, err := cmd.Output()
if err != nil {
log.Printf("error fetching %s packages: %v", manager, err)
}
packageList := strings.Split(strings.TrimSpace(string(packages)), "\n")
return packageList
}
return []string{"Beispielpaket 1", "Beispielpaket 2"} // Platzhalter
}

9
flatpak.go
View file

@ -87,3 +87,12 @@ func (f *FlatpakManager) InstallPackage(pkg string) error {
cmd := execCommand("flatpak", "install", "-y", pkg)
return cmd.Run()
}
func (f *FlatpakManager) RemovePackage(pkg string) error {
cmd := execCommand("flatpak", "uninstall", pkg)
return cmd.Run()
}
func (f *FlatpakManager) SearchPackage(pkg string) []string {
return []string{}
}

9
golang.go
View file

@ -34,3 +34,12 @@ func (g *GolangManager) InstallPackage(pkg string) error {
cmd := execCommand("go", "install", pkg+"@latest")
return cmd.Run()
}
func (g *GolangManager) RemovePackage(pkg string) error {
cmd := execCommand("go", "uninstall", pkg)
return cmd.Run()
}
func (g *GolangManager) SearchPackage(pkg string) []string {
return []string{}
}

9
homebrew.go
View file

@ -41,3 +41,12 @@ func (h *HomebrewManager) InstallPackage(pkg string) error {
cmd := execCommand("brew", "install", pkg)
return cmd.Run()
}
func (h *HomebrewManager) RemovePackage(pkg string) error {
cmd := execCommand("brew", "uninstall", pkg)
return cmd.Run()
}
func (h *HomebrewManager) SearchPackage(pkg string) []string {
return []string{}
}

45
install_cmd.go Normal file
View file

@ -0,0 +1,45 @@
package main
import (
"log"
"github.com/spf13/cobra"
)
var installCmd = &cobra.Command{
Use: "install [package_name]",
Short: "Install a package with the specified package manager",
Args: cobra.ExactArgs(1),
Run: func(cmd *cobra.Command, args []string) {
packageName := args[0]
managerName, _ := cmd.Flags().GetString("manager")
var manager PackageManager
switch managerName {
case "os":
opSys, err := getLinuxDistribution()
if err != nil {
log.Printf("error getting OS information: %v", err)
}
sudoPassword, err := getSudoPassword()
if err != nil {
log.Fatal(err)
}
osManager := NewOSManager(opSys, sudoPassword, []string{packageName})
if err := osManager.Install([]string{packageName}); err != nil {
log.Printf("error: %v\n", err)
}
case "homebrew":
manager = &HomebrewManager{}
case "cargo":
manager = &CargoManager{}
case "pipx":
manager = &PipxManager{}
case "flatpak":
manager = &FlatpakManager{}
default:
}
if err := manager.InstallPackage(packageName); err != nil {
log.Printf("error: %v\n", err)
}
},
}

30
osinfo.go
View file

@ -48,13 +48,25 @@ func (o *OSManager) InstallSpecialSoftware() error {
return o.Model.installSpecialSoftware()
}
func (o *OSManager) removePackage(pkg string) error {
fullCmd := fmt.Sprintf("%s %s", o.OS.RemoveCommand, pkg)
command := execCommand("sudo", "-S", "sh", "-c", fullCmd)
command.Stdin = strings.NewReader(o.SudoPassword + "\n")
return command.Run()
}
func (o *OSManager) SearchPackage(pkg string) []string {
return []string{}
}
type OS struct {
ID string
Name string
Version string
PackageManager string
InstallCommand string
SearchCommand string // TODO: has to be implemented
SearchCommand string
RemoveCommand string
}
func parseOsRelease(osRelease string) *OS {
@ -166,6 +178,22 @@ func (os *OS) getSearchCommand() error {
}
}
func (os *OS) getDeleteCommand() error {
switch os.PackageManager {
case "apt":
os.RemoveCommand = "apt remove"
return nil
case "pacman":
os.RemoveCommand = "pacman -R"
return nil
case "dnf":
os.RemoveCommand = "dnf remove"
return nil
default:
return fmt.Errorf("no install command found for package manager: %s", os.ID)
}
}
func installBuildEssentials(os *OS, sudoPassword string) error {
var command string
switch os.PackageManager {

2
packagemanager.go
View file

@ -4,5 +4,7 @@ type PackageManager interface {
Install(packages []string) error
InstallPackage(pkg string) error
InstallManager() error
RemovePackage(pkg string) error
SearchPackage(pkg string) []string
Name() string
}

9
pipx.go
View file

@ -35,3 +35,12 @@ func (p *PipxManager) InstallPackage(pkg string) error {
cmd := execCommand("pipx", "install", pkg)
return cmd.Run()
}
func (p *PipxManager) RemovePackage(pkg string) error {
cmd := execCommand("pipx", "uninstall", pkg)
return cmd.Run()
}
func (p *PipxManager) SearchPackage(pkg string) []string {
return []string{}
}

45
remove_cmd.go Normal file
View file

@ -0,0 +1,45 @@
package main
import (
"log"
"github.com/spf13/cobra"
)
var removeCmd = &cobra.Command{
Use: "remove [package_name]",
Short: "Remove a package with the specified package manager",
Args: cobra.ExactArgs(1),
Run: func(cmd *cobra.Command, args []string) {
packageName := args[0]
managerName, _ := cmd.Flags().GetString("manager")
var manager PackageManager
switch managerName {
case "os":
opSys, err := getLinuxDistribution()
if err != nil {
log.Printf("error getting OS information: %v", err)
}
sudoPassword, err := getSudoPassword()
if err != nil {
log.Fatal(err)
}
osManager := NewOSManager(opSys, sudoPassword, []string{packageName})
if err := osManager.Install([]string{packageName}); err != nil {
log.Printf("error: %v\n", err)
}
case "homebrew":
manager = &HomebrewManager{}
case "cargo":
manager = &CargoManager{}
case "pipx":
manager = &PipxManager{}
case "flatpak":
manager = &FlatpakManager{}
default:
}
if err := manager.RemovePackage(packageName); err != nil {
log.Printf("error: %v\n", err)
}
},
}

84
search_cmd.go Normal file
View file

@ -0,0 +1,84 @@
package main
import (
"fmt"
"log"
"strings"
"github.com/spf13/cobra"
)
var searchCmd = &cobra.Command{
Use: "search [package_name]",
Short: "Search for a package across package managers (will search in os|flatpak|homebrew)",
Args: cobra.ExactArgs(1),
Run: func(cmd *cobra.Command, args []string) {
packageName := args[0]
managerName, _ := cmd.Flags().GetString("manager")
// var manager PackageManager
if managerName == "" {
managers := []string{"brew", "os", "flatpak"}
for _, manager := range managers {
fmt.Printf("Searching in %s:\n", manager)
results := searchPackage(packageName, manager)
displayResults(results, manager)
fmt.Println()
}
}
},
}
func displayResults(results []string, manager string) {
if len(results) == 0 {
fmt.Printf("No results found in %s\n", manager)
return
}
for _, result := range results {
fmt.Printf("- %s\n", result)
}
}
func searchPackage(packageName, manager string) []string {
switch manager {
case "brew":
cmd := execCommand("brew", "search", packageName)
packages, err := cmd.Output()
if err != nil {
log.Printf("error fetching %s packages: %v", manager, err)
}
packageList := strings.Split(strings.TrimSpace(string(packages)), "\n")
return packageList
case "os":
opSys, err := getLinuxDistribution()
if err != nil {
log.Printf("Error getting OS information: %v", err)
return []string{}
}
cmdParts := strings.Fields(opSys.SearchCommand)
if len(cmdParts) == 0 {
log.Printf("Invalid search command for OS package manager")
return []string{}
}
cmd := execCommand(cmdParts[0], append(cmdParts[1:], packageName)...)
packages, err := cmd.Output()
if err != nil {
log.Printf("Error fetching %s packages: %v", manager, err)
return []string{}
}
packageList := strings.Split(strings.TrimSpace(string(packages)), "\n")
return packageList
case "flatpak":
cmd := execCommand("flatpak", "search", packageName)
packages, err := cmd.Output()
if err != nil {
log.Printf("error fetching %s packages: %v", manager, err)
}
packageList := strings.Split(strings.TrimSpace(string(packages)), "\n")
return packageList
}
return []string{}
}