update: make things work with the new package system

lib/config.go

@@ -0,0 +1,33 @@
+package lib
+
+import (
+	"encoding/json"
+	"os"
+)
+
+type Config struct {
+	Pools []Pool `json:"pools"`
+}
+
+func (c *Config) Load(list *[]Package, file string) error {
+	var (
+		content []byte
+		err     error
+	)
+
+	if content, err = os.ReadFile(file); err != nil {
+		return err
+	}
+
+	if err = json.Unmarshal(content, c); err != nil {
+		return err
+	}
+
+	for _, p := range c.Pools {
+		if err = p.Load(list); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

lib/package.go

@@ -0,0 +1,86 @@
+package lib
+
+import (
+	"fmt"
+	"io"
+	"net/url"
+	"strings"
+
+	"github.com/bigkevmcd/go-configparser"
+)
+
+type Package struct {
+	Name    string   `json:"name"`
+	Pool    *Pool    `json:"-"`
+	Version string   `json:"version"`
+	Depends []string `json:"depends"`
+	Size    string   `json:"size"`
+	Desc    string   `json:"desc"`
+}
+
+func (p *Package) URL() string {
+	if nil == p.Pool {
+		return ""
+	}
+	url, _ := url.JoinPath(p.Pool.Source, "src/branch/"+p.Pool.Branch+"/src", p.Name)
+	return url
+}
+
+func (p *Package) DependsToStr() string {
+	var depends string = ""
+	for _, d := range p.Depends {
+		depends += fmt.Sprintf("%s ", d)
+	}
+	return depends
+}
+
+func (p *Package) Load(r io.Reader) error {
+	var (
+		err     error
+		size    int64
+		depends string = ""
+		section string = "DEFAULT"
+	)
+
+	parser := configparser.New()
+	if err = parser.ParseReader(r); err != nil {
+		return err
+	}
+
+	for _, s := range parser.Sections() {
+		if s == "DEFAULT" {
+			continue
+		}
+		section = s
+		break
+	}
+
+	if section == "DEFAULT" {
+		return fmt.Errorf("DATA does not contain any sections")
+	}
+
+	p.Name = section
+
+	if p.Version, err = parser.Get(section, "version"); err != nil {
+		return err
+	}
+
+	if size, err = parser.GetInt64(section, "size"); err != nil {
+		return err
+	}
+	p.Size = SizeFromBytes(size)
+
+	if p.Desc, err = parser.Get(section, "desc"); err != nil {
+		return err
+	}
+
+	depends, _ = parser.Get(section, "depends")
+
+	if depends == "" {
+		p.Depends = []string{}
+	} else {
+		p.Depends = strings.Split(depends, ",")
+	}
+
+	return nil
+}

lib/pool.go

@@ -0,0 +1,143 @@
+package lib
+
+import (
+	"archive/tar"
+	"bufio"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"os"
+	"path"
+
+	"github.com/bigkevmcd/go-configparser"
+)
+
+type Pool struct {
+	Maintainer string `json:"-"`
+	Pubkey     string `json:"-"`
+	Size       string `json:"-"`
+
+	Display string `json:"display"`
+	Branch  string `json:"branch"`
+	Source  string `json:"source"`
+	Name    string `json:"name"`
+	URL     string `json:"url"`
+	Dir     string `json:"dir"`
+}
+
+func (p *Pool) Load(list *[]Package) error {
+	var err error
+
+	if p.Dir == "" {
+		return fmt.Errorf("pool directory is not specified")
+	}
+
+	if err = p.LoadInfo(); err != nil {
+		return err
+	}
+
+	if err = p.LoadList(list); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (p *Pool) LoadList(list *[]Package) error {
+	var (
+		list_path   string
+		list_file   *os.File
+		gzip_reader io.Reader
+		header      *tar.Header
+		err         error
+	)
+
+	list_path = path.Join(p.Dir, "LIST")
+
+	if list_file, err = os.Open(list_path); err != nil {
+		return err
+	}
+	defer list_file.Close()
+
+	if gzip_reader, err = gzip.NewReader(bufio.NewReader(list_file)); err != nil {
+		return err
+	}
+
+	reader := tar.NewReader(gzip_reader)
+
+	for header, err = reader.Next(); err == nil; header, err = reader.Next() {
+		if header.Typeflag != tar.TypeReg {
+			continue
+		}
+
+		if path.Base(header.Name) != "DATA" {
+			return fmt.Errorf("LIST archive contains an unknown file")
+		}
+
+		var pkg Package
+		pkg.Pool = p
+
+		if err = pkg.Load(reader); err != nil {
+			return err
+		}
+
+		*list = append(*list, pkg)
+	}
+
+	return nil
+}
+
+func (p *Pool) LoadInfo() error {
+	var (
+		info_path string
+		info_file *os.File
+		section   string
+		size      int64
+		err       error
+	)
+
+	info_path = path.Join(p.Dir, "INFO")
+
+	if info_file, err = os.Open(info_path); err != nil {
+		return err
+	}
+
+	parser := configparser.New()
+
+	if err = parser.ParseReader(bufio.NewReader(info_file)); err != nil {
+		return err
+	}
+
+	section = "DEFAULT"
+
+	for _, s := range parser.Sections() {
+		if s == "DEFAULT" {
+			continue
+		}
+		section = s
+		break
+	}
+
+	if section == "DEFAULT" {
+		return fmt.Errorf("DATA does not contain any sections")
+	}
+
+	if p.Name != section {
+		return fmt.Errorf("pool name (\"%s\") doesn't match with \"%s\"", p.Name, section)
+	}
+
+	if p.Maintainer, err = parser.Get(p.Name, "maintainer"); err != nil {
+		return err
+	}
+
+	if size, err = parser.GetInt64(section, "size"); err != nil {
+		return err
+	}
+	p.Size = SizeFromBytes(size)
+
+	if p.Pubkey, err = parser.Get(section, "pubkey"); err != nil {
+		return err
+	}
+
+	return nil
+}

lib/repo.go

@@ -1,163 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"log"
-	"net/url"
-	"os"
-	"strconv"
-	"strings"
-
-	"github.com/bigkevmcd/go-configparser"
-	"github.com/gofiber/fiber/v2"
-)
-
-type Config struct {
-  Repos   []Repo  `json:"repos"`
-}
-
-var Repos []Repo
-type Repo struct {
-  Source  string  `json:"source"`
-  Branch  string  `json:"branch"`
-  Name    string  `json:"name"`
-  URL     string  `json:"url"`
-}
-
-var Packages []Package
-type Package struct {
-  Name  string   `json:"name"`
-  Repo  string   `json:"repo"`
-  Desc  string   `json:"desc"`
-  Size  string   `json:"size"`
-  Deps  []string `json:"depends"`
-  URL   string   `json:"url"`
-  Ver   string   `json:"version"`
-}
-
-func (p Package) StrDeps() string {
-  return ListToStr(p.Deps)
-}
-
-func LoadPackgae(repo *configparser.ConfigParser, s string) (Package, error) {
-  var (
-    pkg Package 
-    err error
-  ) 
-  pkg.Name = s 
-
-  pkg.Ver, err = repo.Get(s, "version")
-  if err != nil {
-    return pkg, err
-  }
-
-  pkg.Desc, err = repo.Get(s, "desc")
-  if err != nil {
-    return pkg, err
-  }
-
-  ssize, err := repo.Get(s, "size")
-  if err != nil {
-    return pkg, err
-  }
-
-  size, err := strconv.Atoi(ssize)
-  if err != nil {
-    return pkg, err
-  }
-  pkg.Size = SizeFromBytes(size)
-
-  deps, err := repo.Get(s, "depends")
-  if err != nil {
-    return pkg, err
-  }
-
-  if deps == "" {
-    pkg.Deps = []string{}
-  }else {
-    pkg.Deps = strings.Split(deps, "\n")
-  }
-
-  return pkg, nil
-}
-
-func GetRepo(r Repo) ([]Package, error){
-  var pkgs []Package
-
-  furl, err := url.JoinPath(r.URL, "list")
-  if err != nil {
-    return pkgs, err
-  }
-
-  agent := fiber.Get(furl)
-  code, body, errs := agent.Bytes()
-  if len(errs) > 0 {
-    return pkgs, errors.New("Request failed")
-  }
-
-  if code != 200 {
-    return pkgs, errors.New("Bad response")
-  }
-
-  list, err := ExtractFile(body, "pkgs")
-  if err != nil {
-    return pkgs, err
-  }
-
-  repo := configparser.New()
-  repo.ParseReader(bytes.NewReader([]byte(list)))
-  
-  for _, s := range repo.Sections() {
-    if s == "DEFAULT" {
-      continue
-    }
-
-    pkg, err := LoadPackgae(repo, s)
-    if err != nil {
-      log.Printf("Error loading %s: %s", s, err)
-      continue
-    }
-
-    pkg.Repo = r.Name
-    pkg.URL, err = url.JoinPath(
-      r.Source, "src/branch/"+r.Branch+"/src",  pkg.Name, "pkg.sh")
-    pkgs = append(pkgs, pkg)
-  }
-  
-  return pkgs, nil
-}
-
-func LoadRepos() {
-  Repos = []Repo{}
-
-  data, err := os.ReadFile("cfg.json")
-  if err != nil {
-    log.Printf("Failed to read the configuration")
-  }
-
-  var cfg Config
-  err = json.Unmarshal(data, &cfg)
-  if err != nil {
-    log.Printf("Failed to parse the configuration: %s", err)
-  }
-
-  Repos = cfg.Repos
-}
-
-func LoadAllPkgs() {
-  LoadRepos()
-  Packages = []Package{}
-
-  for _, r := range Repos {
-    pkgs, err := GetRepo(r)
-    if err != nil {
-      log.Printf("Error loading %s: %s", r.Name, err.Error())
-      continue
-    }
-    Packages = append(Packages, pkgs...)
-  }
-
-  log.Printf("Loaded total %d packages", len(Packages))
-}

lib/util.go

@@ -1,12 +1,7 @@
 package lib
 
 import (
-	"archive/tar"
-	"bytes"
-	"compress/gzip"
-	"errors"
 	"fmt"
-	"io"
 	"strings"
 	"time"
 
@@ -14,99 +9,68 @@ import (
 )
 
 func ListToStr(l []string) string {
-  res := ""
-  for _, e := range l {
-    res += e+" "
-  }
-  return res
+	res := ""
+	for _, e := range l {
+		res += e + " "
+	}
+	return res
 }
 
-func RenderError(c *fiber.Ctx, code int) error{
-  var msg string = "Server Error"
-  c.Status(code)
+func RenderError(c *fiber.Ctx, code int) error {
+	var msg string = "Server Error"
+	c.Status(code)
 
-  switch code {
-  case 404:
-    msg = "Not Found"
-  }
+	switch code {
+	case 404:
+		msg = "Not Found"
+	}
 
-  return c.Render("error", fiber.Map{
-    "msg": msg,
-  })
+	return c.Render("error", fiber.Map{
+		"msg": msg,
+	})
 }
 
-func SizeFromBytes(size int) string {
-  if(size > 1024*1024*1024) {
-    return fmt.Sprintf("%dGB", (size/1024/1024/1024))
-  }else if(size > 1024*1024) {
-    return fmt.Sprintf("%dMB", (size/1024/1024))
-  }else if(size > 1024) { 
-    return fmt.Sprintf("%dKB", (size/1024))
-  }
-  return fmt.Sprintf("%dB", size)
+func SizeFromBytes(size int64) string {
+	if size > 1024*1024*1024 {
+		return fmt.Sprintf("%dGB", (size / 1024 / 1024 / 1024))
+	} else if size > 1024*1024 {
+		return fmt.Sprintf("%dMB", (size / 1024 / 1024))
+	} else if size > 1024 {
+		return fmt.Sprintf("%dKB", (size / 1024))
+	}
+	return fmt.Sprintf("%dB", size)
 }
 
-func ExtractFile(raw []byte, file string) (string, error){
-  stream := bytes.NewReader(raw) 
-  ustream, err := gzip.NewReader(stream)
-  if err != nil {
-    return "", err
-  }
+func TimePassed(t time.Time) string {
+	diff := time.Since(t)
+	res := fmt.Sprintf(
+		"%ds ago",
+		int(diff.Seconds()),
+	)
 
-  reader := tar.NewReader(ustream)
-  var header *tar.Header
-    
-  for header, err = reader.Next(); err == nil; header, err = reader.Next() {
-    if header.Typeflag != tar.TypeReg {
-      return "", errors.New("Found invalid entry in archive")
-    }
+	if diff.Minutes() > 1 {
+		res = fmt.Sprintf(
+			"%dm and %ds ago",
+			int(diff.Minutes()), int(diff.Seconds())-(int(diff.Minutes())*60),
+		)
+	}
 
-    if header.Name != file {
-      continue
-    }
+	if diff.Hours() > 1 {
+		res = fmt.Sprintf("%dh and %dm ago",
+			int(diff.Hours()),
+			int(diff.Minutes())-(int(diff.Hours())*60),
+		)
+	}
 
-    buf := new(strings.Builder)
-    _, err := io.Copy(buf, reader)
-    if err != nil {
-      return "", errors.New("Failed to extract file to memory")
-    }
-
-    return buf.String(), nil
-  }
-
-  return "", errors.New("File not found")
+	return res
 }
 
-func GetTimePassed(t time.Time) string {
-  diff := time.Since(t)
-  res := fmt.Sprintf(
-    "%ds ago", 
-    int(diff.Seconds()),
-  )
+func SanitizeXSS(s string) string {
+	var bad []string = []string{"~", "'", "\"", "/", "<", ">", "?", "=", "#", "(", ")", "{", "}", "*", "!", "`", "[", "]"}
 
-  if diff.Minutes() > 1 { 
-    res = fmt.Sprintf(
-      "%dm and %ds ago", 
-      int(diff.Minutes()), int(diff.Seconds())-(int(diff.Minutes())*60),
-    )
-  }
+	for _, c := range bad {
+		s = strings.ReplaceAll(s, c, "")
+	}
 
-  if diff.Hours() > 1 {
-    res = fmt.Sprintf("%dh and %dm ago", 
-      int(diff.Hours()),
-      int(diff.Minutes())-(int(diff.Hours())*60), 
-    )
-  }
-
-  return res
-}
-
-func CleanString(s string) string{
-  var badchars []string = []string{"~", "'", "\"", "/", "<", ">", "?", "=", "#", "(", ")", "{", "}", "*", "!", "`", "[", "]"}
-
-  for _, c := range badchars {
-    s = strings.ReplaceAll(s, c, "")
-  } 
-
-  return s
+	return s
 }