Feature: Add snap origin (#428)

Author: Zweih

README.md

@@ -9,4 +9,17 @@ const (
 	OriginPacman  = "pacman"
 	OriginPipx    = "pipx"
 	OriginRpm     = "rpm"
+	OriginSnap    = "snap"
 )
+
+var ValidOrigins = []string{
+	OriginBrew,
+	OriginDeb,
+	OriginFlatpak,
+	OriginNpm,
+	OriginOpkg,
+	OriginPacman,
+	OriginPipx,
+	OriginRpm,
+	OriginSnap,
+}

internal/consts/origins.go

@@ -0,0 +1,21 @@
+package snap
+
+const (
+	snapRoot = "/snap"
+
+	networkUnix         = "unix"
+	snapdSocket         = "/run/snapd.socket"
+	snapLocalHost       = "http://localhost/v2/snaps"
+	connectionLocalHost = "http://localhost/v2/connections"
+
+	typeOs    = "os"
+	typeSnapd = "snapd"
+
+	binDir   = "/var/lib/snapd/snap/bin"
+	snapsDir = "/var/lib/snapd/snaps"
+	dotSnap  = ".snap"
+
+	interfaceContent = "content"
+
+	timestampFormat = "2006-01-02T15:04:05.999999999-07:00"
+)

internal/origins/drivers/snap/constants.go

@@ -0,0 +1,52 @@
+package snap
+
+import (
+	"os"
+	"qp/internal/consts"
+	"qp/internal/origins/shared"
+	"qp/internal/pkgdata"
+	"qp/internal/storage"
+)
+
+type SnapDriver struct{}
+
+func (d *SnapDriver) Name() string {
+	return consts.OriginSnap
+}
+
+func (d *SnapDriver) Detect() bool {
+	entries, err := os.ReadDir(snapRoot)
+	if err != nil {
+		return false
+	}
+
+	hasSnaps := false
+	for _, entry := range entries {
+		if entry.IsDir() {
+			hasSnaps = true
+			break
+		}
+	}
+
+	return hasSnaps
+}
+
+func (d *SnapDriver) Load(cacheRoot string) ([]*pkgdata.PkgInfo, error) {
+	return fetchPackages()
+}
+
+func (d *SnapDriver) ResolveDeps(pkgs []*pkgdata.PkgInfo) ([]*pkgdata.PkgInfo, error) {
+	return pkgdata.ResolveDependencyGraph(pkgs, nil)
+}
+
+func (d *SnapDriver) LoadCache(path string) ([]*pkgdata.PkgInfo, error) {
+	return storage.LoadProtoCache(path)
+}
+
+func (d *SnapDriver) SaveCache(cacheRoot string, pkgs []*pkgdata.PkgInfo) error {
+	return storage.SaveProtoCache(cacheRoot, pkgs)
+}
+
+func (d *SnapDriver) IsCacheStale(cacheMtime int64) (bool, error) {
+	return shared.BfsStale(snapsDir, cacheMtime, 1)
+}

internal/origins/drivers/snap/driver.go

@@ -0,0 +1,70 @@
+package snap
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"qp/internal/pkgdata"
+	"time"
+)
+
+func fetchPackages() ([]*pkgdata.PkgInfo, error) {
+	client := &http.Client{
+		Transport: &http.Transport{
+			DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
+				return net.Dial(networkUnix, snapdSocket)
+			},
+		},
+		Timeout: 5 * time.Second,
+	}
+
+	snapResp, err := fetchSnaps(client)
+	if err != nil {
+		return nil, err
+	}
+
+	connsResp, err := fetchConnections(client)
+	if err != nil {
+		return nil, err
+	}
+
+	deps := parseConnections(connsResp)
+
+	return parseSnaps(snapResp, deps)
+}
+
+func fetchSnaps(client *http.Client) (SnapdResponse, error) {
+	resp, err := client.Get(snapLocalHost)
+	if err != nil {
+		return SnapdResponse{}, fmt.Errorf("failed to connect to snapd: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return SnapdResponse{}, fmt.Errorf("snapd API error: %d", resp.StatusCode)
+	}
+
+	var snapRep SnapdResponse
+	if err := json.NewDecoder(resp.Body).Decode(&snapRep); err != nil {
+		return SnapdResponse{}, fmt.Errorf("failed to parse snapd response: %w", err)
+	}
+
+	return snapRep, nil
+}
+
+func fetchConnections(client *http.Client) (ConnectionsResponse, error) {
+	resp, err := client.Get("http://localhost/v2/connections")
+	if err != nil {
+		return ConnectionsResponse{}, err
+	}
+	defer resp.Body.Close()
+
+	var connsResp ConnectionsResponse
+	if err := json.NewDecoder(resp.Body).Decode(&connsResp); err != nil {
+		return ConnectionsResponse{}, err
+	}
+
+	return connsResp, nil
+}

internal/origins/drivers/snap/fetch.go

@@ -0,0 +1,181 @@
+package snap
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"qp/internal/consts"
+	"qp/internal/pkgdata"
+	"time"
+)
+
+type SnapdResponse struct {
+	Type   string     `json:"type"`
+	Status string     `json:"status"`
+	Result []SnapInfo `json:"result"`
+}
+
+type SnapInfo struct {
+	InstalledSize int64     `json:"installed-size"`
+	Name          string    `json:"name"`
+	Title         string    `json:"title"`
+	Base          string    `json:"base"`
+	Type          string    `json:"type"`
+	Version       string    `json:"version"`
+	Revision      string    `json:"revision"`
+	InstallDate   string    `json:"install-date"`
+	RefreshDate   string    `json:"refresh-date"`
+	Status        string    `json:"status"`
+	License       string    `json:"license"`
+	Summary       string    `json:"summary"`
+	Description   string    `json:"description"`
+	Developer     string    `json:"developer"`
+	Publisher     Publisher `json:"publisher"`
+	Links         Links     `json:"links"`
+}
+
+type Publisher struct {
+	ID          string `json:"id"`
+	Username    string `json:"username"`
+	DisplayName string `json:"display-name"`
+	Validation  string `json:"validation"`
+}
+
+type Links struct {
+	Website []string `json:"website"`
+	Source  []string `json:"source"`
+	Issues  []string `json:"issues"`
+}
+
+type ConnectionsResponse struct {
+	Type   string `json:"type"`
+	Status string `json:"status"`
+	Result Result `json:"result"`
+}
+
+type Result struct {
+	Established []Connection `json:"established"`
+}
+
+type Connection struct {
+	Interface string `json:"interface"`
+	Slot      Slot   `json:"slot"`
+	Plug      Plug   `json:"plug"`
+}
+
+type Slot struct {
+	Snap string `json:"snap"`
+	Slot string `json:"slot"`
+}
+
+type Plug struct {
+	Snap string `json:"snap"`
+	Plug string `json:"plug"`
+}
+
+func parseSnaps(snapResp SnapdResponse, deps map[string][]string) ([]*pkgdata.PkgInfo, error) {
+	pkgs := make([]*pkgdata.PkgInfo, 0, len(snapResp.Result))
+
+	for _, snapInfo := range snapResp.Result {
+		depends := make([]pkgdata.Relation, 0, len(deps[snapInfo.Name]))
+		for _, dep := range deps[snapInfo.Name] {
+			depends = append(depends, pkgdata.Relation{
+				Name:  dep,
+				Depth: 1,
+			})
+		}
+
+		reason := consts.ReasonExplicit
+		if snapInfo.Type != typeOs && snapInfo.Type != typeSnapd {
+			binPath := filepath.Join(binDir, snapInfo.Name)
+			_, err := os.Stat(binPath)
+			if err != nil {
+				reason = consts.ReasonDependency
+			}
+		}
+
+		if snapInfo.Base != "" {
+			depends = append(depends, pkgdata.Relation{
+				Name:  snapInfo.Base,
+				Depth: 1,
+			})
+		}
+
+		var updateTimestamp int64
+		snapFile := fmt.Sprintf("%s_%s%s", snapInfo.Name, snapInfo.Revision, dotSnap)
+		snapPath := filepath.Join(snapsDir, snapFile)
+		fileInfo, err := os.Stat(snapPath)
+		if err == nil {
+			updateTimestamp = fileInfo.ModTime().Unix()
+		}
+
+		pkg := &pkgdata.PkgInfo{
+			UpdateTimestamp:  updateTimestamp,
+			InstallTimestamp: parseTimestamp(snapInfo.InstallDate),
+			Size:             snapInfo.InstalledSize,
+			Name:             snapInfo.Name,
+			Title:            snapInfo.Title,
+			Reason:           reason,
+			Version:          snapInfo.Version,
+			Origin:           consts.OriginSnap,
+			License:          snapInfo.License,
+			Description:      snapInfo.Summary,
+			Author:           snapInfo.Developer,
+			Url:              getUrl(snapInfo.Links),
+			Packager:         snapInfo.Publisher.DisplayName,
+			PkgType:          snapInfo.Type,
+			Validation:       snapInfo.Publisher.Validation,
+			Depends:          depends,
+		}
+
+		pkgs = append(pkgs, pkg)
+	}
+
+	return pkgs, nil
+}
+
+func parseConnections(connsResp ConnectionsResponse) map[string][]string {
+	deps := make(map[string][]string)
+	for _, conn := range connsResp.Result.Established {
+		if conn.Interface == interfaceContent {
+			deps[conn.Plug.Snap] = append(deps[conn.Plug.Snap], conn.Slot.Snap)
+		}
+	}
+
+	return deps
+}
+
+func getUrl(links Links) string {
+	for _, link := range links.Website {
+		return link
+	}
+
+	for _, link := range links.Source {
+		return link
+	}
+
+	for _, link := range links.Issues {
+		return link
+	}
+
+	return ""
+}
+
+func parseTimestamp(timeStr string) int64 {
+	if timeStr == "" {
+		return 0
+	}
+
+	timestamp, err := time.Parse(timestampFormat, timeStr)
+	if err != nil {
+		timestamp, err = time.Parse(time.RFC3339Nano, timeStr)
+
+		if err == nil {
+			return timestamp.Unix()
+		}
+
+		return 0
+	}
+
+	return timestamp.Unix()
+}

internal/origins/drivers/snap/parser.go

@@ -10,6 +10,7 @@ import (
 	"qp/internal/origins/drivers/pacman"
 	"qp/internal/origins/drivers/pipx"
 	"qp/internal/origins/drivers/rpm"
+	"qp/internal/origins/drivers/snap"
 )
 
 var registeredDrivers = []driver.Driver{
@@ -21,6 +22,7 @@ var registeredDrivers = []driver.Driver{
 	&pacman.PacmanDriver{},
 	&pipx.PipxDriver{},
 	&rpm.RpmDriver{},
+	&snap.SnapDriver{},
 }
 
 func AvailableDrivers() []driver.Driver {

internal/origins/registry.go

@@ -12,6 +12,7 @@ type PkgInfo struct {
 	Freeable         int64
 	Footprint        int64
 	Name             string
+	Author           string
 	Title            string
 	Reason           string
 	Version          string

internal/pkgdata/pkginfo.go

@@ -21,7 +21,7 @@ type Relation struct {
 	Version      string
 	ProviderName string
 	Why          string
-	PkgType      string
+	PkgType      string // pkgtype should only be declared when there is a split ecosystem, such as formulae/casks in Brew
 }
 
 func (rel *Relation) Key() string {