468 lines
11 KiB
Go
468 lines
11 KiB
Go
/*
|
|
* Copyright 2024 Oleg Borodin <borodin@unix7.org>
|
|
*/
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"mbase/app/config"
|
|
"mbase/app/maindb"
|
|
"mbase/app/descr"
|
|
"mbase/app/logic"
|
|
|
|
"sigs.k8s.io/yaml"
|
|
)
|
|
|
|
const (
|
|
rcFilename = ".certmanager.yaml"
|
|
|
|
helpCmd = "help"
|
|
|
|
createAccountCmd = "createAccount"
|
|
updateAccountCmd = "updateAccount"
|
|
deleteAccountCmd = "deleteAccount"
|
|
listAccountsCmd = "listAccounts"
|
|
|
|
setGrantCmd = "setGrant"
|
|
deleteGrantCmd = "deleteGrant"
|
|
|
|
initDatabaseCmd = "initDatabase"
|
|
seedAccountCmd = "seedAccount"
|
|
)
|
|
|
|
func main() {
|
|
var err error
|
|
util := NewUtil()
|
|
err = util.Build()
|
|
if err != nil {
|
|
fmt.Printf("Build error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
err = util.Exec()
|
|
if err != nil {
|
|
fmt.Printf("Exec error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
os.Exit(0)
|
|
}
|
|
|
|
type Util struct {
|
|
subCmd string
|
|
cmdTimeout int64
|
|
|
|
conf *config.Config
|
|
lg *logic.Logic
|
|
db *maindb.Database
|
|
state descr.Server
|
|
sfile string
|
|
|
|
accessUsername string
|
|
accessPassword string
|
|
accountID int64
|
|
username string
|
|
password string
|
|
disable bool
|
|
newUsername string
|
|
newPassword string
|
|
operation string
|
|
quiet bool
|
|
}
|
|
|
|
func NewUtil() *Util {
|
|
var util Util
|
|
util.cmdTimeout = 120
|
|
return &util
|
|
}
|
|
|
|
func (util *Util) GetOpt() error {
|
|
var err error
|
|
|
|
exeName := filepath.Base(os.Args[0])
|
|
|
|
flag.Int64Var(&util.cmdTimeout, "timeout", util.cmdTimeout, "command execution timeout")
|
|
flag.StringVar(&util.accessUsername, "user", util.accessUsername, "access login")
|
|
flag.StringVar(&util.accessPassword, "pass", util.accessPassword, "access password")
|
|
flag.BoolVar(&util.quiet, "quiet", util.quiet, "don't print result")
|
|
|
|
help := func() {
|
|
fmt.Println("")
|
|
fmt.Printf("Usage: %s [option] command [command option]\n", exeName)
|
|
fmt.Printf("\n")
|
|
fmt.Printf(" %s, %s, %s, %s,\n",
|
|
createAccountCmd,
|
|
deleteAccountCmd,
|
|
listAccountsCmd,
|
|
updateAccountCmd)
|
|
fmt.Printf(" %s, %s\n",
|
|
setGrantCmd,
|
|
deleteGrantCmd)
|
|
fmt.Printf(" %s, %s\n",
|
|
initDatabaseCmd,
|
|
seedAccountCmd)
|
|
|
|
fmt.Printf("\n")
|
|
fmt.Printf("Global options:\n")
|
|
flag.PrintDefaults()
|
|
fmt.Printf("\n")
|
|
}
|
|
flag.Usage = help
|
|
flag.Parse()
|
|
|
|
args := flag.Args()
|
|
|
|
var subCmd string
|
|
var subArgs []string
|
|
if len(args) > 0 {
|
|
subCmd = args[0]
|
|
subArgs = args[1:]
|
|
}
|
|
|
|
util.subCmd = subCmd
|
|
|
|
switch subCmd {
|
|
case helpCmd:
|
|
help()
|
|
return errors.New("Unknown command")
|
|
|
|
case createAccountCmd:
|
|
flagSet := flag.NewFlagSet(createAccountCmd, flag.ExitOnError)
|
|
|
|
flagSet.StringVar(&util.username, "username", util.username, "user name")
|
|
flagSet.StringVar(&util.password, "password", util.password, "user password")
|
|
|
|
flagSet.Usage = func() {
|
|
fmt.Printf("\n")
|
|
fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
|
|
fmt.Printf("\n")
|
|
fmt.Printf("The command options: none\n")
|
|
flagSet.PrintDefaults()
|
|
fmt.Printf("\n")
|
|
}
|
|
flagSet.Parse(subArgs)
|
|
util.subCmd = subCmd
|
|
|
|
case deleteAccountCmd:
|
|
flagSet := flag.NewFlagSet(deleteAccountCmd, flag.ExitOnError)
|
|
|
|
flagSet.StringVar(&util.username, "username", util.username, "user name")
|
|
flagSet.Int64Var(&util.accountID, "accountId", util.accountID, "account ID")
|
|
|
|
flagSet.Usage = func() {
|
|
fmt.Printf("\n")
|
|
fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
|
|
fmt.Printf("\n")
|
|
fmt.Printf("The command options: none\n")
|
|
flagSet.PrintDefaults()
|
|
fmt.Printf("\n")
|
|
}
|
|
flagSet.Parse(subArgs)
|
|
util.subCmd = subCmd
|
|
|
|
case listAccountsCmd:
|
|
flagSet := flag.NewFlagSet(listAccountsCmd, flag.ExitOnError)
|
|
|
|
flagSet.Usage = func() {
|
|
fmt.Printf("\n")
|
|
fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
|
|
fmt.Printf("\n")
|
|
fmt.Printf("The command options: none\n")
|
|
flagSet.PrintDefaults()
|
|
fmt.Printf("\n")
|
|
}
|
|
flagSet.Parse(subArgs)
|
|
util.subCmd = subCmd
|
|
|
|
case updateAccountCmd:
|
|
flagSet := flag.NewFlagSet(updateAccountCmd, flag.ExitOnError)
|
|
|
|
flagSet.StringVar(&util.username, "username", util.username, "user name")
|
|
flagSet.Int64Var(&util.accountID, "accountId", util.accountID, "account ID")
|
|
|
|
flagSet.StringVar(&util.newUsername, "newUsername", util.newUsername, "new user name")
|
|
flagSet.StringVar(&util.newPassword, "newPassword", util.newPassword, "new user password")
|
|
flagSet.BoolVar(&util.disable, "disable", util.disable, "disable account")
|
|
|
|
flagSet.Usage = func() {
|
|
fmt.Printf("\n")
|
|
fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
|
|
fmt.Printf("\n")
|
|
fmt.Printf("The command options: none\n")
|
|
flagSet.PrintDefaults()
|
|
fmt.Printf("\n")
|
|
}
|
|
flagSet.Parse(subArgs)
|
|
util.subCmd = subCmd
|
|
|
|
case setGrantCmd:
|
|
flagSet := flag.NewFlagSet(setGrantCmd, flag.ExitOnError)
|
|
|
|
flagSet.StringVar(&util.username, "username", util.username, "user name")
|
|
flagSet.Int64Var(&util.accountID, "accountId", util.accountID, "account ID")
|
|
flagSet.StringVar(&util.operation, "operation", util.operation, "grant type")
|
|
|
|
flagSet.Usage = func() {
|
|
fmt.Printf("\n")
|
|
fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
|
|
fmt.Printf("\n")
|
|
fmt.Printf("The command options: none\n")
|
|
flagSet.PrintDefaults()
|
|
fmt.Printf("\n")
|
|
}
|
|
flagSet.Parse(subArgs)
|
|
util.subCmd = subCmd
|
|
|
|
case deleteGrantCmd:
|
|
flagSet := flag.NewFlagSet(deleteGrantCmd, flag.ExitOnError)
|
|
|
|
flagSet.StringVar(&util.username, "username", util.username, "user name")
|
|
flagSet.Int64Var(&util.accountID, "accountId", util.accountID, "account ID")
|
|
flagSet.StringVar(&util.operation, "operation", util.operation, "grant type")
|
|
|
|
flagSet.Usage = func() {
|
|
fmt.Printf("\n")
|
|
fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
|
|
fmt.Printf("\n")
|
|
fmt.Printf("The command options: none\n")
|
|
flagSet.PrintDefaults()
|
|
fmt.Printf("\n")
|
|
}
|
|
flagSet.Parse(subArgs)
|
|
util.subCmd = subCmd
|
|
|
|
case initDatabaseCmd:
|
|
flagSet := flag.NewFlagSet(initDatabaseCmd, flag.ExitOnError)
|
|
|
|
flagSet.Usage = func() {
|
|
fmt.Printf("\n")
|
|
fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
|
|
fmt.Printf("\n")
|
|
fmt.Printf("The command options: none\n")
|
|
flagSet.PrintDefaults()
|
|
fmt.Printf("\n")
|
|
}
|
|
flagSet.Parse(subArgs)
|
|
util.subCmd = subCmd
|
|
case seedAccountCmd:
|
|
flagSet := flag.NewFlagSet(seedAccountCmd, flag.ExitOnError)
|
|
|
|
flagSet.Usage = func() {
|
|
fmt.Printf("\n")
|
|
fmt.Printf("Usage: %s [global options] %s [command options]\n", exeName, subCmd)
|
|
fmt.Printf("\n")
|
|
fmt.Printf("The command options: none\n")
|
|
flagSet.PrintDefaults()
|
|
fmt.Printf("\n")
|
|
}
|
|
flagSet.Parse(subArgs)
|
|
util.subCmd = subCmd
|
|
|
|
default:
|
|
help()
|
|
return errors.New("Unknown command")
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (util *Util) Build() 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
|
|
}
|
|
|
|
util.sfile = filepath.Join(util.conf.DataDir, "certmanager.yaml")
|
|
|
|
db, err := maindb.NewDatabase(util.conf.DataDir)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = db.OpenDatabase()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
util.db = db
|
|
logicConfig := &logic.LogicConfig{
|
|
Database: util.db,
|
|
}
|
|
util.lg, err = logic.NewLogic(logicConfig)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return err
|
|
}
|
|
|
|
type Response struct {
|
|
Command string `json:"command" yaml:"command"`
|
|
Args []string `json:"args" yaml:"args"`
|
|
Error bool `json:"error" yaml:"error"`
|
|
Message string `json:"message,omitempty" yaml:"message,omitempty"`
|
|
Result any `json:"result,omitempty" yaml:"result,omitempty"`
|
|
}
|
|
|
|
func (util *Util) Exec() error {
|
|
var err error
|
|
err = util.GetOpt()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var timeout = time.Duration(util.cmdTimeout) * time.Second
|
|
ctx, close := context.WithTimeout(context.Background(), timeout)
|
|
defer close()
|
|
|
|
var res any
|
|
|
|
switch util.subCmd {
|
|
case initDatabaseCmd:
|
|
res, err = util.InitDatabase(ctx)
|
|
case seedAccountCmd:
|
|
res, err = util.SeedAccount(ctx)
|
|
default:
|
|
authOk, operID, localErr := util.lg.ValidateAcount(ctx, util.accessUsername, util.accessPassword)
|
|
if err != nil {
|
|
err = localErr
|
|
goto exit
|
|
}
|
|
if !authOk {
|
|
err = fmt.Errorf("Incorrect username or password")
|
|
goto exit
|
|
}
|
|
switch util.subCmd {
|
|
case createAccountCmd:
|
|
res, err = util.CreateAccount(ctx, operID)
|
|
case updateAccountCmd:
|
|
res, err = util.UpdateAccount(ctx, operID)
|
|
case listAccountsCmd:
|
|
res, err = util.ListAccounts(ctx, operID)
|
|
case deleteAccountCmd:
|
|
res, err = util.DeleteAccount(ctx, operID)
|
|
case setGrantCmd:
|
|
res, err = util.SetGrant(ctx, operID)
|
|
case deleteGrantCmd:
|
|
res, err = util.DeleteGrant(ctx, operID)
|
|
default:
|
|
err = errors.New("Unknown cli command")
|
|
}
|
|
}
|
|
|
|
exit:
|
|
var resp Response
|
|
resp.Command = util.subCmd
|
|
resp.Args = os.Args
|
|
if err != nil {
|
|
resp.Error = true
|
|
resp.Message = fmt.Sprintf("%v", err)
|
|
} else {
|
|
resp.Result = res
|
|
}
|
|
|
|
if !resp.Error && !util.quiet {
|
|
respBytes, _ := yaml.Marshal(resp)
|
|
fmt.Println(string(respBytes))
|
|
}
|
|
return err
|
|
}
|
|
|
|
type InitDatabaseRes struct{}
|
|
|
|
func (util *Util) InitDatabase(ctx context.Context) (InitDatabaseRes, error) {
|
|
res := InitDatabaseRes{}
|
|
// Initialize database
|
|
|
|
// Load state
|
|
err := util.LoadState()
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
if !util.state.DatabaseInitialized {
|
|
if util.db == nil {
|
|
err = fmt.Errorf("Nil db object")
|
|
return res, err
|
|
}
|
|
err := util.db.InitDatabase()
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
util.state.DatabaseInitialized = true
|
|
err = util.SaveState()
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
|
|
}
|
|
return res, err
|
|
}
|
|
|
|
type SeedAccountRes struct{}
|
|
|
|
func (util *Util) SeedAccount(ctx context.Context) (SeedAccountRes, error) {
|
|
// Seed accounts
|
|
res := SeedAccountRes{}
|
|
_, err := util.lg.SeedAccount(ctx)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
return res, err
|
|
}
|
|
|
|
func (util *Util) LoadState() error {
|
|
var err error
|
|
_, err = os.Stat(util.sfile)
|
|
if os.IsNotExist(err) {
|
|
err = nil
|
|
return err
|
|
}
|
|
file, err := os.Open(util.sfile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer file.Close()
|
|
stateBytes, err := ioutil.ReadAll(file)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = yaml.Unmarshal(stateBytes, &util.state)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (util *Util) SaveState() error {
|
|
var err error
|
|
|
|
file, err := os.OpenFile(util.sfile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0640)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer file.Close()
|
|
util.state.UpdatedAt = time.Now().Format(time.RFC3339)
|
|
if util.state.CreatedAt == "" {
|
|
util.state.CreatedAt = util.state.UpdatedAt
|
|
}
|
|
stateBytes, err := yaml.Marshal(util.state)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = file.Write(stateBytes)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return err
|
|
}
|