feat(install): консольный установщик bj и первичная настройка по одноразовому коду
- cmd/bj-installer (вместо веб-мастера): проверка Debian 13 / Astra, пакеты, пользователь и каталоги, активация лицензии ключом продукта, PostgreSQL и миграции m2m_core, компоненты по лицензии с проверкой подписи, root-скрипты и службы, одноразовый код и итоговый экран с адресом http://<сервер>:8080/first-run; проверка в песочнице (--steps, --root) - bj: /first-run — пока нет пользователей и установщик оставил код, по коду создаётся первый администратор (прежние установки без файла работают как раньше) - internal/release/install.go — общая установка компонентов (bj-component-install и установщик); bj-component-install стал компонентом ядра - открытые ключи вынесены в internal/license и internal/release; миграции и файлы развёртывания встроены (migrations/embed.go, deploy/embed.go); unit bj-server исправлен - scripts/build-release.sh: сборка с версиями, подпись, публикация на сервер обновлений Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
zuevav
+826
-82
@@ -1,111 +1,855 @@
|
||||
// Package main — bj-installer.
|
||||
// Command bj-installer — установка bj на Debian 13 или Astra Linux.
|
||||
//
|
||||
// Web-инсталлятор для bj-server: на машине клиента после установки
|
||||
// Debian/Astra поднимает локальный HTTP на 127.0.0.1:8181, проводит
|
||||
// через 5-страничный wizard (welcome → precheck → config → install → done)
|
||||
// и за кадром выполняет 20+ шагов установки Валидаты + bj-server + ИШ.
|
||||
// curl -fsSL https://lic.zetit.ru/install.sh | sudo bash -s -- КЛЮЧ-ПРОДУКТА
|
||||
// sudo bj-installer install --code BJ-XXXX-XXXX-XXXX [--server https://lic.zetit.ru] [--channel stable]
|
||||
// sudo bj-installer install --dry-run только проверка системы, без изменений
|
||||
// sudo bj-installer first-run-code новый одноразовый код первичной настройки
|
||||
// bj-installer version
|
||||
//
|
||||
// Прогресс шагов прилетает в UI через Server-Sent Events. Каждый шаг
|
||||
// идемпотентен — можно повторно запускать инсталлятор на уже настроенной
|
||||
// машине, он пропустит то, что сделано.
|
||||
// Установка идёт в консоли, без графической среды: проверка системы, пакеты, пользователь и каталоги,
|
||||
// активация лицензии, база PostgreSQL, компоненты bj по лицензии (подпись релиза и контрольные суммы
|
||||
// проверяются), root-скрипты и службы. В конце на экране — адрес первичной настройки и одноразовый код:
|
||||
// дальше настройка в браузере, в самом bj.
|
||||
//
|
||||
// Запуск: sudo ./bj-installer [--addr 127.0.0.1:8181] [--no-browser]
|
||||
// Артефакты ожидаются рядом с бинарём в каталоге ./artifacts/:
|
||||
//
|
||||
// artifacts/ClientL_Other/zpki-*.deb
|
||||
// artifacts/ClientL_Other/zsdk-*.deb
|
||||
// artifacts/bj-server (Go-бинарь)
|
||||
// artifacts/crypto-service.jar (Java-сайдкар)
|
||||
// artifacts/ish/igate_*.deb (ИШ НРД)
|
||||
// Проверка без чистого сервера: --steps license,components --root /tmp/песочница --server http://127.0.0.1:18091
|
||||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"log"
|
||||
"io"
|
||||
"io/fs"
|
||||
"math/big"
|
||||
"net"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/exec"
|
||||
"os/signal"
|
||||
"os/user"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"golang.org/x/crypto/bcrypt"
|
||||
|
||||
"git.zetit.ru/zuevav/Bridge-and-Join-s/deploy"
|
||||
"git.zetit.ru/zuevav/Bridge-and-Join-s/internal/license"
|
||||
"git.zetit.ru/zuevav/Bridge-and-Join-s/internal/release"
|
||||
"git.zetit.ru/zuevav/Bridge-and-Join-s/migrations"
|
||||
)
|
||||
|
||||
const banner = `
|
||||
======================================================================
|
||||
bj-installer — мастер установки Bridge-and-Join-s
|
||||
======================================================================
|
||||
`
|
||||
// installerVersion — версия установщика (go build -ldflags "-X main.installerVersion=…").
|
||||
var installerVersion = "0.1.0"
|
||||
|
||||
func main() {
|
||||
addr := flag.String("addr", "127.0.0.1:8181", "адрес web-инсталлятора")
|
||||
noBrowser := flag.Bool("no-browser", false, "не пытаться открыть браузер автоматически")
|
||||
artifactsDir := flag.String("artifacts", "./artifacts", "каталог с дистрибутивами (Validata deb, bj-server, ish)")
|
||||
flag.Parse()
|
||||
const (
|
||||
setupFile = "/var/lib/bj/.bj/setup.json"
|
||||
usersFile = "/var/lib/bj/.bj/users.json"
|
||||
firstRunFile = "/var/lib/bj/.bj/first-run.json"
|
||||
bjPort = 8080
|
||||
)
|
||||
|
||||
if os.Geteuid() != 0 {
|
||||
fmt.Fprintln(os.Stderr, "Установщик должен быть запущен от root (sudo).")
|
||||
os.Exit(1)
|
||||
}
|
||||
type installer struct {
|
||||
server, channel, code string
|
||||
root string // префикс файловой системы (песочница)
|
||||
dryRun bool
|
||||
steps map[string]bool
|
||||
out *console
|
||||
|
||||
fmt.Print(banner)
|
||||
fmt.Printf(" адрес: http://%s\n", *addr)
|
||||
fmt.Printf(" артефакты: %s\n", *artifactsDir)
|
||||
fmt.Println("======================================================================")
|
||||
|
||||
st := newState(*artifactsDir)
|
||||
|
||||
srv := newServer(st)
|
||||
httpSrv := &http.Server{
|
||||
Addr: *addr,
|
||||
Handler: srv,
|
||||
ReadHeaderTimeout: 10 * time.Second,
|
||||
}
|
||||
|
||||
// SIGINT/SIGTERM → корректный shutdown
|
||||
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
|
||||
defer stop()
|
||||
|
||||
go func() {
|
||||
if err := httpSrv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
|
||||
log.Fatalf("HTTP-сервер упал: %v", err)
|
||||
}
|
||||
}()
|
||||
|
||||
url := "http://" + *addr
|
||||
log.Printf("Откройте в браузере: %s", url)
|
||||
if !*noBrowser {
|
||||
tryOpenBrowser(url)
|
||||
}
|
||||
|
||||
<-ctx.Done()
|
||||
log.Println("Завершаем работу...")
|
||||
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
_ = httpSrv.Shutdown(shutdownCtx)
|
||||
token string
|
||||
lic *license.License
|
||||
setupCode string // одноразовый код первичной настройки (итоговый экран)
|
||||
shown bool
|
||||
}
|
||||
|
||||
// tryOpenBrowser — без фанатизма. Если xdg-open/sensible-browser есть и
|
||||
// $DISPLAY поднят (xrdp, Fly DE) — откроем. Иначе пользователь увидит URL
|
||||
// в выводе и перейдёт сам с другого компа (типичный сценарий headless).
|
||||
func tryOpenBrowser(url string) {
|
||||
if os.Getenv("DISPLAY") == "" && os.Getenv("WAYLAND_DISPLAY") == "" {
|
||||
return
|
||||
func main() {
|
||||
if len(os.Args) < 2 {
|
||||
usage()
|
||||
}
|
||||
var bin string
|
||||
switch runtime.GOOS {
|
||||
case "linux":
|
||||
for _, cand := range []string{"xdg-open", "sensible-browser", "x-www-browser"} {
|
||||
if p, err := exec.LookPath(cand); err == nil {
|
||||
bin = p
|
||||
break
|
||||
switch os.Args[1] {
|
||||
case "install":
|
||||
cmdInstall(os.Args[2:])
|
||||
case "first-run-code":
|
||||
cmdFirstRunCode(os.Args[2:])
|
||||
case "version":
|
||||
fmt.Println("bj-installer", installerVersion)
|
||||
default:
|
||||
usage()
|
||||
}
|
||||
}
|
||||
|
||||
func usage() {
|
||||
fmt.Fprintln(os.Stderr, "bj-installer install --code BJ-XXXX-XXXX-XXXX [--server https://lic.zetit.ru] [--channel stable] [--dry-run]")
|
||||
fmt.Fprintln(os.Stderr, "bj-installer first-run-code")
|
||||
fmt.Fprintln(os.Stderr, "bj-installer version")
|
||||
os.Exit(2)
|
||||
}
|
||||
|
||||
func cmdInstall(args []string) {
|
||||
fl := flag.NewFlagSet("install", flag.ExitOnError)
|
||||
in := &installer{out: newConsole()}
|
||||
fl.StringVar(&in.code, "code", "", "ключ продукта (код активации)")
|
||||
fl.StringVar(&in.server, "server", "https://lic.zetit.ru", "сервер лицензий и обновлений")
|
||||
fl.StringVar(&in.channel, "channel", "stable", "канал обновлений")
|
||||
fl.BoolVar(&in.dryRun, "dry-run", false, "только проверить систему")
|
||||
stepsFlag := fl.String("steps", "", "только эти шаги через запятую (для проверки): precheck,packages,system,license,database,components,services,firstrun")
|
||||
fl.StringVar(&in.root, "root", "", "корень файловой системы для проверки в песочнице")
|
||||
_ = fl.Parse(args)
|
||||
in.server = strings.TrimRight(in.server, "/")
|
||||
if *stepsFlag != "" {
|
||||
in.steps = map[string]bool{}
|
||||
for _, s := range strings.Split(*stepsFlag, ",") {
|
||||
in.steps[strings.TrimSpace(s)] = true
|
||||
}
|
||||
}
|
||||
in.out.banner()
|
||||
if err := in.run(); err != nil {
|
||||
in.out.failure(err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
// P — путь с учётом песочницы.
|
||||
func (in *installer) P(path string) string {
|
||||
if in.root == "" {
|
||||
return path
|
||||
}
|
||||
return filepath.Join(in.root, path)
|
||||
}
|
||||
|
||||
type step struct {
|
||||
id, title string
|
||||
run func() (string, error)
|
||||
}
|
||||
|
||||
func (in *installer) run() error {
|
||||
if in.root == "" && !in.dryRun && os.Geteuid() != 0 {
|
||||
return errors.New("установщик запускается от root: sudo bj-installer install …")
|
||||
}
|
||||
if !in.dryRun && in.steps == nil && strings.TrimSpace(in.code) == "" {
|
||||
return errors.New("не указан ключ продукта: bj-installer install --code BJ-XXXX-XXXX-XXXX (он есть в портале клиента https://lic.zetit.ru/portal/)")
|
||||
}
|
||||
all := []step{
|
||||
{"precheck", "Проверка системы", in.stepPrecheck},
|
||||
{"packages", "Системные пакеты", in.stepPackages},
|
||||
{"system", "Пользователь bj и каталоги", in.stepSystem},
|
||||
{"license", "Активация лицензии", in.stepLicense},
|
||||
{"database", "База данных PostgreSQL", in.stepDatabase},
|
||||
{"components", "Компоненты bj по лицензии", in.stepComponents},
|
||||
{"services", "Скрипты и службы", in.stepServices},
|
||||
{"firstrun", "Запуск и код первичной настройки", in.stepFirstRun},
|
||||
}
|
||||
var todo []step
|
||||
for _, s := range all {
|
||||
switch {
|
||||
case in.dryRun && s.id != "precheck":
|
||||
case in.steps != nil && !in.steps[s.id]:
|
||||
default:
|
||||
todo = append(todo, s)
|
||||
}
|
||||
}
|
||||
for i, s := range todo {
|
||||
in.out.step(i+1, len(todo), s.title)
|
||||
detail, err := s.run()
|
||||
if err != nil {
|
||||
in.out.stepFail()
|
||||
return fmt.Errorf("%s: %w", s.title, err)
|
||||
}
|
||||
in.out.stepOK(detail)
|
||||
}
|
||||
if in.dryRun {
|
||||
in.out.note("Проверка пройдена. Для установки запустите без --dry-run и с ключом продукта.")
|
||||
}
|
||||
if in.shown {
|
||||
in.out.done(in.setupCode, in.lic)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ---- шаги ----
|
||||
|
||||
func osRelease() map[string]string {
|
||||
m := map[string]string{}
|
||||
b, err := os.ReadFile("/etc/os-release")
|
||||
if err != nil {
|
||||
return m
|
||||
}
|
||||
for _, line := range strings.Split(string(b), "\n") {
|
||||
k, v, ok := strings.Cut(line, "=")
|
||||
if ok {
|
||||
m[k] = strings.Trim(v, `"`)
|
||||
}
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
func (in *installer) stepPrecheck() (string, error) {
|
||||
osr := osRelease()
|
||||
id, ver, like := osr["ID"], osr["VERSION_ID"], osr["ID_LIKE"]
|
||||
name := pick(osr["PRETTY_NAME"], id+" "+ver)
|
||||
switch {
|
||||
case id == "debian" && strings.HasPrefix(ver, "13"):
|
||||
case id == "astra" || strings.Contains(like, "astra") || strings.Contains(strings.ToLower(name), "astra"):
|
||||
default:
|
||||
return "", fmt.Errorf("поддерживаются Debian 13 и Astra Linux, а на сервере %s", name)
|
||||
}
|
||||
if runtime.GOARCH != "amd64" {
|
||||
return "", fmt.Errorf("нужна архитектура x86_64, а на сервере %s", runtime.GOARCH)
|
||||
}
|
||||
if _, err := os.Stat("/run/systemd/system"); err != nil {
|
||||
return "", errors.New("systemd не запущен")
|
||||
}
|
||||
var st syscall.Statfs_t
|
||||
if err := syscall.Statfs("/", &st); err == nil {
|
||||
if free := st.Bavail * uint64(st.Bsize); free < 10<<30 {
|
||||
return "", fmt.Errorf("на диске свободно %.1f ГБ, нужно не меньше 10 ГБ", float64(free)/(1<<30))
|
||||
}
|
||||
}
|
||||
mem := memTotal()
|
||||
if mem > 0 && mem < 1800<<20 {
|
||||
return "", fmt.Errorf("памяти %.1f ГБ, нужно не меньше 2 ГБ", float64(mem)/(1<<30))
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
||||
defer cancel()
|
||||
req, _ := http.NewRequestWithContext(ctx, http.MethodGet, in.server+"/healthz", nil)
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("нет связи с %s: %v", in.server, err)
|
||||
}
|
||||
resp.Body.Close()
|
||||
return fmt.Sprintf("%s, %.1f ГБ памяти, связь с сервером лицензий есть", name, float64(mem)/(1<<30)), nil
|
||||
}
|
||||
|
||||
func memTotal() uint64 {
|
||||
b, err := os.ReadFile("/proc/meminfo")
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
for _, line := range strings.Split(string(b), "\n") {
|
||||
if strings.HasPrefix(line, "MemTotal:") {
|
||||
f := strings.Fields(line)
|
||||
if len(f) >= 2 {
|
||||
kb, _ := strconv.ParseUint(f[1], 10, 64)
|
||||
return kb << 10
|
||||
}
|
||||
}
|
||||
}
|
||||
if bin == "" {
|
||||
return 0
|
||||
}
|
||||
|
||||
func (in *installer) stepPackages() (string, error) {
|
||||
pkgs := []string{"ca-certificates", "curl", "postgresql", "postgresql-client", "default-jre-headless", "pcscd", "python3"}
|
||||
env := append(os.Environ(), "DEBIAN_FRONTEND=noninteractive")
|
||||
if out, err := runEnv(env, "apt-get", "update", "-qq"); err != nil {
|
||||
return "", fmt.Errorf("apt-get update: %v\n%s", err, tail(out, 8))
|
||||
}
|
||||
args := append([]string{"install", "-y", "-qq", "--no-install-recommends"}, pkgs...)
|
||||
if out, err := runEnv(env, "apt-get", args...); err != nil {
|
||||
return "", fmt.Errorf("apt-get install: %v\n%s", err, tail(out, 12))
|
||||
}
|
||||
return strings.Join(pkgs, ", "), nil
|
||||
}
|
||||
|
||||
func (in *installer) stepSystem() (string, error) {
|
||||
if in.root == "" {
|
||||
if _, err := user.Lookup("bj"); err != nil {
|
||||
if out, err := run("useradd", "--system", "--home-dir", "/var/lib/bj", "--no-create-home", "--shell", "/usr/sbin/nologin", "bj"); err != nil {
|
||||
return "", fmt.Errorf("useradd: %v %s", err, out)
|
||||
}
|
||||
}
|
||||
}
|
||||
dirs := []struct {
|
||||
path string
|
||||
mode os.FileMode
|
||||
bjOwn bool
|
||||
}{
|
||||
{"/opt/bj", 0o755, false}, {"/etc/bj", 0o755, false},
|
||||
{"/var/lib/bj", 0o750, true}, {"/var/lib/bj/.bj", 0o700, true}, {"/var/log/bj", 0o750, true},
|
||||
{"/var/lib/bj/keymedia-requests", 0o770, true}, {"/var/lib/bj/update-staging", 0o750, true},
|
||||
}
|
||||
for _, d := range dirs {
|
||||
if err := os.MkdirAll(in.P(d.path), d.mode); err != nil {
|
||||
return "", err
|
||||
}
|
||||
_ = os.Chmod(in.P(d.path), d.mode)
|
||||
if d.bjOwn {
|
||||
in.chownBJ(in.P(d.path))
|
||||
}
|
||||
}
|
||||
return "пользователь bj, /opt/bj, /var/lib/bj, /var/log/bj", nil
|
||||
}
|
||||
|
||||
func (in *installer) chownBJ(path string) {
|
||||
if in.root != "" {
|
||||
return
|
||||
}
|
||||
_ = exec.Command(bin, url).Start()
|
||||
u, err := user.Lookup("bj")
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
uid, _ := strconv.Atoi(u.Uid)
|
||||
gid, _ := strconv.Atoi(u.Gid)
|
||||
_ = os.Chown(path, uid, gid)
|
||||
}
|
||||
|
||||
// ---- настройки bj (setup.json) ----
|
||||
|
||||
func (in *installer) loadSetup() map[string]any {
|
||||
m := map[string]any{}
|
||||
if b, err := os.ReadFile(in.P(setupFile)); err == nil {
|
||||
_ = json.Unmarshal(b, &m)
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
func (in *installer) saveSetup(m map[string]any) error {
|
||||
b, err := json.MarshalIndent(m, "", " ")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
p := in.P(setupFile)
|
||||
if err := os.MkdirAll(filepath.Dir(p), 0o700); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.WriteFile(p+".tmp", b, 0o600); err != nil {
|
||||
return err
|
||||
}
|
||||
in.chownBJ(p + ".tmp")
|
||||
return os.Rename(p+".tmp", p)
|
||||
}
|
||||
|
||||
func section(m map[string]any, key string) map[string]any {
|
||||
if s, ok := m[key].(map[string]any); ok {
|
||||
return s
|
||||
}
|
||||
s := map[string]any{}
|
||||
m[key] = s
|
||||
return s
|
||||
}
|
||||
|
||||
func newUUID() string {
|
||||
b := make([]byte, 16)
|
||||
_, _ = rand.Read(b)
|
||||
b[6] = b[6]&0x0f | 0x40
|
||||
b[8] = b[8]&0x3f | 0x80
|
||||
h := hex.EncodeToString(b)
|
||||
return h[0:8] + "-" + h[8:12] + "-" + h[12:16] + "-" + h[16:20] + "-" + h[20:]
|
||||
}
|
||||
|
||||
func machineHash() string {
|
||||
b, err := os.ReadFile("/etc/machine-id")
|
||||
if err != nil || strings.TrimSpace(string(b)) == "" {
|
||||
return ""
|
||||
}
|
||||
sum := sha256.Sum256([]byte(strings.TrimSpace(string(b))))
|
||||
return hex.EncodeToString(sum[:])
|
||||
}
|
||||
|
||||
func (in *installer) stepLicense() (string, error) {
|
||||
setup := in.loadSetup()
|
||||
lic := section(setup, "license")
|
||||
installID, _ := lic["install_id"].(string)
|
||||
if len(installID) != 36 {
|
||||
installID = newUUID()
|
||||
}
|
||||
host, _ := os.Hostname()
|
||||
body, _ := json.Marshal(map[string]string{"code": strings.TrimSpace(in.code), "install_id": installID,
|
||||
"hostname": host, "version": "bj-installer " + installerVersion, "machine": machineHash()})
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
defer cancel()
|
||||
req, _ := http.NewRequestWithContext(ctx, http.MethodPost, in.server+"/v1/activate", bytes.NewReader(body))
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("сервер лицензий недоступен: %v", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
|
||||
var reply struct {
|
||||
Token string `json:"token"`
|
||||
Tenant string `json:"tenant"`
|
||||
Message string `json:"message"`
|
||||
}
|
||||
_ = json.Unmarshal(raw, &reply)
|
||||
if resp.StatusCode != http.StatusOK || reply.Token == "" {
|
||||
return "", fmt.Errorf("ключ продукта не принят: %s", pick(reply.Message, fmt.Sprintf("HTTP %d", resp.StatusCode)))
|
||||
}
|
||||
pub, err := license.ParsePublicKey(license.DefaultPublicKey)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
tok, err := license.DecodeToken(reply.Token)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
l, err := license.Verify(tok, pub)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("сервер вернул недействительный ключ: %v", err)
|
||||
}
|
||||
if !strings.EqualFold(l.InstallID, installID) {
|
||||
return "", errors.New("сервер вернул ключ для другой установки")
|
||||
}
|
||||
in.token, in.lic = reply.Token, l
|
||||
now := time.Now().UTC()
|
||||
lic["key"], lic["install_id"] = reply.Token, installID
|
||||
lic["last_sync"], lic["last_attempt"], lic["last_ok"] = now, now, true
|
||||
lic["last_msg"] = "активирована установщиком: ключ до " + l.ExpiresAt.Local().Format("02.01.2006")
|
||||
if err := in.saveSetup(setup); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return fmt.Sprintf("%s, план %s, модули: %s", pick(reply.Tenant, l.Tenant), l.Plan, featuresText(l)), nil
|
||||
}
|
||||
|
||||
func featuresText(l *license.License) string {
|
||||
if l.Plan == license.PlanEnterprise {
|
||||
return "все"
|
||||
}
|
||||
if len(l.Features) == 0 {
|
||||
return "только ядро"
|
||||
}
|
||||
return strings.Join(l.Features, ", ")
|
||||
}
|
||||
|
||||
// ensureToken — ключ из настроек, если шаг активации в этом запуске не выполнялся.
|
||||
func (in *installer) ensureToken() error {
|
||||
if in.token != "" {
|
||||
return nil
|
||||
}
|
||||
key, _ := section(in.loadSetup(), "license")["key"].(string)
|
||||
if key == "" {
|
||||
return errors.New("лицензия не активирована: запустите установку с ключом продукта")
|
||||
}
|
||||
pub, _ := license.ParsePublicKey(license.DefaultPublicKey)
|
||||
tok, err := license.DecodeToken(key)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
l, err := license.Verify(tok, pub)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
in.token, in.lic = key, l
|
||||
return nil
|
||||
}
|
||||
|
||||
func (in *installer) stepDatabase() (string, error) {
|
||||
setup := in.loadSetup()
|
||||
pg := section(setup, "postgres")
|
||||
if dsn, _ := pg["dsn"].(string); dsn != "" {
|
||||
if err := applyMigrations(dsn); err == nil {
|
||||
return "база уже настроена, схема обновлена", nil
|
||||
}
|
||||
}
|
||||
if out, err := run("systemctl", "enable", "--now", "postgresql"); err != nil {
|
||||
return "", fmt.Errorf("запуск PostgreSQL: %v %s", err, out)
|
||||
}
|
||||
if err := waitFor(60*time.Second, func() bool { _, err := psqlAdmin("SELECT 1"); return err == nil }); err != nil {
|
||||
return "", errors.New("PostgreSQL не отвечает")
|
||||
}
|
||||
pw := randomString(28)
|
||||
exists, _ := psqlAdmin("SELECT 1 FROM pg_roles WHERE rolname='bj'")
|
||||
verb := "CREATE ROLE"
|
||||
if strings.TrimSpace(exists) == "1" {
|
||||
verb = "ALTER ROLE"
|
||||
}
|
||||
if _, err := psqlAdmin(verb + " bj WITH LOGIN PASSWORD '" + pw + "'"); err != nil {
|
||||
return "", fmt.Errorf("роль bj: %v", err)
|
||||
}
|
||||
if db, _ := psqlAdmin("SELECT 1 FROM pg_database WHERE datname='bj'"); strings.TrimSpace(db) != "1" {
|
||||
if _, err := psqlAdmin("CREATE DATABASE bj OWNER bj"); err != nil {
|
||||
return "", fmt.Errorf("база bj: %v", err)
|
||||
}
|
||||
}
|
||||
dsn := "postgres://bj:" + pw + "@127.0.0.1:5432/bj?sslmode=disable"
|
||||
if err := applyMigrations(dsn); err != nil {
|
||||
return "", err
|
||||
}
|
||||
pg["dsn"] = dsn
|
||||
if err := in.saveSetup(setup); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return "база bj, пользователь bj, схема m2m_core", nil
|
||||
}
|
||||
|
||||
func psqlAdmin(sql string) (string, error) {
|
||||
return run("runuser", "-u", "postgres", "--", "psql", "-X", "-tAq", "-v", "ON_ERROR_STOP=1", "-c", sql)
|
||||
}
|
||||
|
||||
func applyMigrations(dsn string) error {
|
||||
names, err := fs.Glob(migrations.M2MCore, "m2m-core/*.sql")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sort.Strings(names)
|
||||
for _, n := range names {
|
||||
sqlText, _ := migrations.M2MCore.ReadFile(n)
|
||||
cmd := exec.Command("psql", "-X", "-q", "-v", "ON_ERROR_STOP=1", dsn)
|
||||
cmd.Stdin = bytes.NewReader(sqlText)
|
||||
if out, err := cmd.CombinedOutput(); err != nil {
|
||||
return fmt.Errorf("миграция %s: %v\n%s", filepath.Base(n), err, tail(string(out), 6))
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (in *installer) licensed(feature string) bool {
|
||||
return feature == "" || feature == "updates" || in.lic.HasFeature(feature)
|
||||
}
|
||||
|
||||
// unitTemplate — есть ли в установщике unit-файл для службы компонента.
|
||||
func unitTemplate(unit string) bool {
|
||||
if unit == "" {
|
||||
return true
|
||||
}
|
||||
_, err := fs.Stat(deploy.Files, "systemd/"+unit+".service")
|
||||
return err == nil
|
||||
}
|
||||
|
||||
func (in *installer) stepComponents() (string, error) {
|
||||
if err := in.ensureToken(); err != nil {
|
||||
return "", err
|
||||
}
|
||||
pub, err := release.ParsePublicKey(release.DefaultPublicKey)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
cl, err := release.NewClient(in.server+"/updates", in.channel, release.DefaultPublicKey)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
cl.Token = in.token
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Minute)
|
||||
defer cancel()
|
||||
sm, m, err := cl.FetchSigned(ctx)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("релиз %s: %v", in.channel, err)
|
||||
}
|
||||
staging := filepath.Join(in.P(release.StagingBase), fmt.Sprintf("install-%d", time.Now().UnixNano()))
|
||||
if err := os.MkdirAll(staging, 0o750); err != nil {
|
||||
return "", err
|
||||
}
|
||||
defer os.RemoveAll(staging)
|
||||
var names, skipped []string
|
||||
for _, c := range release.Components {
|
||||
var art *release.Artifact
|
||||
for i := range m.Artifacts {
|
||||
if m.Artifacts[i].Name == c.Name {
|
||||
art = &m.Artifacts[i]
|
||||
}
|
||||
}
|
||||
switch {
|
||||
case art == nil:
|
||||
case !c.Core && !in.licensed(c.Feature):
|
||||
case !unitTemplate(c.Unit):
|
||||
skipped = append(skipped, c.Title)
|
||||
default:
|
||||
if _, err := cl.DownloadArtifact(ctx, *art, staging); err != nil {
|
||||
return "", fmt.Errorf("скачивание %s: %v", c.Name, err)
|
||||
}
|
||||
names = append(names, c.Name)
|
||||
}
|
||||
}
|
||||
if len(names) == 0 {
|
||||
return "", fmt.Errorf("в релизе %s нет компонентов для этой лицензии", m.Version)
|
||||
}
|
||||
b, _ := json.Marshal(sm)
|
||||
_ = os.WriteFile(filepath.Join(staging, "manifest.json"), b, 0o640)
|
||||
rb, _ := json.Marshal(map[string][]string{"names": names})
|
||||
_ = os.WriteFile(filepath.Join(staging, "request.json"), rb, 0o640)
|
||||
res := release.InstallStaged(staging, release.InstallOptions{Root: in.root, PubKey: pub, AllowNew: true})
|
||||
if !res.OK {
|
||||
return "", errors.New(res.Error)
|
||||
}
|
||||
if err := os.WriteFile(in.P("/etc/bj/update.pub"), []byte(release.DefaultPublicKey+"\n"), 0o644); err != nil {
|
||||
return "", err
|
||||
}
|
||||
var list []string
|
||||
for _, x := range res.Installed {
|
||||
list = append(list, x["name"]+" "+x["version"])
|
||||
}
|
||||
detail := "релиз " + m.Version + ": " + strings.Join(list, ", ")
|
||||
if len(skipped) > 0 {
|
||||
detail += "; модули " + strings.Join(skipped, ", ") + " установятся позже, из раздела «Обновления»"
|
||||
}
|
||||
return detail, nil
|
||||
}
|
||||
|
||||
func (in *installer) stepServices() (string, error) {
|
||||
var files []string
|
||||
err := fs.WalkDir(deploy.Files, ".", func(p string, d fs.DirEntry, err error) error {
|
||||
if err != nil || d.IsDir() {
|
||||
return err
|
||||
}
|
||||
body, _ := deploy.Files.ReadFile(p)
|
||||
switch {
|
||||
case strings.HasPrefix(p, "linux/sbin/"):
|
||||
dst := in.P("/usr/local/sbin/" + filepath.Base(p))
|
||||
if err := writeFile(dst, body, 0o755); err != nil {
|
||||
return err
|
||||
}
|
||||
files = append(files, filepath.Base(p))
|
||||
case strings.HasPrefix(p, "systemd/"):
|
||||
if err := writeFile(in.P("/etc/systemd/system/"+filepath.Base(p)), body, 0o644); err != nil {
|
||||
return err
|
||||
}
|
||||
files = append(files, filepath.Base(p))
|
||||
}
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if in.root == "" {
|
||||
for _, c := range [][]string{{"daemon-reload"}, {"enable", "bj-keymedia.service", "bj-server.service"}} {
|
||||
if out, err := run("systemctl", c...); err != nil {
|
||||
return "", fmt.Errorf("systemctl %s: %v %s", strings.Join(c, " "), err, out)
|
||||
}
|
||||
}
|
||||
}
|
||||
return strings.Join(files, ", ") + "; криптосервис включается после настройки ключей в bj", nil
|
||||
}
|
||||
|
||||
func (in *installer) stepFirstRun() (string, error) {
|
||||
code, err := in.newFirstRunCode()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if in.root == "" {
|
||||
for _, unit := range []string{"bj-keymedia", "bj-server"} {
|
||||
if out, err := run("systemctl", "restart", unit); err != nil {
|
||||
return "", fmt.Errorf("запуск %s: %v %s", unit, err, out)
|
||||
}
|
||||
}
|
||||
if err := waitFor(90*time.Second, func() bool {
|
||||
resp, err := http.Get(fmt.Sprintf("http://127.0.0.1:%d/healthz", bjPort))
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
resp.Body.Close()
|
||||
return resp.StatusCode == http.StatusOK
|
||||
}); err != nil {
|
||||
return "", errors.New("bj-server не ответил за 90 секунд: journalctl -u bj-server")
|
||||
}
|
||||
}
|
||||
in.setupCode, in.shown = code, true
|
||||
if in.root != "" {
|
||||
return "проверка в песочнице: службы не запускались", nil
|
||||
}
|
||||
return "bj-server работает", nil
|
||||
}
|
||||
|
||||
// newFirstRunCode — одноразовый код первичной настройки (если пользователей ещё нет).
|
||||
func (in *installer) newFirstRunCode() (string, error) {
|
||||
if b, err := os.ReadFile(in.P(usersFile)); err == nil && bytes.Contains(b, []byte(`"login"`)) {
|
||||
return "", nil // bj уже настроен: вход по учётным записям
|
||||
}
|
||||
n, _ := rand.Int(rand.Reader, big.NewInt(100000000))
|
||||
digits := fmt.Sprintf("%08d", n.Int64())
|
||||
hash, err := bcrypt.GenerateFromPassword([]byte(digits), 12)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
b, _ := json.Marshal(map[string]any{"code_hash": string(hash), "created_at": time.Now().UTC()})
|
||||
if err := writeFile(in.P(firstRunFile), b, 0o600); err != nil {
|
||||
return "", err
|
||||
}
|
||||
in.chownBJ(in.P(firstRunFile))
|
||||
code := digits[:4] + "-" + digits[4:]
|
||||
url := setupURLs()
|
||||
issue := fmt.Sprintf("Bridge&Join, первичная настройка: откройте в браузере %s/first-run и введите код %s\n\n", firstOr(url, "http://<адрес сервера>:8080"), code)
|
||||
_ = writeFile(in.P("/etc/issue.d/bj-setup.issue"), []byte(issue), 0o644)
|
||||
return code, nil
|
||||
}
|
||||
|
||||
func cmdFirstRunCode(args []string) {
|
||||
in := &installer{out: newConsole()}
|
||||
if os.Geteuid() != 0 {
|
||||
in.out.failure(errors.New("запустите от root: sudo bj-installer first-run-code"))
|
||||
os.Exit(1)
|
||||
}
|
||||
code, err := in.newFirstRunCode()
|
||||
if err != nil {
|
||||
in.out.failure(err)
|
||||
os.Exit(1)
|
||||
}
|
||||
if code == "" {
|
||||
in.out.note("В bj уже есть пользователи: первичная настройка выполнена, входите своей учётной записью.")
|
||||
return
|
||||
}
|
||||
_ = in.ensureToken()
|
||||
in.out.done(code, in.lic)
|
||||
}
|
||||
|
||||
// ---- вспомогательное ----
|
||||
|
||||
func setupURLs() []string {
|
||||
var out []string
|
||||
ifaces, _ := net.Interfaces()
|
||||
for _, ifc := range ifaces {
|
||||
if ifc.Flags&net.FlagUp == 0 || ifc.Flags&net.FlagLoopback != 0 {
|
||||
continue
|
||||
}
|
||||
addrs, _ := ifc.Addrs()
|
||||
for _, a := range addrs {
|
||||
if ipn, ok := a.(*net.IPNet); ok && ipn.IP.To4() != nil {
|
||||
out = append(out, fmt.Sprintf("http://%s:%d", ipn.IP.String(), bjPort))
|
||||
}
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func firstOr(list []string, def string) string {
|
||||
if len(list) > 0 {
|
||||
return list[0]
|
||||
}
|
||||
return def
|
||||
}
|
||||
|
||||
func run(name string, args ...string) (string, error) {
|
||||
return runEnv(nil, name, args...)
|
||||
}
|
||||
|
||||
func runEnv(env []string, name string, args ...string) (string, error) {
|
||||
cmd := exec.Command(name, args...)
|
||||
if env != nil {
|
||||
cmd.Env = env
|
||||
}
|
||||
out, err := cmd.CombinedOutput()
|
||||
return strings.TrimSpace(string(out)), err
|
||||
}
|
||||
|
||||
func tail(s string, n int) string {
|
||||
lines := strings.Split(strings.TrimSpace(s), "\n")
|
||||
if len(lines) > n {
|
||||
lines = lines[len(lines)-n:]
|
||||
}
|
||||
return strings.Join(lines, "\n")
|
||||
}
|
||||
|
||||
func waitFor(d time.Duration, ok func() bool) error {
|
||||
deadline := time.Now().Add(d)
|
||||
for time.Now().Before(deadline) {
|
||||
if ok() {
|
||||
return nil
|
||||
}
|
||||
time.Sleep(time.Second)
|
||||
}
|
||||
return errors.New("время ожидания истекло")
|
||||
}
|
||||
|
||||
func writeFile(path string, body []byte, mode os.FileMode) error {
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.WriteFile(path+".tmp", body, mode); err != nil {
|
||||
return err
|
||||
}
|
||||
return os.Rename(path+".tmp", path)
|
||||
}
|
||||
|
||||
func randomString(n int) string {
|
||||
const alphabet = "abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789"
|
||||
b := make([]byte, n)
|
||||
for i := range b {
|
||||
x, _ := rand.Int(rand.Reader, big.NewInt(int64(len(alphabet))))
|
||||
b[i] = alphabet[x.Int64()]
|
||||
}
|
||||
return string(b)
|
||||
}
|
||||
|
||||
func pick(v, def string) string {
|
||||
if strings.TrimSpace(v) == "" {
|
||||
return def
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// ---- вывод в консоль ----
|
||||
|
||||
type console struct {
|
||||
color bool
|
||||
w *bufio.Writer
|
||||
}
|
||||
|
||||
func newConsole() *console {
|
||||
fi, err := os.Stdout.Stat()
|
||||
return &console{color: err == nil && fi.Mode()&os.ModeCharDevice != 0 && os.Getenv("NO_COLOR") == "", w: bufio.NewWriter(os.Stdout)}
|
||||
}
|
||||
|
||||
func (c *console) paint(code, s string) string {
|
||||
if !c.color {
|
||||
return s
|
||||
}
|
||||
return "\033[" + code + "m" + s + "\033[0m"
|
||||
}
|
||||
|
||||
func (c *console) flush() { _ = c.w.Flush() }
|
||||
|
||||
func (c *console) banner() {
|
||||
fmt.Fprintf(c.w, "\n %s установка на сервер\n %s\n\n", c.paint("1", "Bridge&Join"), c.paint("2", "bj-installer "+installerVersion))
|
||||
c.flush()
|
||||
}
|
||||
|
||||
func (c *console) step(i, n int, title string) {
|
||||
fmt.Fprintf(c.w, " %s %s ", c.paint("36", fmt.Sprintf("[%d/%d]", i, n)), title)
|
||||
c.flush()
|
||||
}
|
||||
|
||||
func (c *console) stepOK(detail string) {
|
||||
fmt.Fprintf(c.w, "%s\n", c.paint("32", "готово"))
|
||||
if detail != "" {
|
||||
fmt.Fprintf(c.w, " %s\n", c.paint("2", detail))
|
||||
}
|
||||
c.flush()
|
||||
}
|
||||
|
||||
func (c *console) stepFail() {
|
||||
fmt.Fprintf(c.w, "%s\n", c.paint("31", "ошибка"))
|
||||
c.flush()
|
||||
}
|
||||
|
||||
func (c *console) failure(err error) {
|
||||
fmt.Fprintf(c.w, "\n %s %v\n\n Исправьте причину и запустите установку ещё раз: пройденные шаги повторяются безопасно.\n\n", c.paint("31;1", "Установка не завершена."), err)
|
||||
c.flush()
|
||||
}
|
||||
|
||||
func (c *console) note(s string) {
|
||||
fmt.Fprintf(c.w, "\n %s\n\n", s)
|
||||
c.flush()
|
||||
}
|
||||
|
||||
// done — итоговый экран: адрес первичной настройки и одноразовый код.
|
||||
func (c *console) done(code string, l *license.License) {
|
||||
urls := setupURLs()
|
||||
line := c.paint("2", strings.Repeat("─", 64))
|
||||
fmt.Fprintf(c.w, "\n %s\n %s\n\n", line, c.paint("32;1", "bj установлен"))
|
||||
if code != "" {
|
||||
fmt.Fprintf(c.w, " Откройте в браузере на своём компьютере:\n")
|
||||
if len(urls) == 0 {
|
||||
urls = []string{fmt.Sprintf("http://<адрес сервера>:%d", bjPort)}
|
||||
}
|
||||
for _, u := range urls {
|
||||
fmt.Fprintf(c.w, " %s\n", c.paint("1", u+"/first-run"))
|
||||
}
|
||||
fmt.Fprintf(c.w, "\n Одноразовый код первичной настройки: %s\n\n", c.paint("1;33", code))
|
||||
fmt.Fprintf(c.w, " По коду создаётся администратор, дальше в разделе «Настройка»:\n организация и код участника НРД, ключи и интеграционный шлюз, учётные системы, пользователи.\n")
|
||||
} else {
|
||||
fmt.Fprintf(c.w, " Адрес bj: %s\n", c.paint("1", firstOr(urls, fmt.Sprintf("http://<адрес сервера>:%d", bjPort))))
|
||||
}
|
||||
if l != nil {
|
||||
fmt.Fprintf(c.w, "\n Лицензия: %s, план %s, ключ до %s, модули: %s\n", l.Tenant, l.Plan, l.ExpiresAt.Local().Format("02.01.2006"), featuresText(l))
|
||||
}
|
||||
fmt.Fprintf(c.w, " Код потерян: sudo bj-installer first-run-code\n %s\n\n", line)
|
||||
c.flush()
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user