lain/train-osource
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Compare commits

base: lain:main
Branches Tags
lain:main
lain:master
lain:1.0
..
compare: lain:1.0
Branches Tags
lain:main
lain:master
lain:1.0

No commits in common. "main" and "1.0" have entirely different histories.
main ... 1.0

13 changed files with 94 additions and 366 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -2,4 +2,3 @@ installed*
repo
train
pkg/*/*.save
train-pkg*

31
README.md
View File

@ -1,31 +0,0 @@
# Train
#### РЖД - Российские Железные Дороги
Сборка:
```
go mod tidy
go build -o train
```
Из бинарника в команды:
```
./train install-all
```
Дальше пропишите у себя в .*rc:
```
export PATH="$HOME/.rails/bin:$PATH"
export PATH="$HOME/.rails/installed_bins:$PATH"
```
И будет вам счастье
## Пока-что есть два пакета
* choochoo-build
* fastfetch/neofetch (later)
## Обновлятся вот так
```
train selfupd
```

11
cmd/root.go
View File

@ -1,21 +1,14 @@
package cmd
import (
"fmt"
"os"
"runtime"
"fmt"
"github.com/spf13/cobra"
)
var rootCmd = &cobra.Command{
Use: "train",
Short: "Train - Лёгкий пакетный менеджер",
PersistentPreRun: func(cmd *cobra.Command, args []string) {
if runtime.GOOS == "windows" {
fmt.Println("[WARNING] Train работает на Windows в режиме совместимости. Гарантий работы нет.")
}
},
Short: "Train - легковесный пакетный менеджер",
}
func Execute() {

63
cmd/selfupd.go
View File

@ -1,63 +0,0 @@
package cmd
import (
"fmt"
"io"
"os"
"train/pkg/autoupdate"
"github.com/spf13/cobra"
)
var selfupdCmd = &cobra.Command{
Use: "selfupd",
Short: "Обновляет текущий бинарник Train из исходников",
Run: func(cmd *cobra.Command, args []string) {
tarballURL := "https://git.iwakurahome.ru/lain/train-osource/archive/main.tar.gz"
fmt.Println("Обновление Train из исходников...")
tmpDir, newBinPath, err := autoupdate.BuildNewBinary(tarballURL)
if err != nil {
fmt.Printf("Ошибка сборки: %v\n", err)
os.Exit(1)
}
currentPath, err := os.Executable()
if err != nil {
fmt.Printf("Ошибка получения пути текущего бинарника: %v\n", err)
os.Exit(1)
}
fmt.Printf("Замена текущего бинарника (%s) на новый\n", currentPath)
if err := replaceBinary(newBinPath, currentPath); err != nil {
fmt.Printf("Ошибка обновления бинарника: %v\n", err)
os.Exit(1)
}
os.RemoveAll(tmpDir)
fmt.Println("Обновление успешно. Перезапустите Train.")
os.Exit(0)
},
}
func replaceBinary(newPath, currentPath string) error {
src, err := os.Open(newPath)
if err != nil {
return err
}
defer src.Close()
tmpPath := currentPath + ".new"
dst, err := os.Create(tmpPath)
if err != nil {
return err
}
defer dst.Close()
if _, err = io.Copy(dst, src); err != nil {
return err
}
if err = os.Chmod(tmpPath, 0755); err != nil {
return err
}
return os.Rename(tmpPath, currentPath)
}
func init() {
rootCmd.AddCommand(selfupdCmd)
}

20
cmd/version.go
View File

@ -1,20 +0,0 @@
package cmd
import (
"fmt"
"train/pkg/version"
"github.com/spf13/cobra"
)
var versionCmd = &cobra.Command{
Use: "version",
Short: "Выводит текущую версию Train",
Run: func(cmd *cobra.Command, args []string) {
fmt.Printf("Train version %s\n", version.CurrentVersion)
},
}
func init() {
rootCmd.AddCommand(versionCmd)
}

6
config.json
View File

@ -1,5 +1,5 @@
{
"repo": "https://xn--80abmlgju2eo3byb.xn--p1ai/repo/repo.json",
"repositories": [],
"packages": {}
"repositories": [
"https://xn--80abmlgju2eo3byb.xn--p1ai/sklad"
]
}

131
pkg/autoupdate/autoupdate.go
View File

@ -1,129 +1,58 @@
package autoupdate
import (
"archive/tar"
"compress/gzip"
"fmt"
"io"
"io/ioutil"
"net/http"
"os"
"os/exec"
"path/filepath"
)
func BuildNewBinary(tarballURL string) (buildDir string, newBinPath string, err error) {
fmt.Printf("Downloading tarball: %s\n", tarballURL)
resp, err := http.Get(tarballURL)
func CheckForUpdates(updateURL string) (bool, string, error) {
resp, err := http.Get(updateURL)
if err != nil {
return "", "", fmt.Errorf("failed to download tarball: %w", err)
return false, "", err
}
defer resp.Body.Close()
tmpTarball, err := ioutil.TempFile("", "source_*.tar.gz")
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return "", "", fmt.Errorf("failed to create temp file: %w", err)
return false, "", err
}
_, err = io.Copy(tmpTarball, resp.Body)
if err != nil {
tmpTarball.Close()
return "", "", fmt.Errorf("failed to write tarball: %w", err)
latestVersion := string(data)
currentVersion := "1.0.0"
if latestVersion != currentVersion {
return true, latestVersion, nil
}
tmpTarball.Close()
defer os.Remove(tmpTarball.Name())
tmpDir, err := ioutil.TempDir("", "build_")
if err != nil {
return "", "", fmt.Errorf("failed to create temp directory: %w", err)
}
fmt.Printf("Unpacking tarball to: %s\n", tmpDir)
if err := unpackTarball(tmpTarball.Name(), tmpDir); err != nil {
os.RemoveAll(tmpDir)
return "", "", fmt.Errorf("failed to unpack tarball: %w", err)
}
goModPath := filepath.Join(tmpDir, "go.mod")
if _, err := os.Stat(goModPath); os.IsNotExist(err) {
entries, err := ioutil.ReadDir(tmpDir)
if err != nil {
os.RemoveAll(tmpDir)
return "", "", fmt.Errorf("failed to list unpacked directory: %w", err)
}
var subDir string
count := 0
for _, entry := range entries {
if entry.IsDir() {
subDir = filepath.Join(tmpDir, entry.Name())
count++
}
}
if count == 1 {
goModPath = filepath.Join(subDir, "go.mod")
if _, err := os.Stat(goModPath); err != nil {
os.RemoveAll(tmpDir)
return "", "", fmt.Errorf("go.mod not found in subdirectory")
}
buildDir = subDir
} else {
os.RemoveAll(tmpDir)
return "", "", fmt.Errorf("go.mod not found in unpacked directory")
}
} else {
buildDir = tmpDir
}
newBinPath = filepath.Join(buildDir, "train")
fmt.Println("go.mod found, building using go build...")
cmd := exec.Command("go", "build", "-o", "train")
cmd.Dir = buildDir
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
os.RemoveAll(tmpDir)
return "", "", fmt.Errorf("go build failed: %w", err)
}
fmt.Println("Build completed successfully using go build")
return buildDir, newBinPath, nil
return false, currentVersion, nil
}
func unpackTarball(archivePath, destDir string) error {
f, err := os.Open(archivePath)
func AutoUpdate(updateURL string) error {
available, latest, err := CheckForUpdates(updateURL)
if err != nil {
return err
}
defer f.Close()
gzr, err := gzip.NewReader(f)
if err != nil {
return err
}
defer gzr.Close()
tr := tar.NewReader(gzr)
for {
header, err := tr.Next()
if err == io.EOF {
break
}
if available {
fmt.Printf("Доступна новая версия: %s. Запускаем обновление...\n", latest)
resp, err := http.Get(updateURL + "/binary") // предположим, что по этому URL лежит бинарник
if err != nil {
return err
}
target := filepath.Join(destDir, header.Name)
switch header.Typeflag {
case tar.TypeDir:
if err := os.MkdirAll(target, os.FileMode(header.Mode)); err != nil {
return err
}
case tar.TypeReg:
outFile, err := os.Create(target)
if err != nil {
return err
}
if _, err := io.Copy(outFile, tr); err != nil {
outFile.Close()
return err
}
outFile.Close()
defer resp.Body.Close()
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
tmpFile := "/tmp/train_new"
if err := ioutil.WriteFile(tmpFile, data, 0755); err != nil {
return err
}
cmd := exec.Command(tmpFile)
if err := cmd.Start(); err != nil {
return err
}
os.Exit(0)
} else {
fmt.Println("Обновлений не найдено.")
}
return nil
}

40
pkg/config/config.go
View File

@ -2,35 +2,33 @@ package config
import (
"encoding/json"
"errors"
"io/ioutil"
"os"
"path/filepath"
)
type Config struct {
Repo string `json:"repo"`
Repositories []string `json:"repositories"`
Packages map[string]string `json:"packages"`
}
"train/pkg/paths"
)
var configFile string
func init() {
home, err := os.UserHomeDir()
if err == nil {
railsConfig := filepath.Join(home, ".rails", "config", "config.json")
if _, err := os.Stat(railsConfig); err == nil {
configFile = railsConfig
return
}
railsConfig := filepath.Join(paths.BaseDir(), "config", "config.json")
if _, err := os.Stat(railsConfig); err == nil {
configFile = railsConfig
} else {
configFile = "./config.json"
}
configFile = "./config.json"
}
type Config struct {
Repositories []string `json:"repositories"`
Packages map[string]string `json:"packages"`
}
func LoadConfig() (*Config, error) {
if _, err := os.Stat(configFile); os.IsNotExist(err) {
cfg := &Config{
Repo: "",
Repositories: []string{},
Packages: make(map[string]string),
}
@ -65,7 +63,7 @@ func AddRepository(repo string) error {
}
for _, r := range cfg.Repositories {
if r == repo {
return nil
return errors.New("репозиторий уже добавлен")
}
}
cfg.Repositories = append(cfg.Repositories, repo)
@ -78,10 +76,16 @@ func RemoveRepository(repo string) error {
return err
}
newRepos := []string{}
found := false
for _, r := range cfg.Repositories {
if r != repo {
newRepos = append(newRepos, r)
if r == repo {
found = true
continue
}
newRepos = append(newRepos, r)
}
if !found {
return errors.New("репозиторий не найден")
}
cfg.Repositories = newRepos
return SaveConfig(cfg)

80
pkg/installer/installer.go
View File

@ -26,14 +26,8 @@ var (
buildInstallDir = filepath.Join(paths.BaseDir(), "installed_packages")
)
func logInfo(format string, args ...interface{}) {
msg := fmt.Sprintf(format, args...)
fmt.Printf("\033[32m==>\033[0m %s\n", msg)
}
func logTrain(format string, args ...interface{}) {
msg := fmt.Sprintf(format, args...)
fmt.Printf("\U0001F682 %s\n", msg)
func logMessage(msg string) {
fmt.Println(msg)
}
func computeChecksum(filePath string) (string, error) {
@ -46,7 +40,7 @@ func computeChecksum(filePath string) (string, error) {
}
func downloadFile(url string) (string, error) {
logInfo("Downloading %s", url)
logMessage("Downloading " + url + "...")
resp, err := http.Get(url)
if err != nil {
return "", err
@ -58,17 +52,16 @@ func downloadFile(url string) (string, error) {
}
_, err = io.Copy(tmpFile, resp.Body)
if err != nil {
tmpFile.Close()
return "", err
}
tmpFile.Close()
logInfo("File downloaded to temporary location")
logMessage("File downloaded to temporary location")
return tmpFile.Name(), nil
}
func unpackPackage(filePath, packageName string) error {
logInfo("Unpacking package into %s", filepath.Join(buildInstallDir, packageName))
destDir := filepath.Join(buildInstallDir, packageName)
logMessage("Unpacking package into " + destDir)
if err := os.MkdirAll(destDir, os.ModePerm); err != nil {
return err
}
@ -109,27 +102,28 @@ func unpackPackage(filePath, packageName string) error {
outFile.Close()
}
}
logInfo("Unpacking completed")
logMessage("Unpacking completed")
return nil
}
func executeBuildCommands(commands []string, packageName string) error {
packagePath := filepath.Join(buildInstallDir, packageName)
for _, commandStr := range commands {
logInfo("Executing build command: %s", commandStr)
logMessage("Executing build command: " + commandStr)
cmd := exec.Command("sh", "-c", commandStr)
cmd.Dir = packagePath
output, err := cmd.CombinedOutput()
if err != nil {
return fmt.Errorf("command '%s' failed: %s", commandStr, string(output))
}
logMessage("Command output: " + string(output))
}
return nil
}
func saveInstalledPackage(name string, m *manifest.Manifest) error {
logInfo("Saving manifest to %s", filepath.Join(buildInstallDir, name))
packagePath := filepath.Join(buildInstallDir, name)
logMessage("Saving manifest to " + packagePath)
if err := os.MkdirAll(packagePath, os.ModePerm); err != nil {
return err
}
@ -141,29 +135,29 @@ func saveInstalledPackage(name string, m *manifest.Manifest) error {
}
func InstallPackage(name string) error {
logTrain("Installing package: %s", name)
logMessage("Fetching manifest for package " + name)
m, err := manifest.FetchManifest(name)
if err != nil {
return fmt.Errorf("failed to fetch manifest: %w", err)
}
if strings.ToLower(m.Mode) == "bin" {
logInfo("Installing in binary mode")
logMessage("Installing in binary mode")
platformKey := runtime.GOOS + "_" + runtime.GOARCH
binaryInfo, ok := m.Binaries[platformKey]
binaryURL, ok := m.Binaries[platformKey]
if !ok {
return fmt.Errorf("no binary available for platform %s", platformKey)
}
packageFile, err := downloadFile(binaryInfo.URL)
packageFile, err := downloadFile(binaryURL)
if err != nil {
return fmt.Errorf("failed to download binary: %w", err)
}
defer os.Remove(packageFile)
computedChecksum, err := computeChecksum(packageFile)
checksum, err := computeChecksum(packageFile)
if err != nil {
return fmt.Errorf("failed to compute checksum: %w", err)
}
if computedChecksum != binaryInfo.Checksum {
return fmt.Errorf("checksum mismatch: expected %s, got %s", binaryInfo.Checksum, computedChecksum)
if checksum != m.Checksum {
return fmt.Errorf("checksum mismatch: expected %s, got %s", m.Checksum, checksum)
}
if err := os.MkdirAll(binInstallDir, os.ModePerm); err != nil {
return err
@ -176,22 +170,21 @@ func InstallPackage(name string) error {
if err := ioutil.WriteFile(destPath, data, 0755); err != nil {
return err
}
logInfo("Binary package %s installed in %s", m.Name, destPath)
logTrain("Package %s successfully installed.", m.Name)
logMessage("Binary package " + m.Name + " installed to " + destPath)
return nil
} else if strings.ToLower(m.Mode) == "build" {
logInfo("Installing in build mode")
logMessage("Installing in build mode")
packageFile, err := downloadFile(m.Source)
if err != nil {
return fmt.Errorf("failed to download package: %w", err)
}
defer os.Remove(packageFile)
computedChecksum, err := computeChecksum(packageFile)
checksum, err := computeChecksum(packageFile)
if err != nil {
return fmt.Errorf("failed to compute checksum: %w", err)
}
if computedChecksum != m.Checksum {
return fmt.Errorf("checksum mismatch: expected %s, got %s", m.Checksum, computedChecksum)
if checksum != m.Checksum {
return fmt.Errorf("checksum mismatch: expected %s, got %s", m.Checksum, checksum)
}
if err := unpackPackage(packageFile, name); err != nil {
return fmt.Errorf("failed to unpack package: %w", err)
@ -204,53 +197,34 @@ func InstallPackage(name string) error {
if err := saveInstalledPackage(name, m); err != nil {
return fmt.Errorf("failed to save manifest: %w", err)
}
logTrain("Build package %s installed successfully.", m.Name)
logMessage("Build package " + m.Name + " installed successfully")
return nil
}
return errors.New("unknown package mode")
}
func RemovePackage(name string) error {
logTrain("Removing package: %s", name)
packagePath := filepath.Join(buildInstallDir, name)
logMessage("Removing package " + name + " from " + packagePath)
if _, err := os.Stat(packagePath); os.IsNotExist(err) {
return errors.New("package not found")
}
manifestPath := filepath.Join(packagePath, "manifest.json")
data, err := ioutil.ReadFile(manifestPath)
if err == nil {
var m manifest.Manifest
if err := json.Unmarshal(data, &m); err == nil {
if len(m.Uninstall) > 0 {
for _, cmdStr := range m.Uninstall {
logInfo("Executing uninstall command: %s", cmdStr)
cmd := exec.Command("sh", "-c", cmdStr)
cmd.Dir = packagePath
output, err := cmd.CombinedOutput()
if err != nil {
return fmt.Errorf("uninstall command '%s' failed: %s", cmdStr, string(output))
}
}
}
}
}
logInfo("Removing directory %s", packagePath)
if err := os.RemoveAll(packagePath); err != nil {
return fmt.Errorf("failed to remove package: %w", err)
}
logTrain("Package %s removed.", name)
logMessage("Package " + name + " removed successfully")
return nil
}
func UpdatePackage(name string) error {
logTrain("Updating package: %s", name)
logMessage("Updating package " + name)
if err := RemovePackage(name); err != nil {
return fmt.Errorf("failed to remove package for update: %w", err)
}
if err := InstallPackage(name); err != nil {
return fmt.Errorf("failed to install package: %w", err)
return fmt.Errorf("failed to install package during update: %w", err)
}
logTrain("Package %s updated successfully.", name)
logMessage("Package " + name + " updated successfully")
return nil
}

BIN
pkg/manifest/.DS_Store vendored
View File

Binary file not shown.

32
pkg/manifest/manifest.go
View File

@ -9,21 +9,15 @@ import (
"train/pkg/config"
)
type BinaryInfo struct {
URL string `json:"url"`
Checksum string `json:"checksum"`
}
type Manifest struct {
Name string `json:"name"`
Version string `json:"version"`
Mode string `json:"mode"`
Source string `json:"source"`
Checksum string `json:"checksum"`
Dependencies []string `json:"dependencies"`
Build []string `json:"build"`
Binaries map[string]BinaryInfo `json:"binaries"`
Uninstall []string `json:"uninstall"`
Name string `json:"name"`
Version string `json:"version"`
Mode string `json:"mode"`
Source string `json:"source"`
Checksum string `json:"checksum"`
Dependencies []string `json:"dependencies"`
Build []string `json:"build"`
Binaries map[string]string `json:"binaries"`
}
func FetchManifest(name string) (*Manifest, error) {
@ -31,12 +25,6 @@ func FetchManifest(name string) (*Manifest, error) {
if err != nil {
return nil, err
}
if cfg.Repo != "" {
m, err := FetchManifestFromRepo(cfg.Repo, name)
if err == nil {
return m, nil
}
}
if url, ok := cfg.Packages[name]; ok {
return fetchManifestFromURL(url)
}
@ -50,7 +38,7 @@ func FetchManifest(name string) (*Manifest, error) {
lastErr = err
}
if lastErr == nil {
lastErr = errors.New("no repository found")
lastErr = errors.New("не найден ни один репозиторий")
}
return nil, lastErr
}
@ -62,7 +50,7 @@ func fetchManifestFromURL(url string) (*Manifest, error) {
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, errors.New("manifest not found at " + url)
return nil, errors.New("манифест пакета не найден по ссылке " + url)
}
data, err := ioutil.ReadAll(resp.Body)
if err != nil {

42
pkg/manifest/repo.go
View File

@ -1,42 +0,0 @@
package manifest
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
type RepoPackage struct {
Name string `json:"name"`
Manifest string `json:"manifest"`
}
type RepoFile struct {
Packages []RepoPackage `json:"packages"`
}
func FetchManifestFromRepo(repoURL, pkgName string) (*Manifest, error) {
resp, err := http.Get(repoURL)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, fmt.Errorf("repo file not found at %s", repoURL)
}
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
var rf RepoFile
if err := json.Unmarshal(data, &rf); err != nil {
return nil, err
}
for _, rp := range rf.Packages {
if rp.Name == pkgName {
return fetchManifestFromURL(rp.Manifest)
}
}
return nil, fmt.Errorf("package %s not found in repo", pkgName)
}

3
pkg/version/current.go
View File

@ -1,3 +0,0 @@
package version
const CurrentVersion = "1.1"