184 lines
3.4 KiB
Go
184 lines
3.4 KiB
Go
/*
|
|
* Copyright 2022 Oleg Borodin <borodin@unix7.org>
|
|
*/
|
|
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"certmanager/internal/config"
|
|
"certmanager/internal/database"
|
|
"certmanager/internal/descriptor"
|
|
"certmanager/pkg/logger"
|
|
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
func main() {
|
|
var err error
|
|
util := NewUtil()
|
|
err = util.Exec()
|
|
if err != nil {
|
|
fmt.Printf("Exec error: %s\n", err)
|
|
}
|
|
}
|
|
|
|
type Util struct {
|
|
conf *config.Config
|
|
db *database.Database
|
|
log *logger.Logger
|
|
|
|
filename string
|
|
deleteAllRecords bool
|
|
}
|
|
|
|
func NewUtil() *Util {
|
|
var util Util
|
|
util.log = logger.NewLogger("logic")
|
|
return &util
|
|
}
|
|
|
|
func (util *Util) GetOpt() error {
|
|
var err error
|
|
|
|
exeName := filepath.Base(os.Args[0])
|
|
|
|
help := func() {
|
|
fmt.Println("")
|
|
fmt.Printf("Usage: %s [option]\n", exeName)
|
|
fmt.Printf("\n")
|
|
flag.PrintDefaults()
|
|
fmt.Printf("\n")
|
|
}
|
|
|
|
flag.Usage = help
|
|
|
|
flag.StringVar(&util.filename, "file", util.filename, "dump file name")
|
|
flag.BoolVar(&util.deleteAllRecords, "deleteAllRecords", util.deleteAllRecords, "delete all existing zones before restoring")
|
|
|
|
flag.Parse()
|
|
return err
|
|
}
|
|
|
|
func (util *Util) Exec() error {
|
|
var err error
|
|
err = util.GetOpt()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
const timeout = 30 * time.Second
|
|
ctx, _ := context.WithTimeout(context.Background(), timeout)
|
|
|
|
err = util.RestoreRecords(ctx)
|
|
|
|
type ErrorDescr struct {
|
|
Error bool `json:"error,omitempty"`
|
|
Message string `json:"errorMessage,omitempty" yaml:"errorMessage,omitempty"`
|
|
}
|
|
|
|
errDescr := ErrorDescr{}
|
|
if err != nil {
|
|
errDescr.Error = true
|
|
errDescr.Message = fmt.Sprintf("%v", err)
|
|
}
|
|
|
|
errBytes, _ := yaml.Marshal(errDescr)
|
|
fmt.Printf("%s\n", string(errBytes))
|
|
|
|
return err
|
|
}
|
|
|
|
func (util *Util) RestoreRecords(ctx context.Context) error {
|
|
var err error
|
|
|
|
util.conf = config.NewConfig()
|
|
err = util.conf.ReadFile()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = util.conf.ReadEnv()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
db, err := database.NewDatabase(util.conf.DataDir)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
util.db = db
|
|
|
|
err = util.db.InitDatabase(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
file := os.Stdin
|
|
if util.filename != "" {
|
|
file, err = os.Open(util.filename)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer file.Close()
|
|
}
|
|
|
|
buffer := bytes.NewBuffer(nil)
|
|
_, err = io.Copy(buffer, file)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
dump := descriptor.Dump{}
|
|
|
|
err = yaml.Unmarshal(buffer.Bytes(), &dump)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if util.deleteAllRecords {
|
|
err = util.db.CleanDatabase(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for _, issuer := range dump.Issuers {
|
|
util.log.Infof("Insert issuer %s", issuer.Name)
|
|
err = util.db.InsertIssuer(ctx, &issuer)
|
|
if err != nil {
|
|
util.log.Errorf("Insert issuer error: %v", err)
|
|
}
|
|
}
|
|
for _, service := range dump.Services {
|
|
util.log.Infof("Insert service %s", service.Name)
|
|
err = util.db.InsertService(ctx, &service)
|
|
if err != nil {
|
|
util.log.Errorf("Insert service error: %v", err)
|
|
}
|
|
}
|
|
for _, account := range dump.Accounts {
|
|
util.log.Infof("Insert account %s", account.Username)
|
|
err = util.db.InsertAccount(ctx, &account)
|
|
if err != nil {
|
|
util.log.Errorf("Insert account error: %v", err)
|
|
}
|
|
}
|
|
for _, grant := range dump.Grants {
|
|
util.log.Infof("Insert grant %s for account %d", grant.Operation, grant.AccountID)
|
|
err = util.db.InsertGrant(ctx, &grant)
|
|
if err != nil {
|
|
util.log.Errorf("Insert account error: %v", err)
|
|
}
|
|
}
|
|
|
|
return err
|
|
}
|