Plemya-x/ALR
Plemya-x/ALR
1
1
Fork 2
Code Issues 4 Pull Requests Actions Packages Projects 1 Releases 4 Wiki Activity

Merge branch 'master' into chore/linting

Browse Source
This commit is contained in:
Maxim Slipenko 2025-01-18 19:22:18 +03:00
commit d46414a67c
27 changed files with 927 additions and 564 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -21,7 +21,7 @@ ALR написан на чистом Go и после сборки не имее
curl -fsSL plemya-x.ru/alr/install.sh | bash curl -fsSL plemya-x.ru/alr/install.sh | bash
``` ```
**ВАЖНО**: При этом скрипт будет загружен и запущен с <https://gitea.plemya-x.ru/xpamych/ALR/install>. Пожалуйста, просматривайте любые скрипты, которые вы скачиваете из Интернета (включая этот), прежде чем запускать их. **ВАЖНО**: При этом скрипт будет загружен и запущен с <https://gitea.plemya-x.ru/Plemya-x/ALR/src/branch/master/scripts/install.sh>. Пожалуйста, просматривайте любые скрипты, которые вы скачиваете из Интернета (включая этот), прежде чем запускать их.
### Сборка из исходного кода ### Сборка из исходного кода

134
internal/config/config.go
View File

@ -21,6 +21,7 @@ package config
import ( import (
"context" "context"
"os" "os"
"path/filepath"
"sync" "sync"
"github.com/pelletier/go-toml/v2" "github.com/pelletier/go-toml/v2"
@ -28,6 +29,14 @@ import (
"plemya-x.ru/alr/pkg/loggerctx" "plemya-x.ru/alr/pkg/loggerctx"
) )
type ALRConfig struct {
cfg *types.Config
paths *Paths
cfgOnce sync.Once
pathsOnce sync.Once
}
var defaultConfig = &types.Config{ var defaultConfig = &types.Config{
RootCmd: "sudo", RootCmd: "sudo",
PagerStyle: "native", PagerStyle: "native",
@ -40,40 +49,107 @@ var defaultConfig = &types.Config{
}, },
} }
var ( func New() *ALRConfig {
configMtx sync.Mutex return &ALRConfig{}
config *types.Config }
)
// Config returns a ALR configuration struct. func (c *ALRConfig) Load(ctx context.Context) {
// The first time it's called, it'll load the config from a file.
// Subsequent calls will just return the same value.
func Config(ctx context.Context) *types.Config {
configMtx.Lock()
defer configMtx.Unlock()
log := loggerctx.From(ctx) log := loggerctx.From(ctx)
cfgFl, err := os.Open(c.GetPaths(ctx).ConfigPath)
if err != nil {
log.Warn("Error opening config file, using defaults").Err(err).Send()
c.cfg = defaultConfig
return
}
defer cfgFl.Close()
if config == nil { // Copy the default configuration into config
cfgFl, err := os.Open(GetPaths(ctx).ConfigPath) defCopy := *defaultConfig
if err != nil { config := &defCopy
log.Warn("Error opening config file, using defaults").Err(err).Send() config.Repos = nil
return defaultConfig
}
defer cfgFl.Close()
// Copy the default configuration into config err = toml.NewDecoder(cfgFl).Decode(config)
defCopy := *defaultConfig if err != nil {
config = &defCopy log.Warn("Error decoding config file, using defaults").Err(err).Send()
config.Repos = nil c.cfg = defaultConfig
return
}
c.cfg = config
}
err = toml.NewDecoder(cfgFl).Decode(config) func (c *ALRConfig) initPaths(ctx context.Context) {
if err != nil { log := loggerctx.From(ctx)
log.Warn("Error decoding config file, using defaults").Err(err).Send() paths := &Paths{}
// Set config back to nil so that we try again next time
config = nil cfgDir, err := os.UserConfigDir()
return defaultConfig if err != nil {
} log.Fatal("Unable to detect user config directory").Err(err).Send()
} }
return config paths.ConfigDir = filepath.Join(cfgDir, "alr")
err = os.MkdirAll(paths.ConfigDir, 0o755)
if err != nil {
log.Fatal("Unable to create ALR config directory").Err(err).Send()
}
paths.ConfigPath = filepath.Join(paths.ConfigDir, "alr.toml")
if _, err := os.Stat(paths.ConfigPath); err != nil {
cfgFl, err := os.Create(paths.ConfigPath)
if err != nil {
log.Fatal("Unable to create ALR config file").Err(err).Send()
}
err = toml.NewEncoder(cfgFl).Encode(&defaultConfig)
if err != nil {
log.Fatal("Error encoding default configuration").Err(err).Send()
}
cfgFl.Close()
}
cacheDir, err := os.UserCacheDir()
if err != nil {
log.Fatal("Unable to detect cache directory").Err(err).Send()
}
paths.CacheDir = filepath.Join(cacheDir, "alr")
paths.RepoDir = filepath.Join(paths.CacheDir, "repo")
paths.PkgsDir = filepath.Join(paths.CacheDir, "pkgs")
err = os.MkdirAll(paths.RepoDir, 0o755)
if err != nil {
log.Fatal("Unable to create repo cache directory").Err(err).Send()
}
err = os.MkdirAll(paths.PkgsDir, 0o755)
if err != nil {
log.Fatal("Unable to create package cache directory").Err(err).Send()
}
paths.DBPath = filepath.Join(paths.CacheDir, "db")
c.paths = paths
}
func (c *ALRConfig) GetPaths(ctx context.Context) *Paths {
c.pathsOnce.Do(func() {
c.initPaths(ctx)
})
return c.paths
}
func (c *ALRConfig) Repos(ctx context.Context) []types.Repo {
c.cfgOnce.Do(func() {
c.Load(ctx)
})
return c.cfg.Repos
}
func (c *ALRConfig) IgnorePkgUpdates(ctx context.Context) []string {
c.cfgOnce.Do(func() {
c.Load(ctx)
})
return c.cfg.IgnorePkgUpdates
} }

54
internal/config/config_legacy.go Normal file
View File

@ -0,0 +1,54 @@
/*
* ALR - Any Linux Repository
* Copyright (C) 2024 Евгений Храмов
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package config
import (
"context"
"sync"
"plemya-x.ru/alr/internal/types"
)
// Config returns a ALR configuration struct.
// The first time it's called, it'll load the config from a file.
// Subsequent calls will just return the same value.
//
// Deprecated: use struct method
func Config(ctx context.Context) *types.Config {
return GetInstance(ctx).cfg
}
// =======================
// FOR LEGACY ONLY
// =======================
var (
alrConfig *ALRConfig
alrConfigOnce sync.Once
)
// Deprecated: For legacy only
func GetInstance(ctx context.Context) *ALRConfig {
alrConfigOnce.Do(func() {
alrConfig = New()
alrConfig.Load(ctx)
})
return alrConfig
}

72
internal/config/paths.go
View File

@ -20,12 +20,6 @@ package config
import ( import (
"context" "context"
"os"
"path/filepath"
"sync"
"github.com/pelletier/go-toml/v2"
"plemya-x.ru/alr/pkg/loggerctx"
) )
// Paths contains various paths used by ALR // Paths contains various paths used by ALR
@ -38,71 +32,13 @@ type Paths struct {
DBPath string DBPath string
} }
var (
pathsMtx sync.Mutex
paths *Paths
)
// GetPaths returns a Paths struct. // GetPaths returns a Paths struct.
// The first time it's called, it'll generate the struct // The first time it's called, it'll generate the struct
// using information from the system. // using information from the system.
// Subsequent calls will return the same value. // Subsequent calls will return the same value.
//
// Depreacted: use struct API
func GetPaths(ctx context.Context) *Paths { func GetPaths(ctx context.Context) *Paths {
pathsMtx.Lock() alrConfig := GetInstance(ctx)
defer pathsMtx.Unlock() return alrConfig.GetPaths(ctx)
log := loggerctx.From(ctx)
if paths == nil {
paths = &Paths{}
cfgDir, err := os.UserConfigDir()
if err != nil {
log.Fatal("Unable to detect user config directory").Err(err).Send()
}
paths.ConfigDir = filepath.Join(cfgDir, "alr")
err = os.MkdirAll(paths.ConfigDir, 0o755)
if err != nil {
log.Fatal("Unable to create ALR config directory").Err(err).Send()
}
paths.ConfigPath = filepath.Join(paths.ConfigDir, "alr.toml")
if _, err := os.Stat(paths.ConfigPath); err != nil {
cfgFl, err := os.Create(paths.ConfigPath)
if err != nil {
log.Fatal("Unable to create ALR config file").Err(err).Send()
}
err = toml.NewEncoder(cfgFl).Encode(&defaultConfig)
if err != nil {
log.Fatal("Error encoding default configuration").Err(err).Send()
}
cfgFl.Close()
}
cacheDir, err := os.UserCacheDir()
if err != nil {
log.Fatal("Unable to detect cache directory").Err(err).Send()
}
paths.CacheDir = filepath.Join(cacheDir, "alr")
paths.RepoDir = filepath.Join(paths.CacheDir, "repo")
paths.PkgsDir = filepath.Join(paths.CacheDir, "pkgs")
err = os.MkdirAll(paths.RepoDir, 0o755)
if err != nil {
log.Fatal("Unable to create repo cache directory").Err(err).Send()
}
err = os.MkdirAll(paths.PkgsDir, 0o755)
if err != nil {
log.Fatal("Unable to create package cache directory").Err(err).Send()
}
paths.DBPath = filepath.Join(paths.CacheDir, "db")
}
return paths
} }

262
internal/db/db.go
View File

@ -20,28 +20,16 @@ package db
import ( import (
"context" "context"
"database/sql"
"database/sql/driver"
"encoding/json"
"errors"
"fmt"
"sync"
"github.com/jmoiron/sqlx" "github.com/jmoiron/sqlx"
"plemya-x.ru/alr/internal/config" "plemya-x.ru/alr/internal/config"
"plemya-x.ru/alr/pkg/loggerctx" "plemya-x.ru/alr/pkg/loggerctx"
"golang.org/x/exp/slices"
"modernc.org/sqlite"
) )
// CurrentVersion is the current version of the database. // CurrentVersion is the current version of the database.
// The database is reset if its version doesn't match this. // The database is reset if its version doesn't match this.
const CurrentVersion = 2 const CurrentVersion = 2
func init() {
sqlite.MustRegisterScalarFunction("json_array_contains", 2, jsonArrayContains)
}
// Package is a ALR package's database representation // Package is a ALR package's database representation
type Package struct { type Package struct {
Name string `sh:"name,required" db:"name"` Name string `sh:"name,required" db:"name"`
@ -66,66 +54,47 @@ type version struct {
Version int `db:"version"` Version int `db:"version"`
} }
var ( type Config interface {
mu sync.Mutex GetPaths(ctx context.Context) *config.Paths
}
type Database struct {
conn *sqlx.DB conn *sqlx.DB
closed = true config Config
) }
// DB returns the ALR database. func New(config Config) *Database {
// The first time it's called, it opens the SQLite database file. return &Database{
// Subsequent calls return the same connection. config: config,
func DB(ctx context.Context) *sqlx.DB {
log := loggerctx.From(ctx)
if conn != nil && !closed {
return getConn()
} }
_, err := open(ctx, config.GetPaths(ctx).DBPath) }
func (d *Database) Init(ctx context.Context) error {
err := d.Connect(ctx)
if err != nil { if err != nil {
log.Fatal("Error opening database").Err(err).Send() return err
} }
return getConn() return d.initDB(ctx)
} }
func getConn() *sqlx.DB { func (d *Database) Connect(ctx context.Context) error {
mu.Lock() dsn := d.config.GetPaths(ctx).DBPath
defer mu.Unlock()
return conn
}
func open(ctx context.Context, dsn string) (*sqlx.DB, error) {
db, err := sqlx.Open("sqlite", dsn) db, err := sqlx.Open("sqlite", dsn)
if err != nil { if err != nil {
return nil, err return err
} }
d.conn = db
mu.Lock() return nil
conn = db
closed = false
mu.Unlock()
err = initDB(ctx, dsn)
if err != nil {
return nil, err
}
return db, nil
} }
// Close closes the database func (d *Database) GetConn() *sqlx.DB {
func Close() error { return d.conn
closed = true
if conn != nil {
return conn.Close()
} else {
return nil
}
} }
// initDB initializes the database func (d *Database) initDB(ctx context.Context) error {
func initDB(ctx context.Context, dsn string) error {
log := loggerctx.From(ctx) log := loggerctx.From(ctx)
conn = conn.Unsafe() d.conn = d.conn.Unsafe()
conn := d.conn
_, err := conn.ExecContext(ctx, ` _, err := conn.ExecContext(ctx, `
CREATE TABLE IF NOT EXISTS pkgs ( CREATE TABLE IF NOT EXISTS pkgs (
name TEXT NOT NULL, name TEXT NOT NULL,
@ -155,58 +124,72 @@ func initDB(ctx context.Context, dsn string) error {
return err return err
} }
ver, ok := GetVersion(ctx) ver, ok := d.GetVersion(ctx)
if ok && ver != CurrentVersion { if ok && ver != CurrentVersion {
log.Warn("Database version mismatch; resetting").Int("version", ver).Int("expected", CurrentVersion).Send() log.Warn("Database version mismatch; resetting").Int("version", ver).Int("expected", CurrentVersion).Send()
reset(ctx) d.reset(ctx)
return initDB(ctx, dsn) return d.initDB(ctx)
} else if !ok { } else if !ok {
log.Warn("Database version does not exist. Run alr fix if something isn't working.").Send() log.Warn("Database version does not exist. Run alr fix if something isn't working.").Send()
return addVersion(ctx, CurrentVersion) return d.addVersion(ctx, CurrentVersion)
} }
return nil return nil
} }
// reset drops all the database tables func (d *Database) GetVersion(ctx context.Context) (int, bool) {
func reset(ctx context.Context) error {
_, err := DB(ctx).ExecContext(ctx, "DROP TABLE IF EXISTS pkgs;")
if err != nil {
return err
}
_, err = DB(ctx).ExecContext(ctx, "DROP TABLE IF EXISTS alr_db_version;")
return err
}
// IsEmpty returns true if the database has no packages in it, otherwise it returns false.
func IsEmpty(ctx context.Context) bool {
var count int
err := DB(ctx).GetContext(ctx, &count, "SELECT count(1) FROM pkgs;")
if err != nil {
return true
}
return count == 0
}
// GetVersion returns the database version and a boolean indicating
// whether the database contained a version number
func GetVersion(ctx context.Context) (int, bool) {
var ver version var ver version
err := DB(ctx).GetContext(ctx, &ver, "SELECT * FROM alr_db_version LIMIT 1;") err := d.conn.GetContext(ctx, &ver, "SELECT * FROM alr_db_version LIMIT 1;")
if err != nil { if err != nil {
return 0, false return 0, false
} }
return ver.Version, true return ver.Version, true
} }
func addVersion(ctx context.Context, ver int) error { func (d *Database) addVersion(ctx context.Context, ver int) error {
_, err := DB(ctx).ExecContext(ctx, `INSERT INTO alr_db_version(version) VALUES (?);`, ver) _, err := d.conn.ExecContext(ctx, `INSERT INTO alr_db_version(version) VALUES (?);`, ver)
return err return err
} }
// InsertPackage adds a package to the database func (d *Database) reset(ctx context.Context) error {
func InsertPackage(ctx context.Context, pkg Package) error { _, err := d.conn.ExecContext(ctx, "DROP TABLE IF EXISTS pkgs;")
_, err := DB(ctx).NamedExecContext(ctx, ` if err != nil {
return err
}
_, err = d.conn.ExecContext(ctx, "DROP TABLE IF EXISTS alr_db_version;")
return err
}
func (d *Database) GetPkgs(ctx context.Context, where string, args ...any) (*sqlx.Rows, error) {
stream, err := d.conn.QueryxContext(ctx, "SELECT * FROM pkgs WHERE "+where, args...)
if err != nil {
return nil, err
}
return stream, nil
}
func (d *Database) GetPkg(ctx context.Context, where string, args ...any) (*Package, error) {
out := &Package{}
err := d.conn.GetContext(ctx, out, "SELECT * FROM pkgs WHERE "+where+" LIMIT 1", args...)
return out, err
}
func (d *Database) DeletePkgs(ctx context.Context, where string, args ...any) error {
_, err := d.conn.ExecContext(ctx, "DELETE FROM pkgs WHERE "+where, args...)
return err
}
func (d *Database) IsEmpty(ctx context.Context) bool {
var count int
err := d.conn.GetContext(ctx, &count, "SELECT count(1) FROM pkgs;")
if err != nil {
return true
}
return count == 0
}
func (d *Database) InsertPackage(ctx context.Context, pkg Package) error {
_, err := d.conn.NamedExecContext(ctx, `
INSERT OR REPLACE INTO pkgs ( INSERT OR REPLACE INTO pkgs (
name, name,
repository, repository,
@ -246,101 +229,10 @@ func InsertPackage(ctx context.Context, pkg Package) error {
return err return err
} }
// GetPkgs returns a result containing packages that match the where conditions func (d *Database) Close() error {
func GetPkgs(ctx context.Context, where string, args ...any) (*sqlx.Rows, error) { if d.conn != nil {
stream, err := DB(ctx).QueryxContext(ctx, "SELECT * FROM pkgs WHERE "+where, args...) return d.conn.Close()
if err != nil { } else {
return nil, err
}
return stream, nil
}
// GetPkg returns a single package that matches the where conditions
func GetPkg(ctx context.Context, where string, args ...any) (*Package, error) {
out := &Package{}
err := DB(ctx).GetContext(ctx, out, "SELECT * FROM pkgs WHERE "+where+" LIMIT 1", args...)
return out, err
}
// DeletePkgs deletes all packages matching the where conditions
func DeletePkgs(ctx context.Context, where string, args ...any) error {
_, err := DB(ctx).ExecContext(ctx, "DELETE FROM pkgs WHERE "+where, args...)
return err
}
// jsonArrayContains is an SQLite function that checks if a JSON array
// in the database contains a given value
func jsonArrayContains(ctx *sqlite.FunctionContext, args []driver.Value) (driver.Value, error) {
value, ok := args[0].(string)
if !ok {
return nil, errors.New("both arguments to json_array_contains must be strings")
}
item, ok := args[1].(string)
if !ok {
return nil, errors.New("both arguments to json_array_contains must be strings")
}
var array []string
err := json.Unmarshal([]byte(value), &array)
if err != nil {
return nil, err
}
return slices.Contains(array, item), nil
}
// JSON represents a JSON value in the database
type JSON[T any] struct {
Val T
}
// NewJSON creates a new database JSON value
func NewJSON[T any](v T) JSON[T] {
return JSON[T]{Val: v}
}
func (s *JSON[T]) Scan(val any) error {
if val == nil {
return nil return nil
} }
switch val := val.(type) {
case string:
err := json.Unmarshal([]byte(val), &s.Val)
if err != nil {
return err
}
case sql.NullString:
if val.Valid {
err := json.Unmarshal([]byte(val.String), &s.Val)
if err != nil {
return err
}
}
default:
return errors.New("sqlite json types must be strings")
}
return nil
}
func (s JSON[T]) Value() (driver.Value, error) {
data, err := json.Marshal(s.Val)
if err != nil {
return nil, err
}
return string(data), nil
}
func (s JSON[T]) MarshalYAML() (any, error) {
return s.Val, nil
}
func (s JSON[T]) String() string {
return fmt.Sprint(s.Val)
}
func (s JSON[T]) GoString() string {
return fmt.Sprintf("%#v", s.Val)
} }

105
internal/db/db_legacy.go Normal file
View File

@ -0,0 +1,105 @@
/*
* ALR - Any Linux Repository
* Copyright (C) 2024 Евгений Храмов
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package db
import (
"context"
"sync"
"github.com/jmoiron/sqlx"
"plemya-x.ru/alr/internal/config"
"plemya-x.ru/alr/pkg/loggerctx"
)
// DB returns the ALR database.
// The first time it's called, it opens the SQLite database file.
// Subsequent calls return the same connection.
//
// Deprecated: use struct method
func DB(ctx context.Context) *sqlx.DB {
return GetInstance(ctx).GetConn()
}
// Close closes the database
//
// Deprecated: use struct method
func Close() error {
if database != nil {
return database.Close()
}
return nil
}
// IsEmpty returns true if the database has no packages in it, otherwise it returns false.
//
// Deprecated: use struct method
func IsEmpty(ctx context.Context) bool {
return GetInstance(ctx).IsEmpty(ctx)
}
// InsertPackage adds a package to the database
//
// Deprecated: use struct method
func InsertPackage(ctx context.Context, pkg Package) error {
return GetInstance(ctx).InsertPackage(ctx, pkg)
}
// GetPkgs returns a result containing packages that match the where conditions
//
// Deprecated: use struct method
func GetPkgs(ctx context.Context, where string, args ...any) (*sqlx.Rows, error) {
return GetInstance(ctx).GetPkgs(ctx, where, args...)
}
// GetPkg returns a single package that matches the where conditions
//
// Deprecated: use struct method
func GetPkg(ctx context.Context, where string, args ...any) (*Package, error) {
return GetInstance(ctx).GetPkg(ctx, where, args...)
}
// DeletePkgs deletes all packages matching the where conditions
//
// Deprecated: use struct method
func DeletePkgs(ctx context.Context, where string, args ...any) error {
return GetInstance(ctx).DeletePkgs(ctx, where, args...)
}
// =======================
// FOR LEGACY ONLY
// =======================
var (
dbOnce sync.Once
database *Database
)
// Deprecated: For legacy only
func GetInstance(ctx context.Context) *Database {
dbOnce.Do(func() {
log := loggerctx.From(ctx)
cfg := config.GetInstance(ctx)
database = New(cfg)
err := database.Init(ctx)
if err != nil {
log.Fatal("Error opening database").Err(err).Send()
}
})
return database
}

101
internal/db/db_test.go
View File

@ -19,14 +19,30 @@
package db_test package db_test
import ( import (
"context"
"reflect" "reflect"
"strings" "strings"
"testing" "testing"
"github.com/jmoiron/sqlx" "github.com/jmoiron/sqlx"
"plemya-x.ru/alr/internal/config"
"plemya-x.ru/alr/internal/db" "plemya-x.ru/alr/internal/db"
) )
type TestALRConfig struct{}
func (c *TestALRConfig) GetPaths(ctx context.Context) *config.Paths {
return &config.Paths{
DBPath: ":memory:",
}
}
func prepareDb() *db.Database {
database := db.New(&TestALRConfig{})
database.Init(context.Background())
return database
}
var testPkg = db.Package{ var testPkg = db.Package{
Name: "test", Name: "test",
Version: "0.0.1", Version: "0.0.1",
@ -59,18 +75,11 @@ var testPkg = db.Package{
} }
func TestInit(t *testing.T) { func TestInit(t *testing.T) {
_, err := db.Open(":memory:") ctx := context.Background()
if err != nil { database := prepareDb()
t.Fatalf("Expected no error, got %s", err) defer database.Close()
}
defer db.Close()
_, err = db.DB().Exec("SELECT * FROM pkgs") ver, ok := database.GetVersion(ctx)
if err != nil {
t.Fatalf("Expected no error, got %s", err)
}
ver, ok := db.GetVersion()
if !ok { if !ok {
t.Errorf("Expected version to be present") t.Errorf("Expected version to be present")
} else if ver != db.CurrentVersion { } else if ver != db.CurrentVersion {
@ -79,19 +88,17 @@ func TestInit(t *testing.T) {
} }
func TestInsertPackage(t *testing.T) { func TestInsertPackage(t *testing.T) {
_, err := db.Open(":memory:") ctx := context.Background()
if err != nil { database := prepareDb()
t.Fatalf("Expected no error, got %s", err) defer database.Close()
}
defer db.Close()
err = db.InsertPackage(testPkg) err := database.InsertPackage(ctx, testPkg)
if err != nil { if err != nil {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }
dbPkg := db.Package{} dbPkg := db.Package{}
err = sqlx.Get(db.DB(), &dbPkg, "SELECT * FROM pkgs WHERE name = 'test' AND repository = 'default'") err = sqlx.Get(database.GetConn(), &dbPkg, "SELECT * FROM pkgs WHERE name = 'test' AND repository = 'default'")
if err != nil { if err != nil {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }
@ -102,28 +109,26 @@ func TestInsertPackage(t *testing.T) {
} }
func TestGetPkgs(t *testing.T) { func TestGetPkgs(t *testing.T) {
_, err := db.Open(":memory:") ctx := context.Background()
if err != nil { database := prepareDb()
t.Fatalf("Expected no error, got %s", err) defer database.Close()
}
defer db.Close()
x1 := testPkg x1 := testPkg
x1.Name = "x1" x1.Name = "x1"
x2 := testPkg x2 := testPkg
x2.Name = "x2" x2.Name = "x2"
err = db.InsertPackage(x1) err := database.InsertPackage(ctx, x1)
if err != nil { if err != nil {
t.Errorf("Expected no error, got %s", err) t.Errorf("Expected no error, got %s", err)
} }
err = db.InsertPackage(x2) err = database.InsertPackage(ctx, x2)
if err != nil { if err != nil {
t.Errorf("Expected no error, got %s", err) t.Errorf("Expected no error, got %s", err)
} }
result, err := db.GetPkgs("name LIKE 'x%'") result, err := database.GetPkgs(ctx, "name LIKE 'x%'")
if err != nil { if err != nil {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }
@ -142,28 +147,26 @@ func TestGetPkgs(t *testing.T) {
} }
func TestGetPkg(t *testing.T) { func TestGetPkg(t *testing.T) {
_, err := db.Open(":memory:") ctx := context.Background()
if err != nil { database := prepareDb()
t.Fatalf("Expected no error, got %s", err) defer database.Close()
}
defer db.Close()
x1 := testPkg x1 := testPkg
x1.Name = "x1" x1.Name = "x1"
x2 := testPkg x2 := testPkg
x2.Name = "x2" x2.Name = "x2"
err = db.InsertPackage(x1) err := database.InsertPackage(ctx, x1)
if err != nil { if err != nil {
t.Errorf("Expected no error, got %s", err) t.Errorf("Expected no error, got %s", err)
} }
err = db.InsertPackage(x2) err = database.InsertPackage(ctx, x2)
if err != nil { if err != nil {
t.Errorf("Expected no error, got %s", err) t.Errorf("Expected no error, got %s", err)
} }
pkg, err := db.GetPkg("name LIKE 'x%' ORDER BY name") pkg, err := database.GetPkg(ctx, "name LIKE 'x%' ORDER BY name")
if err != nil { if err != nil {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }
@ -178,34 +181,32 @@ func TestGetPkg(t *testing.T) {
} }
func TestDeletePkgs(t *testing.T) { func TestDeletePkgs(t *testing.T) {
_, err := db.Open(":memory:") ctx := context.Background()
if err != nil { database := prepareDb()
t.Fatalf("Expected no error, got %s", err) defer database.Close()
}
defer db.Close()
x1 := testPkg x1 := testPkg
x1.Name = "x1" x1.Name = "x1"
x2 := testPkg x2 := testPkg
x2.Name = "x2" x2.Name = "x2"
err = db.InsertPackage(x1) err := database.InsertPackage(ctx, x1)
if err != nil { if err != nil {
t.Errorf("Expected no error, got %s", err) t.Errorf("Expected no error, got %s", err)
} }
err = db.InsertPackage(x2) err = database.InsertPackage(ctx, x2)
if err != nil { if err != nil {
t.Errorf("Expected no error, got %s", err) t.Errorf("Expected no error, got %s", err)
} }
err = db.DeletePkgs("name = 'x1'") err = database.DeletePkgs(ctx, "name = 'x1'")
if err != nil { if err != nil {
t.Errorf("Expected no error, got %s", err) t.Errorf("Expected no error, got %s", err)
} }
var dbPkg db.Package var dbPkg db.Package
err = db.DB().Get(&dbPkg, "SELECT * FROM pkgs WHERE name LIKE 'x%' ORDER BY name LIMIT 1;") err = database.GetConn().Get(&dbPkg, "SELECT * FROM pkgs WHERE name LIKE 'x%' ORDER BY name LIMIT 1;")
if err != nil { if err != nil {
t.Errorf("Expected no error, got %s", err) t.Errorf("Expected no error, got %s", err)
} }
@ -216,11 +217,9 @@ func TestDeletePkgs(t *testing.T) {
} }
func TestJsonArrayContains(t *testing.T) { func TestJsonArrayContains(t *testing.T) {
_, err := db.Open(":memory:") ctx := context.Background()
if err != nil { database := prepareDb()
t.Fatalf("Expected no error, got %s", err) defer database.Close()
}
defer db.Close()
x1 := testPkg x1 := testPkg
x1.Name = "x1" x1.Name = "x1"
@ -228,18 +227,18 @@ func TestJsonArrayContains(t *testing.T) {
x2.Name = "x2" x2.Name = "x2"
x2.Provides.Val = append(x2.Provides.Val, "x") x2.Provides.Val = append(x2.Provides.Val, "x")
err = db.InsertPackage(x1) err := database.InsertPackage(ctx, x1)
if err != nil { if err != nil {
t.Errorf("Expected no error, got %s", err) t.Errorf("Expected no error, got %s", err)
} }
err = db.InsertPackage(x2) err = database.InsertPackage(ctx, x2)
if err != nil { if err != nil {
t.Errorf("Expected no error, got %s", err) t.Errorf("Expected no error, got %s", err)
} }
var dbPkg db.Package var dbPkg db.Package
err = db.DB().Get(&dbPkg, "SELECT * FROM pkgs WHERE json_array_contains(provides, 'x');") err = database.GetConn().Get(&dbPkg, "SELECT * FROM pkgs WHERE json_array_contains(provides, 'x');")
if err != nil { if err != nil {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }

64
internal/db/json.go Normal file
View File

@ -0,0 +1,64 @@
package db
import (
"database/sql"
"database/sql/driver"
"encoding/json"
"errors"
"fmt"
)
// JSON represents a JSON value in the database
type JSON[T any] struct {
Val T
}
// NewJSON creates a new database JSON value
func NewJSON[T any](v T) JSON[T] {
return JSON[T]{Val: v}
}
func (s *JSON[T]) Scan(val any) error {
if val == nil {
return nil
}
switch val := val.(type) {
case string:
err := json.Unmarshal([]byte(val), &s.Val)
if err != nil {
return err
}
case sql.NullString:
if val.Valid {
err := json.Unmarshal([]byte(val.String), &s.Val)
if err != nil {
return err
}
}
default:
return errors.New("sqlite json types must be strings")
}
return nil
}
func (s JSON[T]) Value() (driver.Value, error) {
data, err := json.Marshal(s.Val)
if err != nil {
return nil, err
}
return string(data), nil
}
func (s JSON[T]) MarshalYAML() (any, error) {
return s.Val, nil
}
func (s JSON[T]) String() string {
return fmt.Sprint(s.Val)
}
func (s JSON[T]) GoString() string {
return fmt.Sprintf("%#v", s.Val)
}

36
internal/db/utils.go Normal file
View File

@ -0,0 +1,36 @@
package db
import (
"database/sql/driver"
"encoding/json"
"errors"
"golang.org/x/exp/slices"
"modernc.org/sqlite"
)
func init() {
sqlite.MustRegisterScalarFunction("json_array_contains", 2, jsonArrayContains)
}
// jsonArrayContains is an SQLite function that checks if a JSON array
// in the database contains a given value
func jsonArrayContains(ctx *sqlite.FunctionContext, args []driver.Value) (driver.Value, error) {
value, ok := args[0].(string)
if !ok {
return nil, errors.New("both arguments to json_array_contains must be strings")
}
item, ok := args[1].(string)
if !ok {
return nil, errors.New("both arguments to json_array_contains must be strings")
}
var array []string
err := json.Unmarshal([]byte(value), &array)
if err != nil {
return nil, err
}
return slices.Contains(array, item), nil
}

12
internal/dl/dl.go
View File

@ -14,7 +14,7 @@
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
// Пакет dl содержит абстракции для загрузки файлов и каталогов // Пакет dl содержит абстракции для загрузки файлов и каталогов
// из различных источников. // из различных источников.
@ -39,6 +39,7 @@ import (
"golang.org/x/crypto/blake2b" "golang.org/x/crypto/blake2b"
"golang.org/x/crypto/blake2s" "golang.org/x/crypto/blake2s"
"golang.org/x/exp/slices" "golang.org/x/exp/slices"
"plemya-x.ru/alr/internal/config"
"plemya-x.ru/alr/internal/dlcache" "plemya-x.ru/alr/internal/dlcache"
"plemya-x.ru/alr/pkg/loggerctx" "plemya-x.ru/alr/pkg/loggerctx"
) )
@ -142,6 +143,9 @@ type UpdatingDownloader interface {
// Функция Download загружает файл или каталог с использованием указанных параметров // Функция Download загружает файл или каталог с использованием указанных параметров
func Download(ctx context.Context, opts Options) (err error) { func Download(ctx context.Context, opts Options) (err error) {
log := loggerctx.From(ctx) log := loggerctx.From(ctx)
cfg := config.GetInstance(ctx)
dc := dlcache.New(cfg)
normalized, err := normalizeURL(opts.URL) normalized, err := normalizeURL(opts.URL)
if err != nil { if err != nil {
return err return err
@ -156,7 +160,7 @@ func Download(ctx context.Context, opts Options) (err error) {
} }
var t Type var t Type
cacheDir, ok := dlcache.Get(ctx, opts.URL) cacheDir, ok := dc.Get(ctx, opts.URL)
if ok { if ok {
var updated bool var updated bool
if d, ok := d.(UpdatingDownloader); ok { if d, ok := d.(UpdatingDownloader); ok {
@ -203,7 +207,7 @@ func Download(ctx context.Context, opts Options) (err error) {
log.Info("Downloading source").Str("source", opts.Name).Str("downloader", d.Name()).Send() log.Info("Downloading source").Str("source", opts.Name).Str("downloader", d.Name()).Send()
cacheDir, err = dlcache.New(ctx, opts.URL) cacheDir, err = dc.New(ctx, opts.URL)
if err != nil { if err != nil {
return err return err
} }
@ -299,8 +303,6 @@ func linkDir(src, dest string) error {
return nil return nil
} }
rel, err := filepath.Rel(src, path) rel, err := filepath.Rel(src, path)
if err != nil { if err != nil {
return err return err

44
internal/dlcache/dlcache.go
View File

@ -20,29 +20,41 @@ package dlcache
import ( import (
"context" "context"
"crypto/sha1"
"encoding/hex"
"io"
"os" "os"
"path/filepath" "path/filepath"
"plemya-x.ru/alr/internal/config" "plemya-x.ru/alr/internal/config"
) )
// BasePath returns the base path of the download cache type Config interface {
func BasePath(ctx context.Context) string { GetPaths(ctx context.Context) *config.Paths
return filepath.Join(config.GetPaths(ctx).CacheDir, "dl") }
type DownloadCache struct {
cfg Config
}
func New(cfg Config) *DownloadCache {
return &DownloadCache{
cfg,
}
}
func (dc *DownloadCache) BasePath(ctx context.Context) string {
return filepath.Join(
dc.cfg.GetPaths(ctx).CacheDir, "dl",
)
} }
// New creates a new directory with the given ID in the cache. // New creates a new directory with the given ID in the cache.
// If a directory with the same ID already exists, // If a directory with the same ID already exists,
// it will be deleted before creating a new one. // it will be deleted before creating a new one.
func New(ctx context.Context, id string) (string, error) { func (dc *DownloadCache) New(ctx context.Context, id string) (string, error) {
h, err := hashID(id) h, err := hashID(id)
if err != nil { if err != nil {
return "", err return "", err
} }
itemPath := filepath.Join(BasePath(ctx), h) itemPath := filepath.Join(dc.BasePath(ctx), h)
fi, err := os.Stat(itemPath) fi, err := os.Stat(itemPath)
if err == nil || (fi != nil && !fi.IsDir()) { if err == nil || (fi != nil && !fi.IsDir()) {
@ -65,12 +77,12 @@ func New(ctx context.Context, id string) (string, error) {
// returns the directory and true. If it // returns the directory and true. If it
// does not exist, it returns an empty string // does not exist, it returns an empty string
// and false. // and false.
func Get(ctx context.Context, id string) (string, bool) { func (dc *DownloadCache) Get(ctx context.Context, id string) (string, bool) {
h, err := hashID(id) h, err := hashID(id)
if err != nil { if err != nil {
return "", false return "", false
} }
itemPath := filepath.Join(BasePath(ctx), h) itemPath := filepath.Join(dc.BasePath(ctx), h)
_, err = os.Stat(itemPath) _, err = os.Stat(itemPath)
if err != nil { if err != nil {
@ -79,15 +91,3 @@ func Get(ctx context.Context, id string) (string, bool) {
return itemPath, true return itemPath, true
} }
// hashID hashes the input ID with SHA1
// and returns the hex string of the hashed
// ID.
func hashID(id string) (string, error) {
h := sha1.New()
_, err := io.WriteString(h, id)
if err != nil {
return "", err
}
return hex.EncodeToString(h.Sum(nil)), nil
}

41
internal/dlcache/dlcache_test.go
View File

@ -39,14 +39,49 @@ func init() {
config.GetPaths(context.Background()).RepoDir = dir config.GetPaths(context.Background()).RepoDir = dir
} }
type TestALRConfig struct {
CacheDir string
}
func (c *TestALRConfig) GetPaths(ctx context.Context) *config.Paths {
return &config.Paths{
CacheDir: c.CacheDir,
}
}
func prepare(t *testing.T) *TestALRConfig {
t.Helper()
dir, err := os.MkdirTemp("/tmp", "alr-dlcache-test.*")
if err != nil {
panic(err)
}
return &TestALRConfig{
CacheDir: dir,
}
}
func cleanup(t *testing.T, cfg *TestALRConfig) {
t.Helper()
os.Remove(cfg.CacheDir)
}
func TestNew(t *testing.T) { func TestNew(t *testing.T) {
cfg := prepare(t)
defer cleanup(t, cfg)
dc := dlcache.New(cfg)
ctx := context.Background()
const id = "https://example.com" const id = "https://example.com"
dir, err := dlcache.New(id) dir, err := dc.New(ctx, id)
if err != nil { if err != nil {
t.Errorf("Expected no error, got %s", err) t.Errorf("Expected no error, got %s", err)
} }
exp := filepath.Join(dlcache.BasePath(), sha1sum(id)) exp := filepath.Join(dc.BasePath(ctx), sha1sum(id))
if dir != exp { if dir != exp {
t.Errorf("Expected %s, got %s", exp, dir) t.Errorf("Expected %s, got %s", exp, dir)
} }
@ -60,7 +95,7 @@ func TestNew(t *testing.T) {
t.Errorf("Expected cache item to be a directory") t.Errorf("Expected cache item to be a directory")
} }
dir2, ok := dlcache.Get(id) dir2, ok := dc.Get(ctx, id)
if !ok { if !ok {
t.Errorf("Expected Get() to return valid value") t.Errorf("Expected Get() to return valid value")
} }

16
internal/dlcache/utils.go Normal file
View File

@ -0,0 +1,16 @@
package dlcache
import (
"crypto/sha1"
"encoding/hex"
"io"
)
func hashID(id string) (string, error) {
h := sha1.New()
_, err := io.WriteString(h, id)
if err != nil {
return "", err
}
return hex.EncodeToString(h.Sum(nil)), nil
}

9
internal/shutils/decoder/decoder.go
View File

@ -25,12 +25,12 @@ import (
"strings" "strings"
"github.com/mitchellh/mapstructure" "github.com/mitchellh/mapstructure"
"plemya-x.ru/alr/internal/overrides"
"plemya-x.ru/alr/pkg/distro"
"golang.org/x/exp/slices" "golang.org/x/exp/slices"
"mvdan.cc/sh/v3/expand" "mvdan.cc/sh/v3/expand"
"mvdan.cc/sh/v3/interp" "mvdan.cc/sh/v3/interp"
"mvdan.cc/sh/v3/syntax" "mvdan.cc/sh/v3/syntax"
"plemya-x.ru/alr/internal/overrides"
"plemya-x.ru/alr/pkg/distro"
) )
var ErrNotPointerToStruct = errors.New("val must be a pointer to a struct") var ErrNotPointerToStruct = errors.New("val must be a pointer to a struct")
@ -221,3 +221,8 @@ func (d *Decoder) getVar(name string) *expand.Variable {
} }
return nil return nil
} }
func IsTruthy(value string) bool {
value = strings.ToLower(strings.TrimSpace(value))
return value == "true" || value == "yes" || value == "1"
}

6
internal/shutils/decoder/decoder_test.go
View File

@ -27,10 +27,10 @@ import (
"strings" "strings"
"testing" "testing"
"plemya-x.ru/alr/internal/shutils/decoder"
"plemya-x.ru/alr/pkg/distro"
"mvdan.cc/sh/v3/interp" "mvdan.cc/sh/v3/interp"
"mvdan.cc/sh/v3/syntax" "mvdan.cc/sh/v3/syntax"
"plemya-x.ru/alr/internal/shutils/decoder"
"plemya-x.ru/alr/pkg/distro"
) )
type BuildVars struct { type BuildVars struct {
@ -56,7 +56,7 @@ const testScript = `
release=1 release=1
epoch=2 epoch=2
desc="Test package" desc="Test package"
homepage='//https://gitea.plemya-x.ru/xpamych/ALR' homepage='https://gitea.plemya-x.ru/xpamych/ALR'
maintainer='Евгений Храмов <xpamych@yandex.ru>' maintainer='Евгений Храмов <xpamych@yandex.ru>'
architectures=('arm64' 'amd64') architectures=('arm64' 'amd64')
license=('GPL-3.0-or-later') license=('GPL-3.0-or-later')

8
internal/shutils/handlers/exec_test.go
View File

@ -23,11 +23,11 @@ import (
"strings" "strings"
"testing" "testing"
"plemya-x.ru/alr/internal/shutils/handlers"
"plemya-x.ru/alr/internal/shutils/decoder"
"plemya-x.ru/alr/pkg/distro"
"mvdan.cc/sh/v3/interp" "mvdan.cc/sh/v3/interp"
"mvdan.cc/sh/v3/syntax" "mvdan.cc/sh/v3/syntax"
"plemya-x.ru/alr/internal/shutils/decoder"
"plemya-x.ru/alr/internal/shutils/handlers"
"plemya-x.ru/alr/pkg/distro"
) )
const testScript = ` const testScript = `
@ -89,7 +89,7 @@ func TestExecFuncs(t *testing.T) {
t.Fatalf("Expected test() function to exist") t.Fatalf("Expected test() function to exist")
} }
eh := shutils.ExecFuncs{ eh := handlers.ExecFuncs{
"test-cmd": func(hc interp.HandlerContext, name string, args []string) error { "test-cmd": func(hc interp.HandlerContext, name string, args []string) error {
if name != "test-cmd" { if name != "test-cmd" {
t.Errorf("Expected name to be 'test-cmd', got '%s'", name) t.Errorf("Expected name to be 'test-cmd', got '%s'", name)

2
internal/types/build.go
View File

@ -49,6 +49,8 @@ type BuildVars struct {
Checksums []string `sh:"checksums"` Checksums []string `sh:"checksums"`
Backup []string `sh:"backup"` Backup []string `sh:"backup"`
Scripts Scripts `sh:"scripts"` Scripts Scripts `sh:"scripts"`
AutoReq []string `sh:"auto_req"`
AutoProv []string `sh:"auto_prov"`
} }
type Scripts struct { type Scripts struct {

18
list.go
View File

@ -22,12 +22,12 @@ import (
"fmt" "fmt"
"github.com/urfave/cli/v2" "github.com/urfave/cli/v2"
"golang.org/x/exp/slices"
"plemya-x.ru/alr/internal/config" "plemya-x.ru/alr/internal/config"
"plemya-x.ru/alr/internal/db" database "plemya-x.ru/alr/internal/db"
"plemya-x.ru/alr/pkg/loggerctx" "plemya-x.ru/alr/pkg/loggerctx"
"plemya-x.ru/alr/pkg/manager" "plemya-x.ru/alr/pkg/manager"
"plemya-x.ru/alr/pkg/repos" "plemya-x.ru/alr/pkg/repos"
"golang.org/x/exp/slices"
) )
var listCmd = &cli.Command{ var listCmd = &cli.Command{
@ -43,8 +43,14 @@ var listCmd = &cli.Command{
Action: func(c *cli.Context) error { Action: func(c *cli.Context) error {
ctx := c.Context ctx := c.Context
log := loggerctx.From(ctx) log := loggerctx.From(ctx)
cfg := config.New()
err := repos.Pull(ctx, config.Config(ctx).Repos) db := database.New(cfg)
err := db.Init(ctx)
if err != nil {
log.Fatal("Error initialization database").Err(err).Send()
}
rs := repos.New(cfg, db)
err = rs.Pull(ctx, cfg.Repos(ctx))
if err != nil { if err != nil {
log.Fatal("Error pulling repositories").Err(err).Send() log.Fatal("Error pulling repositories").Err(err).Send()
} }
@ -76,13 +82,13 @@ var listCmd = &cli.Command{
} }
for result.Next() { for result.Next() {
var pkg db.Package var pkg database.Package
err := result.StructScan(&pkg) err := result.StructScan(&pkg)
if err != nil { if err != nil {
return err return err
} }
if slices.Contains(config.Config(ctx).IgnorePkgUpdates, pkg.Name) { if slices.Contains(cfg.IgnorePkgUpdates(ctx), pkg.Name) {
continue continue
} }

26
pkg/build/build.go
View File

@ -46,6 +46,7 @@ import (
_ "github.com/goreleaser/nfpm/v2/arch" _ "github.com/goreleaser/nfpm/v2/arch"
_ "github.com/goreleaser/nfpm/v2/deb" _ "github.com/goreleaser/nfpm/v2/deb"
_ "github.com/goreleaser/nfpm/v2/rpm" _ "github.com/goreleaser/nfpm/v2/rpm"
"go.elara.ws/logger/log"
"mvdan.cc/sh/v3/expand" "mvdan.cc/sh/v3/expand"
"mvdan.cc/sh/v3/interp" "mvdan.cc/sh/v3/interp"
"mvdan.cc/sh/v3/syntax" "mvdan.cc/sh/v3/syntax"
@ -543,14 +544,25 @@ func buildPkgMetadata(ctx context.Context, vars *types.BuildVars, dirs types.Dir
} }
pkgInfo.Overridables.Contents = contents pkgInfo.Overridables.Contents = contents
if pkgFormat == "rpm" { if len(vars.AutoProv) == 1 && decoder.IsTruthy(vars.AutoProv[0]) {
err = rpmFindProvides(ctx, pkgInfo, dirs) if pkgFormat == "rpm" {
if err != nil { err = rpmFindProvides(ctx, pkgInfo, dirs)
return nil, err if err != nil {
return nil, err
}
} else {
log.Info("AutoProv is not implemented for this package format, so it's skiped").Send()
} }
err = rpmFindRequires(ctx, pkgInfo, dirs) }
if err != nil {
return nil, err if len(vars.AutoReq) == 1 && decoder.IsTruthy(vars.AutoReq[0]) {
if pkgFormat == "rpm" {
err = rpmFindRequires(ctx, pkgInfo, dirs)
if err != nil {
return nil, err
}
} else {
log.Info("AutoReq is not implemented for this package format, so it's skiped").Send()
} }
} }

2
pkg/build/findDeps.go
View File

@ -47,7 +47,7 @@ func rpmFindDependencies(ctx context.Context, pkgInfo *nfpm.Info, dirs types.Dir
cmd.Stdout = &out cmd.Stdout = &out
cmd.Stderr = &stderr cmd.Stderr = &stderr
if err := cmd.Run(); err != nil { if err := cmd.Run(); err != nil {
log.Error(stderr.String()) log.Error(stderr.String()).Send()
return err return err
} }

10
pkg/repos/find.go
View File

@ -15,7 +15,6 @@
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
package repos package repos
import ( import (
@ -24,10 +23,7 @@ import (
"plemya-x.ru/alr/internal/db" "plemya-x.ru/alr/internal/db"
) )
// FindPkgs looks for packages matching the inputs inside the database. func (rs *Repos) FindPkgs(ctx context.Context, pkgs []string) (map[string][]db.Package, []string, error) {
// It returns a map that maps the package name input to any packages found for it.
// It also returns a slice that contains the names of all packages that were not found.
func FindPkgs(ctx context.Context, pkgs []string) (map[string][]db.Package, []string, error) {
found := map[string][]db.Package{} found := map[string][]db.Package{}
notFound := []string(nil) notFound := []string(nil)
@ -36,7 +32,7 @@ func FindPkgs(ctx context.Context, pkgs []string) (map[string][]db.Package, []st
continue continue
} }
result, err := db.GetPkgs(ctx, "json_array_contains(provides, ?)", pkgName) result, err := rs.db.GetPkgs(ctx, "json_array_contains(provides, ?)", pkgName)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
@ -55,7 +51,7 @@ func FindPkgs(ctx context.Context, pkgs []string) (map[string][]db.Package, []st
result.Close() result.Close()
if added == 0 { if added == 0 {
result, err := db.GetPkgs(ctx, "name LIKE ?", pkgName) result, err := rs.db.GetPkgs(ctx, "name LIKE ?", pkgName)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }

56
pkg/repos/find_test.go
View File

@ -19,7 +19,6 @@
package repos_test package repos_test
import ( import (
"context"
"reflect" "reflect"
"strings" "strings"
"testing" "testing"
@ -30,18 +29,15 @@ import (
) )
func TestFindPkgs(t *testing.T) { func TestFindPkgs(t *testing.T) {
_, err := db.Open(":memory:") e := prepare(t)
if err != nil { defer cleanup(t, e)
t.Fatalf("Expected no error, got %s", err)
}
defer db.Close()
setCfgDirs(t) rs := repos.New(
defer removeCacheDir(t) e.Cfg,
e.Db,
)
ctx := context.Background() err := rs.Pull(e.Ctx, []types.Repo{
err = repos.Pull(ctx, []types.Repo{
{ {
Name: "default", Name: "default",
URL: "https://gitea.plemya-x.ru/xpamych/xpamych-alr-repo.git", URL: "https://gitea.plemya-x.ru/xpamych/xpamych-alr-repo.git",
@ -51,7 +47,10 @@ func TestFindPkgs(t *testing.T) {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }
found, notFound, err := repos.FindPkgs([]string{"itd", "nonexistentpackage1", "nonexistentpackage2"}) found, notFound, err := rs.FindPkgs(
e.Ctx,
[]string{"alr", "nonexistentpackage1", "nonexistentpackage2"},
)
if err != nil { if err != nil {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }
@ -64,33 +63,32 @@ func TestFindPkgs(t *testing.T) {
t.Errorf("Expected 1 package found, got %d", len(found)) t.Errorf("Expected 1 package found, got %d", len(found))
} }
itdPkgs, ok := found["itd"] alrPkgs, ok := found["alr"]
if !ok { if !ok {
t.Fatalf("Expected 'itd' packages to be found") t.Fatalf("Expected 'alr' packages to be found")
} }
if len(itdPkgs) < 2 { if len(alrPkgs) < 2 {
t.Errorf("Expected two 'itd' packages to be found") t.Errorf("Expected two 'alr' packages to be found")
} }
for i, pkg := range itdPkgs { for i, pkg := range alrPkgs {
if !strings.HasPrefix(pkg.Name, "itd") { if !strings.HasPrefix(pkg.Name, "alr") {
t.Errorf("Expected package name of all found packages to start with 'itd', got %s on element %d", pkg.Name, i) t.Errorf("Expected package name of all found packages to start with 'alr', got %s on element %d", pkg.Name, i)
} }
} }
} }
func TestFindPkgsEmpty(t *testing.T) { func TestFindPkgsEmpty(t *testing.T) {
_, err := db.Open(":memory:") e := prepare(t)
if err != nil { defer cleanup(t, e)
t.Fatalf("Expected no error, got %s", err)
}
defer db.Close()
setCfgDirs(t) rs := repos.New(
defer removeCacheDir(t) e.Cfg,
e.Db,
)
err = db.InsertPackage(db.Package{ err := e.Db.InsertPackage(e.Ctx, db.Package{
Name: "test1", Name: "test1",
Repository: "default", Repository: "default",
Version: "0.0.1", Version: "0.0.1",
@ -105,7 +103,7 @@ func TestFindPkgsEmpty(t *testing.T) {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }
err = db.InsertPackage(db.Package{ err = e.Db.InsertPackage(e.Ctx, db.Package{
Name: "test2", Name: "test2",
Repository: "default", Repository: "default",
Version: "0.0.1", Version: "0.0.1",
@ -120,7 +118,7 @@ func TestFindPkgsEmpty(t *testing.T) {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }
found, notFound, err := repos.FindPkgs([]string{"test", ""}) found, notFound, err := rs.FindPkgs(e.Ctx, []string{"test", ""})
if err != nil { if err != nil {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }

130
pkg/repos/pull.go
View File

@ -21,41 +21,48 @@ package repos
import ( import (
"context" "context"
"errors" "errors"
"io"
"net/url" "net/url"
"os" "os"
"path/filepath" "path/filepath"
"reflect"
"strings" "strings"
"github.com/go-git/go-billy/v5" "github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/osfs" "github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-git/v5" "github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing" "github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/diff"
"github.com/pelletier/go-toml/v2" "github.com/pelletier/go-toml/v2"
"go.elara.ws/vercmp" "go.elara.ws/vercmp"
"plemya-x.ru/alr/internal/config"
"plemya-x.ru/alr/internal/db"
"plemya-x.ru/alr/internal/shutils/decoder"
"plemya-x.ru/alr/internal/shutils/handlers"
"plemya-x.ru/alr/internal/types"
"plemya-x.ru/alr/pkg/distro"
"plemya-x.ru/alr/pkg/loggerctx"
"mvdan.cc/sh/v3/expand" "mvdan.cc/sh/v3/expand"
"mvdan.cc/sh/v3/interp" "mvdan.cc/sh/v3/interp"
"mvdan.cc/sh/v3/syntax" "mvdan.cc/sh/v3/syntax"
"plemya-x.ru/alr/internal/config"
"plemya-x.ru/alr/internal/db"
"plemya-x.ru/alr/internal/shutils/handlers"
"plemya-x.ru/alr/internal/types"
"plemya-x.ru/alr/pkg/loggerctx"
) )
type actionType uint8
const (
actionDelete actionType = iota
actionUpdate
)
type action struct {
Type actionType
File string
}
// Pull pulls the provided repositories. If a repo doesn't exist, it will be cloned // Pull pulls the provided repositories. If a repo doesn't exist, it will be cloned
// and its packages will be written to the DB. If it does exist, it will be pulled. // and its packages will be written to the DB. If it does exist, it will be pulled.
// In this case, only changed packages will be processed if possible. // In this case, only changed packages will be processed if possible.
// If repos is set to nil, the repos in the ALR config will be used. // If repos is set to nil, the repos in the ALR config will be used.
func Pull(ctx context.Context, repos []types.Repo) error { func (rs *Repos) Pull(ctx context.Context, repos []types.Repo) error {
log := loggerctx.From(ctx) log := loggerctx.From(ctx)
if repos == nil { if repos == nil {
repos = config.Config(ctx).Repos repos = rs.cfg.Repos(ctx)
} }
for _, repo := range repos { for _, repo := range repos {
@ -95,7 +102,7 @@ func Pull(ctx context.Context, repos []types.Repo) error {
repoFS = w.Filesystem repoFS = w.Filesystem
// Make sure the DB is created even if the repo is up to date // Make sure the DB is created even if the repo is up to date
if !errors.Is(err, git.NoErrAlreadyUpToDate) || db.IsEmpty(ctx) { if !errors.Is(err, git.NoErrAlreadyUpToDate) || rs.db.IsEmpty(ctx) {
new, err := r.Head() new, err := r.Head()
if err != nil { if err != nil {
return err return err
@ -104,13 +111,13 @@ func Pull(ctx context.Context, repos []types.Repo) error {
// If the DB was not present at startup, that means it's // If the DB was not present at startup, that means it's
// empty. In this case, we need to update the DB fully // empty. In this case, we need to update the DB fully
// rather than just incrementally. // rather than just incrementally.
if db.IsEmpty(ctx) { if rs.db.IsEmpty(ctx) {
err = processRepoFull(ctx, repo, repoDir) err = rs.processRepoFull(ctx, repo, repoDir)
if err != nil { if err != nil {
return err return err
} }
} else { } else {
err = processRepoChanges(ctx, repo, r, w, old, new) err = rs.processRepoChanges(ctx, repo, r, w, old, new)
if err != nil { if err != nil {
return err return err
} }
@ -135,7 +142,7 @@ func Pull(ctx context.Context, repos []types.Repo) error {
return err return err
} }
err = processRepoFull(ctx, repo, repoDir) err = rs.processRepoFull(ctx, repo, repoDir)
if err != nil { if err != nil {
return err return err
} }
@ -169,19 +176,7 @@ func Pull(ctx context.Context, repos []types.Repo) error {
return nil return nil
} }
type actionType uint8 func (rs *Repos) processRepoChanges(ctx context.Context, repo types.Repo, r *git.Repository, w *git.Worktree, old, new *plumbing.Reference) error {
const (
actionDelete actionType = iota
actionUpdate
)
type action struct {
Type actionType
File string
}
func processRepoChanges(ctx context.Context, repo types.Repo, r *git.Repository, w *git.Worktree, old, new *plumbing.Reference) error {
oldCommit, err := r.CommitObject(old.Hash()) oldCommit, err := r.CommitObject(old.Hash())
if err != nil { if err != nil {
return err return err
@ -275,7 +270,7 @@ func processRepoChanges(ctx context.Context, repo types.Repo, r *git.Repository,
return err return err
} }
err = db.DeletePkgs(ctx, "name = ? AND repository = ?", pkg.Name, repo.Name) err = rs.db.DeletePkgs(ctx, "name = ? AND repository = ?", pkg.Name, repo.Name)
if err != nil { if err != nil {
return err return err
} }
@ -310,7 +305,7 @@ func processRepoChanges(ctx context.Context, repo types.Repo, r *git.Repository,
resolveOverrides(runner, &pkg) resolveOverrides(runner, &pkg)
err = db.InsertPackage(ctx, pkg) err = rs.db.InsertPackage(ctx, pkg)
if err != nil { if err != nil {
return err return err
} }
@ -320,23 +315,7 @@ func processRepoChanges(ctx context.Context, repo types.Repo, r *git.Repository,
return nil return nil
} }
// isValid makes sure the path of the file being updated is valid. func (rs *Repos) processRepoFull(ctx context.Context, repo types.Repo, repoDir string) error {
// It checks to make sure the file is not within a nested directory
// and that it is called alr.sh.
func isValid(from, to diff.File) bool {
var path string
if from != nil {
path = from.Path()
}
if to != nil {
path = to.Path()
}
match, _ := filepath.Match("*/*.sh", path)
return match
}
func processRepoFull(ctx context.Context, repo types.Repo, repoDir string) error {
glob := filepath.Join(repoDir, "/*/alr.sh") glob := filepath.Join(repoDir, "/*/alr.sh")
matches, err := filepath.Glob(glob) matches, err := filepath.Glob(glob)
if err != nil { if err != nil {
@ -380,7 +359,7 @@ func processRepoFull(ctx context.Context, repo types.Repo, repoDir string) error
resolveOverrides(runner, &pkg) resolveOverrides(runner, &pkg)
err = db.InsertPackage(ctx, pkg) err = rs.db.InsertPackage(ctx, pkg)
if err != nil { if err != nil {
return err return err
} }
@ -388,54 +367,3 @@ func processRepoFull(ctx context.Context, repo types.Repo, repoDir string) error
return nil return nil
} }
func parseScript(ctx context.Context, parser *syntax.Parser, runner *interp.Runner, r io.ReadCloser, pkg *db.Package) error {
defer r.Close()
fl, err := parser.Parse(r, "alr.sh")
if err != nil {
return err
}
runner.Reset()
err = runner.Run(ctx, fl)
if err != nil {
return err
}
d := decoder.New(&distro.OSRelease{}, runner)
d.Overrides = false
d.LikeDistros = false
return d.DecodeVars(pkg)
}
var overridable = map[string]string{
"deps": "Depends",
"build_deps": "BuildDepends",
"desc": "Description",
"homepage": "Homepage",
"maintainer": "Maintainer",
}
func resolveOverrides(runner *interp.Runner, pkg *db.Package) {
pkgVal := reflect.ValueOf(pkg).Elem()
for name, val := range runner.Vars {
for prefix, field := range overridable {
if strings.HasPrefix(name, prefix) {
override := strings.TrimPrefix(name, prefix)
override = strings.TrimPrefix(override, "_")
field := pkgVal.FieldByName(field)
varVal := field.FieldByName("Val")
varType := varVal.Type()
switch varType.Elem().String() {
case "[]string":
varVal.SetMapIndex(reflect.ValueOf(override), reflect.ValueOf(val.List))
case "string":
varVal.SetMapIndex(reflect.ValueOf(override), reflect.ValueOf(val.Str))
}
break
}
}
}
}

115
pkg/repos/pull_test.go
View File

@ -26,69 +26,104 @@ import (
"plemya-x.ru/alr/internal/config" "plemya-x.ru/alr/internal/config"
"plemya-x.ru/alr/internal/db" "plemya-x.ru/alr/internal/db"
database "plemya-x.ru/alr/internal/db"
"plemya-x.ru/alr/internal/types" "plemya-x.ru/alr/internal/types"
"plemya-x.ru/alr/pkg/repos" "plemya-x.ru/alr/pkg/repos"
) )
func setCfgDirs(t *testing.T) { type TestEnv struct {
t.Helper() Ctx context.Context
Cfg *TestALRConfig
paths := config.GetPaths() Db *db.Database
var err error
paths.CacheDir, err = os.MkdirTemp("/tmp", "alr-pull-test.*")
if err != nil {
t.Fatalf("Expected no error, got %s", err)
}
paths.RepoDir = filepath.Join(paths.CacheDir, "repo")
paths.PkgsDir = filepath.Join(paths.CacheDir, "pkgs")
err = os.MkdirAll(paths.RepoDir, 0o755)
if err != nil {
t.Fatalf("Expected no error, got %s", err)
}
err = os.MkdirAll(paths.PkgsDir, 0o755)
if err != nil {
t.Fatalf("Expected no error, got %s", err)
}
paths.DBPath = filepath.Join(paths.CacheDir, "db")
} }
func removeCacheDir(t *testing.T) { type TestALRConfig struct {
t.Helper() CacheDir string
RepoDir string
PkgsDir string
}
err := os.RemoveAll(config.GetPaths().CacheDir) func (c *TestALRConfig) GetPaths(ctx context.Context) *config.Paths {
if err != nil { return &config.Paths{
t.Fatalf("Expected no error, got %s", err) DBPath: ":memory:",
CacheDir: c.CacheDir,
RepoDir: c.RepoDir,
PkgsDir: c.PkgsDir,
} }
} }
func TestPull(t *testing.T) { func (c *TestALRConfig) Repos(ctx context.Context) []types.Repo {
_, err := db.Open(":memory:") return []types.Repo{}
}
func prepare(t *testing.T) *TestEnv {
t.Helper()
cacheDir, err := os.MkdirTemp("/tmp", "alr-pull-test.*")
if err != nil { if err != nil {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }
defer db.Close()
setCfgDirs(t) repoDir := filepath.Join(cacheDir, "repo")
defer removeCacheDir(t) err = os.MkdirAll(repoDir, 0o755)
if err != nil {
t.Fatalf("Expected no error, got %s", err)
}
pkgsDir := filepath.Join(cacheDir, "pkgs")
err = os.MkdirAll(pkgsDir, 0o755)
if err != nil {
t.Fatalf("Expected no error, got %s", err)
}
cfg := &TestALRConfig{
CacheDir: cacheDir,
RepoDir: repoDir,
PkgsDir: pkgsDir,
}
ctx := context.Background() ctx := context.Background()
err = repos.Pull(ctx, []types.Repo{ db := database.New(cfg)
db.Init(ctx)
return &TestEnv{
Cfg: cfg,
Db: db,
Ctx: ctx,
}
}
func cleanup(t *testing.T, e *TestEnv) {
t.Helper()
err := os.RemoveAll(e.Cfg.CacheDir)
if err != nil {
t.Fatalf("Expected no error, got %s", err)
}
e.Db.Close()
}
func TestPull(t *testing.T) {
e := prepare(t)
defer cleanup(t, e)
rs := repos.New(
e.Cfg,
e.Db,
)
err := rs.Pull(e.Ctx, []types.Repo{
{ {
Name: "default", Name: "default",
URL: "https://gitea.plemya-x.ru/xpamych/ALR.git", URL: "https://gitea.plemya-x.ru/Plemya-x/xpamych-alr-repo.git",
}, },
}) })
if err != nil { if err != nil {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }
result, err := db.GetPkgs("name LIKE 'itd%'") result, err := e.Db.GetPkgs(e.Ctx, "true")
if err != nil { if err != nil {
t.Fatalf("Expected no error, got %s", err) t.Fatalf("Expected no error, got %s", err)
} }
@ -103,7 +138,7 @@ func TestPull(t *testing.T) {
pkgAmt++ pkgAmt++
} }
if pkgAmt < 2 { if pkgAmt == 0 {
t.Errorf("Expected 2 packages to match, got %d", pkgAmt) t.Errorf("Expected at least 1 matching package, but got %d", pkgAmt)
} }
} }

29
pkg/repos/repos.go Normal file
View File

@ -0,0 +1,29 @@
package repos
import (
"context"
"plemya-x.ru/alr/internal/config"
database "plemya-x.ru/alr/internal/db"
"plemya-x.ru/alr/internal/types"
)
type Config interface {
GetPaths(ctx context.Context) *config.Paths
Repos(ctx context.Context) []types.Repo
}
type Repos struct {
cfg Config
db *database.Database
}
func New(
cfg Config,
db *database.Database,
) *Repos {
return &Repos{
cfg,
db,
}
}

54
pkg/repos/repos_legacy.go Normal file
View File

@ -0,0 +1,54 @@
package repos
import (
"context"
"sync"
"plemya-x.ru/alr/internal/config"
"plemya-x.ru/alr/internal/db"
database "plemya-x.ru/alr/internal/db"
"plemya-x.ru/alr/internal/types"
)
// Pull pulls the provided repositories. If a repo doesn't exist, it will be cloned
// and its packages will be written to the DB. If it does exist, it will be pulled.
// In this case, only changed packages will be processed if possible.
// If repos is set to nil, the repos in the ALR config will be used.
//
// Deprecated: use struct method
func Pull(ctx context.Context, repos []types.Repo) error {
return GetInstance(ctx).Pull(ctx, repos)
}
// FindPkgs looks for packages matching the inputs inside the database.
// It returns a map that maps the package name input to any packages found for it.
// It also returns a slice that contains the names of all packages that were not found.
//
// Deprecated: use struct method
func FindPkgs(ctx context.Context, pkgs []string) (map[string][]db.Package, []string, error) {
return GetInstance(ctx).FindPkgs(ctx, pkgs)
}
// =======================
// FOR LEGACY ONLY
// =======================
var (
reposInstance *Repos
alrConfigOnce sync.Once
)
// Deprecated: For legacy only
func GetInstance(ctx context.Context) *Repos {
alrConfigOnce.Do(func() {
cfg := config.GetInstance(ctx)
db := database.GetInstance(ctx)
reposInstance = New(
cfg,
db,
)
})
return reposInstance
}

83
pkg/repos/utils.go Normal file
View File

@ -0,0 +1,83 @@
package repos
import (
"context"
"io"
"path/filepath"
"reflect"
"strings"
"github.com/go-git/go-git/v5/plumbing/format/diff"
"mvdan.cc/sh/v3/interp"
"mvdan.cc/sh/v3/syntax"
"plemya-x.ru/alr/internal/db"
"plemya-x.ru/alr/internal/shutils/decoder"
"plemya-x.ru/alr/pkg/distro"
)
// isValid makes sure the path of the file being updated is valid.
// It checks to make sure the file is not within a nested directory
// and that it is called alr.sh.
func isValid(from, to diff.File) bool {
var path string
if from != nil {
path = from.Path()
}
if to != nil {
path = to.Path()
}
match, _ := filepath.Match("*/*.sh", path)
return match
}
func parseScript(ctx context.Context, parser *syntax.Parser, runner *interp.Runner, r io.ReadCloser, pkg *db.Package) error {
defer r.Close()
fl, err := parser.Parse(r, "alr.sh")
if err != nil {
return err
}
runner.Reset()
err = runner.Run(ctx, fl)
if err != nil {
return err
}
d := decoder.New(&distro.OSRelease{}, runner)
d.Overrides = false
d.LikeDistros = false
return d.DecodeVars(pkg)
}
var overridable = map[string]string{
"deps": "Depends",
"build_deps": "BuildDepends",
"desc": "Description",
"homepage": "Homepage",
"maintainer": "Maintainer",
}
func resolveOverrides(runner *interp.Runner, pkg *db.Package) {
pkgVal := reflect.ValueOf(pkg).Elem()
for name, val := range runner.Vars {
for prefix, field := range overridable {
if strings.HasPrefix(name, prefix) {
override := strings.TrimPrefix(name, prefix)
override = strings.TrimPrefix(override, "_")
field := pkgVal.FieldByName(field)
varVal := field.FieldByName("Val")
varType := varVal.Type()
switch varType.Elem().String() {
case "[]string":
varVal.SetMapIndex(reflect.ValueOf(override), reflect.ValueOf(val.List))
case "string":
varVal.SetMapIndex(reflect.ValueOf(override), reflect.ValueOf(val.Str))
}
break
}
}
}
}