Merge pull request #1 from mdgspace/phoenix/packages

feat: Generate script to reinstall packages

Author: baync180705

.gitignore

@@ -0,0 +1 @@
+dist/

main.go

@@ -1,47 +1,8 @@
 package main
 
-import (
-	"fmt"
-	"os"
-	"runtime"
-	"strings"
-)
+import "github.com/mdgspace/sysreplicate/system"
 
+// main is the entry point for the program.
 func main() {
-	osType := runtime.GOOS
-	fmt.Println("Detected OS Type:",osType)
-
-	switch(osType){
-	case "darwin":
-		fmt.Println("MacOS is not supported")
-	case "windows":
-		fmt.Println("Windows is not supported")
-	case "linux":
-		distro, base_distro := fetchLinusDistro()
-		if(distro=="unknown" && base_distro=="unknown"){fmt.Println("Failed to fetch the details of your distro")}
-		fmt.Println("Distribution:", distro)
-		fmt.Println("Built On:", base_distro)
-	default:
-		fmt.Println("OS not supported")
-
-	}
+	system.Run()
 }
-
-func fetchLinusDistro() (string, string) {
-	data, err := os.ReadFile("/etc/os-release")
-
-	if (err != nil) {return "unknown", "unknown"}
-	var distro, base_distro string
-
-	lines:= strings.Split(string(data),"\n")
-	for _, line := range lines {
-		if strings.HasPrefix(line, "ID="){
-			distro =strings.Trim(strings.SplitN(line,"=",2)[1],`"`)
-		}
-		if (strings.HasPrefix(line, "ID_LIKE=")){
-			base_distro = strings.Trim(strings.SplitN(line, "=",2)[1],`"`)
-		}
-	}
-
-	return distro, base_distro
-}

system/output/json.go

@@ -0,0 +1,37 @@
+package output
+
+import (
+	"encoding/json"
+)
+
+// BuildSystemJSON creates a well-structured JSON object for the system info and packages.
+func BuildSystemJSON(osType, distro, baseDistro string, packages []string) ([]byte, error) {
+	type ArchPackages struct {
+		Official []string `json:"official_packages"`
+		AUR      []string `json:"aur_packages"`
+	}
+	type SystemInfo struct {
+		OS         string      `json:"os"`
+		Distro     string      `json:"distro"`
+		BaseDistro string      `json:"base_distro"`
+		Packages   interface{} `json:"packages"`
+	}
+	if baseDistro == "arch" {
+		official, aur := SplitArchPackages(packages)
+		archPkgs := ArchPackages{Official: official, AUR: aur}
+		info := SystemInfo{
+			OS:         osType,
+			Distro:     distro,
+			BaseDistro: baseDistro,
+			Packages:   archPkgs,
+		}
+		return json.MarshalIndent(info, "", "  ")
+	}
+	info := SystemInfo{
+		OS:         osType,
+		Distro:     distro,
+		BaseDistro: baseDistro,
+		Packages:   packages,
+	}
+	return json.MarshalIndent(info, "", "  ")
+}

system/output/script.go

@@ -0,0 +1,107 @@
+package output
+
+import (
+	"fmt"
+	"os"
+)
+
+// splitArchPackages splits the combined package list into official and AUR packages for Arch-based distros.
+func SplitArchPackages(packages []string) (official, aur []string) {
+	isAUR := false
+	for _, pkg := range packages {
+		if pkg == "YayPackages" {
+			isAUR = true
+			continue
+		}
+		if isAUR {
+			if pkg != "" {
+				aur = append(aur, pkg)
+			}
+		} else {
+			if pkg != "" {
+				official = append(official, pkg)
+			}
+		}
+	}
+	return
+}
+
+// generateInstallScript creates a shell script to install all packages for the given distro.
+// Returns an error if the script cannot be created or written.
+func GenerateInstallScript(baseDistro string, packages []string, scriptPath string) error {
+	f, err := os.Create(scriptPath)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	_, err = f.WriteString("#!/bin/bash\nset -e\necho 'Starting package installation...'\n")
+	if err != nil {
+		return err
+	}
+
+	var installCmd string
+	switch baseDistro {
+	case "debian":
+		installCmd = "sudo apt-get install -y"
+	case "arch":
+		installCmd = "sudo pacman -S --noconfirm"
+	case "rhel", "fedora":
+		installCmd = "sudo dnf install -y"
+	case "void":
+		installCmd = "sudo xbps-install -y"
+	default:
+		_, _ = f.WriteString("echo 'Unsupported distro for script generation.'\n")
+		return nil
+	}
+
+	if baseDistro == "arch" {
+		official, aur := SplitArchPackages(packages)
+		_, err = f.WriteString("echo 'Installing official packages with pacman...'\n")
+		if err != nil {
+			return err
+		}
+		for _, pkg := range official {
+			if pkg == "" {
+				continue
+			}
+			_, err = f.WriteString(fmt.Sprintf("%s %s || true\n", installCmd, pkg))
+			if err != nil {
+				return err
+			}
+		}
+		_, err = f.WriteString("if ! command -v yay >/dev/null; then\n  echo 'yay not found, installing yay...'\n  sudo pacman -S --noconfirm yay\nfi\n")
+		if err != nil {
+			return err
+		}
+		_, err = f.WriteString("echo 'Installing AUR packages with yay...'\n")
+		if err != nil {
+			return err
+		}
+		for _, pkg := range aur {
+			if pkg == "" {
+				continue
+			}
+			_, err = f.WriteString(fmt.Sprintf("yay -S --noconfirm %s || true\n", pkg))
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	_, err = f.WriteString(fmt.Sprintf("echo 'Installing packages with %s...'\n", installCmd))
+	if err != nil {
+		return err
+	}
+	for _, pkg := range packages {
+		if pkg == "" {
+			continue
+		}
+		_, err = f.WriteString(fmt.Sprintf("%s %s || true\n", installCmd, pkg))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

system/run.go

@@ -0,0 +1,52 @@
+package system
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"runtime"
+	"github.com/mdgspace/sysreplicate/system/output"
+	"github.com/mdgspace/sysreplicate/system/utils"
+)
+
+// Run is the entry point for the system orchestrator.
+func Run() {
+	osType := runtime.GOOS
+	fmt.Println("Detected OS Type:", osType)
+
+	switch osType {
+	case "darwin":
+		fmt.Println("MacOS is not supported")
+	case "windows":
+		fmt.Println("Windows is not supported")
+	case "linux":
+		distro, baseDistro := utils.DetectDistro()
+		if distro == "unknown" && baseDistro == "unknown" {
+			log.Println("Failed to fetch the details of your distro")
+		}
+		fmt.Println("Distribution:", distro)
+		fmt.Println("Built On:", baseDistro)
+		packages := utils.FetchPackages(baseDistro)
+		jsonObj, err := output.BuildSystemJSON(osType, distro, baseDistro, packages)
+		if err != nil {
+			log.Println("Error marshalling JSON:", err)
+		} else {
+			if err := os.MkdirAll(outputSysDir, 0744); err != nil {
+				log.Println("Error creating sys output directory:", err)
+			}
+			if err := os.WriteFile(jsonOutputPath, jsonObj, 0644); err != nil {
+				log.Println("Error writing JSON output:", err)
+			}
+			if err := os.MkdirAll(outputScriptsDir, 0744); err != nil {
+				log.Println("Error creating scripts output directory:", err)
+			}
+			if err := output.GenerateInstallScript(baseDistro, packages, scriptOutputPath); err != nil {
+				log.Println("Error generating install script:", err)
+			} else {
+				fmt.Println("Script generated successfully at:", scriptOutputPath)
+			}
+		}
+	default:
+		fmt.Println("OS not supported")
+	}
+}

system/settings.go

@@ -0,0 +1,8 @@
+package system
+
+const (
+	outputSysDir     = "dist/sys-info"
+	outputScriptsDir = "dist"
+	jsonOutputPath   = outputSysDir + "/package.json"
+	scriptOutputPath = outputScriptsDir + "/setup.sh"
+)

system/utils/detect_distro.go

@@ -0,0 +1,25 @@
+package utils
+
+import (
+	"os"
+	"strings"
+)
+
+// DetectDistro returns the distro and base distro.
+func DetectDistro() (string, string) {
+	data, err := os.ReadFile("/etc/os-release")
+	if err != nil {
+		return "unknown", "unknown"
+	}
+	var distro, baseDistro string
+	lines := strings.Split(string(data), "\n")
+	for _, line := range lines {
+		if strings.HasPrefix(line, "ID=") {
+			distro = strings.Trim(strings.SplitN(line, "=", 2)[1], `"`)
+		}
+		if strings.HasPrefix(line, "ID_LIKE=") {
+			baseDistro = strings.Trim(strings.SplitN(line, "=", 2)[1], `"`)
+		}
+	}
+	return distro, baseDistro
+}

system/utils/fetch_packages.go

@@ -0,0 +1,49 @@
+package utils
+
+import (
+	"log"
+	"os/exec"
+	"strings"
+)
+
+// FetchPackages returns a list of installed packages for the given base distro.
+func FetchPackages(baseDistro string) []string {
+	var cmd *exec.Cmd
+	var cmdYay *exec.Cmd
+	switch baseDistro {
+	case "debian":
+		cmd = exec.Command("dpkg", "--get-selections")
+	case "arch":
+		cmd = exec.Command("pacman", "-Qn")
+		cmdYay = exec.Command("pacman", "-Qm")
+	case "rhel", "fedora":
+		cmd = exec.Command("rpm", "-qa")
+	case "void":
+		cmd = exec.Command("xbps-query", "-l")
+	default:
+		log.Println("Your distro is unsupported, cannot identify package manager!")
+		return []string{"unknown"}
+	}
+
+	if baseDistro != "arch" {
+		output, err := cmd.CombinedOutput()
+		if err != nil {
+			log.Println("Error in retrieving packages:", err)
+		}
+		return strings.Split(strings.TrimSpace(string(output)), "\n")
+	}
+
+	outputPacman, err := cmd.CombinedOutput()
+	outPutYay, errYay := cmdYay.CombinedOutput()
+	if err != nil {
+		log.Println("Error in retrieving Pacman packages:", err)
+	}
+	if errYay != nil {
+		log.Println("Error in retrieving Yay packages:", errYay)
+	}
+	pacmanPackages := strings.Split(strings.TrimSpace(string(outputPacman)), "\n")
+	yayPackages := strings.Split(strings.TrimSpace(string(outPutYay)), "\n")
+	// Mark the split between official and AUR packages
+	yayPackages = append([]string{"YayPackages"}, yayPackages...)
+	return append(pacmanPackages, yayPackages...)
+}