creating database schemas for packets cli, started doing packets cli and

packing nginx

cmd/main.go

@@ -1,154 +0,0 @@
-package main
-
-import (
-	"log"
-	"os"
-	"path"
-	"path/filepath"
-	"runtime"
-	"strings"
-
-	"github.com/go-git/go-git/v6"
-	"github.com/roboogg133/packets/pkg/install"
-	"github.com/roboogg133/packets/pkg/packet.lua.d"
-)
-
-const bipath = "/usr/bin"
-
-func main() {
-
-	log.SetFlags(log.Llongfile)
-
-	switch os.Args[1] {
-	case "install":
-
-		f, err := os.ReadFile(os.Args[2])
-		if err != nil {
-			log.Fatal(err)
-		}
-		options := &packet.Config{
-			BinDir: bipath,
-		}
-		pkg, err := packet.ReadPacket(f, options)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		pkgId := pkg.Name + "@" + pkg.Version
-		if err := os.MkdirAll("_pkgtest/"+pkgId, 0777); err != nil {
-			log.Fatal(err)
-		}
-
-		os.MkdirAll("_pkgtest/"+pkgId+"/src", 0777)
-		os.MkdirAll("_pkgtest/"+pkgId+"/packet", 0777)
-		if pkg.Plataforms != nil {
-			tmp := *pkg.Plataforms
-
-			plataform := tmp[packet.OperationalSystem(runtime.GOOS)]
-
-			for _, v := range *plataform.Sources {
-				src, err := packet.GetSource(v.Url, v.Method, v.Specs, 5)
-				if err != nil {
-					log.Fatal(err)
-				}
-
-				if v.Method == "GET" || v.Method == "POST" {
-					f := src.([]byte)
-
-					if err := os.WriteFile("_pkgtest/"+pkgId+"/"+path.Base(v.Url), f, 0777); err != nil {
-						log.Fatal(err)
-					}
-
-					if err := packet.Dearchive("_pkgtest/"+pkgId+"/"+path.Base(v.Url), "_pkgtest/"+pkgId+"/src"); err != nil {
-						log.Fatal(err)
-					}
-					os.Remove("_pkgtest/" + pkgId + "/" + path.Base(v.Url))
-
-				} else {
-					result, err := packet.GetSource(v.Url, v.Method, v.Specs, -213123)
-					if err != nil {
-						log.Fatal(err)
-					}
-
-					reponame, _ := strings.CutSuffix(path.Base(v.Url), ".git")
-
-					_, err = git.PlainClone("_pkgtest/"+pkgId+"/src/"+reponame, result.(*git.CloneOptions))
-					if err != nil {
-						log.Fatal(err)
-					}
-				}
-
-			}
-		}
-		if pkg.GlobalSources != nil {
-			for _, v := range *pkg.GlobalSources {
-				src, err := packet.GetSource(v.Url, v.Method, v.Specs, 5)
-				if err != nil {
-					log.Fatal(err)
-				}
-
-				if v.Method == "GET" || v.Method == "POST" {
-					f := src.([]byte)
-
-					if err := os.WriteFile("_pkgtest/"+pkgId+"/"+path.Base(v.Url), f, 0777); err != nil {
-						log.Fatal(err)
-					}
-
-					if err := packet.Dearchive("_pkgtest/"+pkgId+"/"+path.Base(v.Url), "_pkgtest/"+pkgId+"/src"); err != nil {
-						log.Fatal(err)
-					}
-					os.Remove("_pkgtest/" + pkgId + "/" + path.Base(v.Url))
-
-				} else {
-					result, err := packet.GetSource(v.Url, v.Method, v.Specs, -213123)
-					if err != nil {
-						log.Fatal(err)
-					}
-
-					reponame, _ := strings.CutSuffix(path.Base(v.Url), ".git")
-
-					_, err = git.PlainClone("_pkgtest/"+pkgId+"/src/"+reponame, result.(*git.CloneOptions))
-					if err != nil {
-						log.Fatal(err)
-					}
-				}
-
-			}
-		}
-
-		packetdir, err := filepath.Abs("_pkgtest/" + pkgId + "/packet")
-		if err != nil {
-			log.Fatal(err)
-		}
-		srcdir, err := filepath.Abs("_pkgtest/" + pkgId + "/src")
-		if err != nil {
-			log.Fatal(err)
-		}
-		rootdir, err := filepath.Abs("_pkgtest/" + pkgId)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		pkg.ExecuteBuild(&packet.Config{
-			BinDir:     bipath,
-			PacketDir:  packetdir,
-			SourcesDir: srcdir,
-			RootDir:    rootdir,
-		})
-
-		pkg.ExecuteInstall(&packet.Config{
-			BinDir:     bipath,
-			PacketDir:  packetdir,
-			SourcesDir: srcdir,
-			RootDir:    rootdir,
-		})
-
-		files, err := install.GetPackageFiles(packetdir)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if err := install.InstallFiles(files, packetdir); err != nil {
-			log.Fatal(err)
-		}
-	}
-}

cmd/packets/config.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+type PacketsConfiguration struct {
+	BinDir string `toml:"BinDir"`
+}
+
+func GetConfiguration() error {
+	configFile := filepath.Join(ConfigurationDir, "config.toml")
+	data, err := os.ReadFile(configFile)
+	if err != nil {
+		return err
+	}
+	var config PacketsConfiguration
+	err = toml.Unmarshal(data, &config)
+	if err != nil {
+		return err
+	}
+
+	Config = &config
+	return nil
+}

cmd/packets/database/database.go

@@ -0,0 +1,91 @@
+package database
+
+import (
+	"database/sql"
+	"time"
+
+	_ "github.com/mattn/go-sqlite3"
+	"github.com/roboogg133/packets/pkg/packet.lua.d"
+)
+
+const (
+	CreateInstructions = `CREATE TABLE installed_packges(
+    name TEXT NOT NULL,
+    id TEXT PRIMARY KEY,
+    version TEXT NOT NULL,
+    serial INTEGER NOT NULL,
+    maintainer TEXT NOT NULL,
+    verified INTEGER NOT NULL DEFAULT 0,
+    description TEXT NOT NULL,
+    upload_time TEXT NOT NULL,
+    installed_time TEXT NOT NULL,
+
+    image BLOB,
+
+    UNIQUE(name, signature),
+    UNIQUE(name, version),
+    UNIQUE(name, serial)
+)
+
+CREATE TABLE package_files(
+    package_id TEXT PRIMARY KEY,
+    filepath TEXT NOT NULL,
+    is_dir INTEGER NOT NULL DEFAULT 0,
+
+    UNIQUE(package_id, filepath)
+)
+
+CREATE TABLE dependencies(
+    package_id TEXT NOT NULL,
+    dependency_name TEXT NOT NULL,
+    constraint TEXT NOT NULL,
+
+    PRIMARY KEY (package_id, dependency_name)
+)
+
+
+CREATE TABLE build_dependencies(
+    package_id TEXT NOT NULL,
+    dependency_name TEXT NOT NULL,
+    constraint TEXT NOT NULL,
+
+    PRIMARY KEY (package_id, dependency_name)
+)
+
+
+CREATE TABLE conflicts(
+    package_id TEXT NOT NULL,
+    dependency_name TEXT NOT NULL,
+    constraint TEXT NOT NULL,
+
+    PRIMARY KEY (package_id, dependency_name)
+)
+
+CREATE TABLE package_flags(
+    package_id TEXT NOT NULL,
+    flag TEXT NOT NULL,
+    name TEXT NOT NULL,
+    path TEXT NOT NULL,
+)
+`
+)
+
+type DatabaseOptions struct {
+	// Add any additional options here
+}
+
+func MarkAsInstalled(pkg packet.PacketLua, db *sql.DB, image *[]byte) error {
+
+	if image != nil {
+		_, err := db.Exec("INSERT INTO installed_packages (name, id, version, installed_time, image) VALUES (?, ?, ?, ?, ?, ?, ?)", pkg.Name, pkg.Name+"@"+pkg.Version, pkg.Version, time.Now().UnixMilli(), image)
+		if err != nil {
+			return err
+		}
+	} else {
+		_, err := db.Exec("INSERT INTO installed_packages (name, id, version, installed_time, image) VALUES (?, ?, ?, ?, ?, ?, ?)", pkg.Name, pkg.Name+"@"+pkg.Version, pkg.Version, time.Now().UnixMilli(), []byte{1})
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

cmd/packets/decompress/main.go

@@ -0,0 +1,152 @@
+package decompress
+
+import (
+	"archive/tar"
+	"archive/zip"
+	"bytes"
+	"compress/bzip2"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/klauspost/compress/zstd"
+	"github.com/pierrec/lz4/v4"
+	"github.com/ulikunitz/xz"
+)
+
+func extractZipFile(file *zip.File, dest string) error {
+	rc, err := file.Open()
+	if err != nil {
+		return err
+	}
+	defer rc.Close()
+
+	path := filepath.Join(dest, file.Name)
+
+	if file.FileInfo().IsDir() {
+		return os.MkdirAll(path, file.Mode())
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+		return err
+	}
+
+	outFile, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode())
+	if err != nil {
+		return err
+	}
+	defer outFile.Close()
+
+	_, err = io.Copy(outFile, rc)
+	return err
+}
+
+func Decompress(data []byte, outputDir, filename string) error {
+
+	var reader io.Reader
+	switch {
+	case strings.HasSuffix(filename, ".gz"):
+		var err error
+		reader, err = gzip.NewReader(bytes.NewReader(data))
+		if err != nil {
+			return err
+		}
+		filename, _ = strings.CutSuffix(filename, ".gz")
+	case strings.HasSuffix(filename, ".xz"):
+		var err error
+		reader, err = xz.NewReader(bytes.NewReader(data))
+		if err != nil {
+			return err
+		}
+		filename, _ = strings.CutSuffix(filename, ".xz")
+	case strings.HasSuffix(filename, ".zst"):
+		var err error
+		reader, err = zstd.NewReader(bytes.NewReader(data))
+		if err != nil {
+			return err
+		}
+		filename, _ = strings.CutSuffix(filename, ".zst")
+	case strings.HasSuffix(filename, ".bz2"):
+		reader = bzip2.NewReader(bytes.NewReader(data))
+		filename, _ = strings.CutSuffix(filename, ".bz2")
+	case strings.HasSuffix(filename, ".lz4"):
+		reader = lz4.NewReader(bytes.NewReader(data))
+		filename, _ = strings.CutSuffix(filename, ".lz4")
+	case strings.HasSuffix(filename, ".zip"):
+		byteReader := bytes.NewReader(data)
+		reader, err := zip.NewReader(byteReader, int64(len(data)))
+		if err != nil {
+			return err
+		}
+		if err := os.MkdirAll(outputDir, 0755); err != nil {
+			return err
+		}
+
+		for _, file := range reader.File {
+			err := extractZipFile(file, outputDir)
+			if err != nil {
+				return fmt.Errorf("error unziping %s: %w", file.Name, err)
+			}
+		}
+		return nil
+	}
+
+	if strings.HasSuffix(filename, ".tar") {
+
+		tarReader := tar.NewReader(reader)
+
+		for {
+			header, err := tarReader.Next()
+			if err == io.EOF {
+				break
+			}
+			if err != nil {
+				return err
+			}
+
+			targetPath := filepath.Join(outputDir, filepath.Clean(header.Name))
+			if !strings.HasPrefix(targetPath, outputDir) {
+				return fmt.Errorf("invalid path: %s", targetPath)
+			}
+
+			switch header.Typeflag {
+			case tar.TypeDir:
+				if err := os.MkdirAll(targetPath, os.FileMode(header.Mode)); err != nil {
+					return err
+				}
+
+			case tar.TypeReg, tar.TypeRegA:
+				if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
+					return err
+				}
+
+				outFile, err := os.OpenFile(targetPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.FileMode(header.Mode))
+				if err != nil {
+					return err
+				}
+				defer outFile.Close()
+
+				if _, err := io.Copy(outFile, tarReader); err != nil {
+					return err
+				}
+
+			case tar.TypeSymlink:
+				if err := os.Symlink(header.Linkname, targetPath); err != nil {
+					return err
+				}
+			case tar.TypeLink:
+				linkPath := filepath.Join(outputDir, header.Linkname)
+				if err := os.Link(linkPath, targetPath); err != nil {
+					return err
+				}
+
+			default:
+				return fmt.Errorf("unknown file type: %c => %s", header.Typeflag, header.Name)
+			}
+		}
+	}
+
+	return nil
+}

cmd/packets/functions.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/go-git/go-git/v6"
+	"github.com/roboogg133/packets/cmd/packets/decompress"
+	"github.com/roboogg133/packets/pkg/packet.lua.d"
+)
+
+func DownloadSource(sources *[]packet.Source, configs *packet.Config) error {
+	for _, source := range *sources {
+		downloaded, err := packet.GetSource(source.Url, source.Method, source.Specs, NumberOfTryAttempts)
+		if err != nil {
+			return fmt.Errorf("error: %s", err.Error())
+		}
+		if source.Method == "GET" || source.Method == "POST" {
+			f := downloaded.([]byte)
+
+			_ = os.MkdirAll(configs.SourcesDir, 0755)
+			if err := decompress.Decompress(f, configs.SourcesDir, path.Base(source.Url)); err != nil {
+				return fmt.Errorf("error: %s", err.Error())
+			}
+		} else {
+			options := downloaded.(*git.CloneOptions)
+			repoName, _ := strings.CutSuffix(filepath.Base(source.Url), ".git")
+			_ = os.MkdirAll(filepath.Join(configs.SourcesDir, repoName), 0755)
+			_, err := git.PlainClone(filepath.Join(configs.SourcesDir, repoName), options)
+			if err != nil {
+				return fmt.Errorf("error: %s", err.Error())
+			}
+			os.RemoveAll(filepath.Join(configs.SourcesDir, repoName, ".git"))
+		}
+
+	}
+	return nil
+}

cmd/packets/main.go

@@ -0,0 +1,107 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/roboogg133/packets/pkg/packet.lua.d"
+	"github.com/spf13/cobra"
+)
+
+var Config *PacketsConfiguration
+
+var rootCmd = &cobra.Command{
+	Use:   "packets",
+	Short: "A tool for managing packets",
+	Long:  "A multiplatform package manager",
+}
+
+var executeCmd = &cobra.Command{
+	Use:   "execute {path}",
+	Short: "Installs a package from a given Packet.lua file",
+	Long:  "Installs a package from a given Packet.lua file",
+	Args:  cobra.MinimumNArgs(1),
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		return GetConfiguration()
+	},
+	Run: func(cmd *cobra.Command, args []string) {
+
+		for _, v := range args {
+			if !strings.HasSuffix(v, ".lua") {
+				fmt.Printf("error: %s need to have .lua suffix\n", v)
+				os.Exit(1)
+			}
+			contentBlob, err := os.ReadFile(v)
+			if err != nil {
+				fmt.Printf("error: %s could not be read\n", v)
+				os.Exit(1)
+			}
+			pkg, err := packet.ReadPacket(contentBlob, &packet.Config{BinDir: Config.BinDir})
+			if err != nil {
+				fmt.Printf("error: %s", err.Error())
+				os.Exit(1)
+			}
+
+			rootdir, err := filepath.Abs(filepath.Join(PackageRootDir, pkg.Name+"@"+pkg.Version))
+			if err != nil {
+				fmt.Printf("error: %s", err.Error())
+				os.Exit(1)
+			}
+			sourcesdir, err := filepath.Abs(filepath.Join(rootdir, "src"))
+			if err != nil {
+				fmt.Printf("error: %s", err.Error())
+				os.Exit(1)
+			}
+			packetsdir, err := filepath.Abs(filepath.Join(rootdir, "packet"))
+			if err != nil {
+				fmt.Printf("error: %s", err.Error())
+				os.Exit(1)
+			}
+			configs := &packet.Config{
+				BinDir:     Config.BinDir,
+				RootDir:    rootdir,
+				SourcesDir: sourcesdir,
+				PacketDir:  packetsdir,
+			}
+
+			_ = os.MkdirAll(configs.RootDir, 0755)
+			_ = os.MkdirAll(configs.SourcesDir, 0755)
+			_ = os.MkdirAll(configs.PacketDir, 0755)
+
+			if err := DownloadSource(pkg.GlobalSources, configs); err != nil {
+				fmt.Printf("error: %s", err.Error())
+				os.Exit(1)
+			}
+
+			if pkg.Plataforms != nil {
+
+				temp := *pkg.Plataforms
+
+				if plataform, exists := temp[packet.OperationalSystem(runtime.GOOS)]; exists {
+					if err := DownloadSource(plataform.Sources, configs); err != nil {
+						fmt.Printf("error: %s", err.Error())
+						os.Exit(1)
+					}
+				}
+			}
+			backupDir, err := filepath.Abs(".")
+			if err != nil {
+				fmt.Printf("error: %s", err.Error())
+				os.Exit(1)
+			}
+
+			pkg.ExecuteBuild(configs)
+			pkg.ExecuteInstall(configs)
+			os.Chdir(backupDir)
+
+		}
+	},
+}
+
+func main() {
+	rootCmd.AddCommand(executeCmd)
+	rootCmd.Execute()
+}

cmd/packets/specifications.go

@@ -0,0 +1,10 @@
+package main
+
+const (
+	ConfigurationDir       = "/etc/packets"
+	HomeDir                = "/var/lib/packets"
+	PackageRootDir         = "_pkgtest"
+	NumberOfTryAttempts    = 4
+	UserHomeDirPlaceholder = "{{ USER HOME FOLDER }}"
+	UsernamePlaceholder    = "{{ USERNAME }}"
+)