install.go

package main

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"github.com/pelletier/go-toml"
)

type PackageInfo struct {
	Name    string
	Version string
}

func install(pkg string) error {
	repopath := "/usr/bin/arfpkg/temp/packages.toml"

	// Load package list
	pkglist, err := toml.LoadFile(repopath)
	if err != nil {
		return err
	}

	// Check if package exists
	pkgname := pkglist.Get("packages." + pkg)
	if pkgname == nil {
		return fmt.Errorf("package '%s' not found", pkg)
	}

	// Catch error before everything falls apart
	get := func(val string) (string, error) {
		v := pkglist.Get("packages." + pkg + "." + val)
		s, ok := v.(string)
		if !ok {
			return "", fmt.Errorf("invalid or missing field: %s", val)
		}
		return s, nil
	}

	url, err := get("url")
	if err != nil {
		return err
	}
	xzname, err := get("xzname")
	if err != nil {
		return err
	}
	foldername, err := get("foldername")
	if err != nil {
		return err
	}
	version, err := get("version")
	if err != nil {
		return err
	}
	sha, err := get("sha256")
	if err != nil {
		return err
	}

	// Confirm install
	fmt.Printf("Install %s %s? [y/[N]]: ", pkg, version)
	var yn string
	fmt.Scanln(&yn)
	yn = strings.ToLower(strings.TrimSpace(yn))
	if yn != "y" {
		fmt.Println("Aborted.")
		return nil
	}

	// Download package
	fmt.Println("Downloading package...")
	if err := download(xzname, url); err != nil {
		return err
	}
	// Verify SHA256
	fmt.Println("Verifying integrity...")
	if shacalc("/usr/bin/arfpkg/temp/"+xzname) != sha {
		return fmt.Errorf("integrity check failed. Package may be corrupted")
	}

	fmt.Println("Extracting...")
	destDir := filepath.Join("/usr/bin/arfpkg/temp", foldername+version)
	if err := os.MkdirAll(destDir, 0755); err != nil {
		return err
	}
	if err := tarxz(xzname, foldername, version); err != nil {
		return err
	}

	// Load package info
	pkgconfpath := filepath.Join(
		destDir,
		pkg+"-latest",
		pkg+".toml",
	)

	pkgconf, err := toml.LoadFile(pkgconfpath)
	if err != nil {
		return err
	}

	instdir, ok := pkgconf.Get(pkg + ".install-location").(string)
	if !ok {
		return fmt.Errorf("invalid install-location")
	}
	binary, ok := pkgconf.Get(pkg + ".binaries.mainexec").(string)
	if !ok {
		return fmt.Errorf("invalid mainexec")
	}

	fmt.Println("Installing...")
	srcBin := filepath.Join(destDir, pkg+"-latest", binary)
	dstBin := filepath.Join(instdir, pkg)

	if err := os.Rename(srcBin, dstBin); err != nil {
		return err
	}
	if err := os.Chmod(dstBin, 0755); err != nil {
		return err
	}

	// Add package meta
	pkginfo := PackageInfo{
		Name:    pkg,
		Version: version,
	}

	data, err := toml.Marshal(pkginfo)
	if err != nil {
		return err
	}

	if err := os.MkdirAll("/usr/bin/arfpkg/packages", 0755); err != nil {
		return err
	}

	if err := os.WriteFile(
		"/usr/bin/arfpkg/packages/"+pkg+".toml",
		data,
		0644,
	); err != nil {
		return err
	}

	// Clean up
	fmt.Println("Cleaning up...")
	_ = os.RemoveAll(destDir)
	_ = os.Rename(
		"/usr/bin/arfpkg/temp/"+xzname,
		"/usr/bin/arfpkg/package_archive/"+pkg+".tar.xz",
	)

	return nil
}