working commit

2026-06-06 17:49:33 +02:00
parent c96602e933
commit 0e303ef96a
12 changed files with 89 additions and 21 deletions
@@ -0,0 +1,232 @@
+package operator
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"mbase/pkg/descr"
+	"mbase/pkg/auxuuid"
+	"mbase/pkg/auxpwd"
+	"mbase/pkg/mbctl"
+)
+
+func (lg *Logic) ValidateAcount(ctx context.Context, username, password string) (bool, string, error) {
+	var err error
+	var accountID string
+	var valid bool
+
+	lg.WaitRestoring()
+
+	accountExists, accountDescr, err := lg.db.GetAccountByUsername(ctx, username)
+	if !accountExists {
+		err := fmt.Errorf("Account not exists")
+		return valid, accountID, err
+	}
+	if !auxpwd.PasswordMatchCompat([]byte(password), accountDescr.Passhash) {
+		err := fmt.Errorf("Login data mismatch")
+		return valid, accountID, err
+	}
+	valid = true
+	accountID = accountDescr.ID
+	return valid, accountID, err
+}
+
+func (lg *Logic) CreateAccount(ctx context.Context, accountID string, params *mbctl.CreateAccountParams) (*mbctl.CreateAccountResult, error) {
+	var err error
+	res := &mbctl.CreateAccountResult{}
+
+	lg.WaitDumping()
+	lg.WaitRestoring()
+
+	grantExists, _, err := lg.db.GetGrant(ctx, accountID, descr.GrantModifyUsers)
+	if err != nil {
+		return res, err
+	}
+	if !grantExists {
+		err := fmt.Errorf("Operation not allowed for the user")
+		return res, err
+	}
+	if params.Username == "" {
+		err := fmt.Errorf("Empty username parameters")
+		return res, err
+	}
+
+	if params.Password == "" {
+		err := fmt.Errorf("Empty password parameter")
+		return res, err
+	}
+
+	accountExists, _, err := lg.db.GetAccountByUsername(ctx, params.Username)
+	if err != nil {
+		return res, err
+	}
+	if accountExists {
+		err := fmt.Errorf("Account with thist name already exists")
+		return res, err
+	}
+	now := time.Now().Format(time.RFC3339)
+	passhash := auxpwd.MakeSHA256Hash([]byte(params.Password))
+	accountDescr := &descr.Account{
+		ID:        auxuuid.NewUUID(),
+		Username:  params.Username,
+		Passhash:  passhash,
+		Disabled:  false,
+		CreatedAt: now,
+		UpdatedAt: now,
+	}
+	err = lg.db.InsertAccount(ctx, accountDescr)
+	if err != nil {
+		return res, err
+	}
+	res.AccountID = accountDescr.ID
+	return res, err
+}
+
+func (lg *Logic) UpdateAccount(ctx context.Context, accountID string, params *mbctl.UpdateAccountParams) (*mbctl.UpdateAccountResult, error) {
+	var err error
+	res := &mbctl.UpdateAccountResult{}
+
+	lg.WaitRestoring()
+	lg.WaitDumping()
+
+	grantExists, _, err := lg.db.GetGrant(ctx, accountID, descr.GrantModifyUsers)
+	if err != nil {
+		return res, err
+	}
+	if !grantExists {
+		err := fmt.Errorf("Operation not allowed for the user")
+		return res, err
+	}
+
+	var accountDescr *descr.Account
+	var accountExists bool
+	switch {
+	case params.AccountID != "":
+		accountExists, accountDescr, err = lg.db.GetAccountByID(ctx, params.AccountID)
+		if err != nil {
+			return res, err
+		}
+	case params.Username != "":
+		accountExists, accountDescr, err = lg.db.GetAccountByUsername(ctx, params.Username)
+		if err != nil {
+			return res, err
+		}
+	}
+	if !accountExists {
+		err := fmt.Errorf("Account with this is or name dont exists")
+		return res, err
+	}
+	now := time.Now().Format(time.RFC3339)
+	if params.NewUsername != "" {
+		accountDescr.UpdatedAt = now
+		accountDescr.Username = params.NewUsername
+	}
+	if params.NewPassword != "" {
+		passhash := auxpwd.MakeSHA256Hash([]byte(params.NewPassword))
+
+		accountDescr.UpdatedAt = now
+		accountDescr.Passhash = passhash
+	}
+	if params.Disabled != accountDescr.Disabled {
+		accountDescr.UpdatedAt = now
+		accountDescr.Disabled = params.Disabled
+	}
+
+	err = lg.db.UpdateAccountByID(ctx, accountDescr.ID, accountDescr)
+	if err != nil {
+		return res, err
+	}
+	return res, err
+}
+
+func (lg *Logic) DeleteAccount(ctx context.Context, accountID string, params *mbctl.DeleteAccountParams) (*mbctl.DeleteAccountResult, error) {
+	var err error
+	res := &mbctl.DeleteAccountResult{}
+
+	lg.WaitDumping()
+	lg.WaitRestoring()
+
+	grantExists, _, err := lg.db.GetGrant(ctx, accountID, descr.GrantModifyUsers)
+	if err != nil {
+		return res, err
+	}
+	if !grantExists {
+		err := fmt.Errorf("Operation not allowed for the user")
+		return res, err
+	}
+
+	var accountDescr *descr.Account
+	var accountExists bool
+	switch {
+	case params.AccountID != "":
+		accountExists, accountDescr, err = lg.db.GetAccountByID(ctx, params.AccountID)
+		if err != nil {
+			return res, err
+		}
+	case params.Username != "":
+		accountExists, accountDescr, err = lg.db.GetAccountByUsername(ctx, params.Username)
+		if err != nil {
+			return res, err
+		}
+	}
+	if !accountExists {
+		err := fmt.Errorf("Account with this is or name dont exists")
+		return res, err
+	}
+
+	err = lg.db.DeleteAllGrantsForAccountID(ctx, accountDescr.ID)
+	if err != nil {
+		return res, err
+	}
+	err = lg.db.DeleteAccountByID(ctx, accountDescr.ID)
+	if err != nil {
+		return res, err
+	}
+	return res, err
+}
+
+func (lg *Logic) ListAccounts(ctx context.Context, accountID string, params *mbctl.ListAccountsParams) (*mbctl.ListAccountsResult, error) {
+	var err error
+	res := &mbctl.ListAccountsResult{
+		Accounts: make([]*mbctl.AccountShortDescr, 0),
+	}
+
+	lg.WaitRestoring()
+
+	grantExists, _, err := lg.db.GetGrant(ctx, accountID, descr.GrantModifyUsers)
+	if err != nil {
+		return res, err
+	}
+	if !grantExists {
+		err := fmt.Errorf("Operation not allowed for the user")
+		return res, err
+	}
+
+	accountDescrs, err := lg.db.ReducedListAccounts(ctx)
+	if err != nil {
+		return res, err
+	}
+	for _, accountDescr := range accountDescrs {
+		accountShortDescr := &mbctl.AccountShortDescr{
+			Username:  accountDescr.Username,
+			Disabled:  accountDescr.Disabled,
+			CreatedAt: accountDescr.CreatedAt,
+			UpdatedAt: accountDescr.UpdatedAt,
+			Grants:    make([]*mbctl.GrantShortDescr, 0),
+		}
+		grantDescrs, err := lg.db.ListGrantsByAccountID(ctx, accountDescr.ID)
+		if err != nil {
+			return res, err
+		}
+		for _, grantDescrs := range grantDescrs {
+			grantShortDescrs := &mbctl.GrantShortDescr{
+				Operation: grantDescrs.Operation,
+				CreatedAt: grantDescrs.CreatedAt,
+			}
+			accountShortDescr.Grants = append(accountShortDescr.Grants, grantShortDescrs)
+		}
+		res.Accounts = append(res.Accounts, accountShortDescr)
+	}
+	return res, err
+}
@@ -0,0 +1,69 @@
+package operator
+
+import (
+	"context"
+	"time"
+
+	"mbase/pkg/descr"
+	"mbase/pkg/auxuuid"
+	"mbase/pkg/auxpwd"
+)
+
+const (
+	defaultSeedUsername = "certman"
+	defaultSeedPassword = "certman"
+)
+
+func (lg *Logic) CleanDatabase(ctx context.Context) error {
+	var err error
+	err = lg.db.CleanDatabase(ctx)
+	if err != nil {
+		return err
+	}
+	return err
+}
+
+func (lg *Logic) SeedAccount(ctx context.Context) (string, error) {
+	var err error
+	var accountID string
+	accountDescrs, err := lg.db.ReducedListAccounts(ctx)
+	if err != nil {
+		return accountID, err
+	}
+	lg.log.Debugf("Seed account")
+	if len(accountDescrs) == 0 {
+		now := time.Now().Format(time.RFC3339)
+		passhash := auxpwd.MakeSHA256Hash([]byte(defaultSeedPassword))
+		accountDescr := &descr.Account{
+			ID:        auxuuid.NewUUID(),
+			Username:  defaultSeedUsername,
+			Passhash:  passhash,
+			Disabled:  false,
+			CreatedAt: now,
+			UpdatedAt: now,
+		}
+		err = lg.db.InsertAccount(ctx, accountDescr)
+		if err != nil {
+			return accountID, err
+		}
+		accountID = accountDescr.ID
+		grantTypes := []string{
+			descr.GrantModifyUsers,
+			descr.GrantModifyDatabase,
+		}
+		for _, grantType := range grantTypes {
+			grantDescr := &descr.Grant{
+				AccountID: accountDescr.ID,
+				Operation: grantType,
+				CreatedAt: now,
+			}
+			err = lg.db.InsertGrant(ctx, grantDescr)
+			if err != nil {
+				return accountID, err
+			}
+
+		}
+	}
+	return accountID, err
+
+}
@@ -0,0 +1,107 @@
+package operator
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"mbase/pkg/descr"
+	"mbase/pkg/mbctl"
+
+	"go.yaml.in/yaml/v4"
+)
+
+func (lg *Logic) GetDump(ctx context.Context, accountID string, params *mbctl.GetDumpParams) (*mbctl.GetDumpResult, error) {
+	var err error
+	res := &mbctl.GetDumpResult{}
+
+	grantExists, _, err := lg.db.GetGrant(ctx, accountID, descr.GrantModifyDatabase)
+	if err != nil {
+		return res, err
+	}
+	if !grantExists {
+		err := fmt.Errorf("Operation not allowed for the user")
+		return res, err
+	}
+
+	lg.WaitRestoring()
+	lg.WaitDumping()
+
+	lg.DumpingSemUp()
+	defer lg.DumpingSemDown()
+
+	listAccounts, err := lg.db.CompletedListAccounts(ctx)
+	if err != nil {
+		return res, err
+	}
+	listGrants, err := lg.db.ListGrants(ctx)
+	if err != nil {
+		return res, err
+	}
+	lg.DumpingSemDown()
+
+	dump := descr.Dump{
+		Timestamp: time.Now().Format(time.RFC3339),
+		Accounts:  listAccounts,
+		Grants:    listGrants,
+	}
+
+	dumpBytes, err := yaml.Marshal(dump)
+	if err != nil {
+		return res, err
+	}
+
+	res.Dump = string(dumpBytes)
+	return res, err
+}
+
+func (lg *Logic) RestoreDump(ctx context.Context, accountID string, params *mbctl.RestoreDumpParams) (*mbctl.RestoreDumpResult, error) {
+	var err error
+	res := &mbctl.RestoreDumpResult{}
+
+	grantExists, _, err := lg.db.GetGrant(ctx, accountID, descr.GrantModifyDatabase)
+	if err != nil {
+		return res, err
+	}
+	if !grantExists {
+		err := fmt.Errorf("Operation not allowed for the user")
+		return res, err
+	}
+
+	lg.WaitDumping()
+	lg.WaitRestoring()
+
+	var dump descr.Dump
+
+	err = yaml.Unmarshal([]byte(params.Dump), &dump)
+	if err != nil {
+		return res, err
+	}
+
+	lg.RestoringSemUp()
+	defer lg.RestoringSemDown()
+
+	if params.DeleteAllRecords {
+		err = lg.db.CleanDatabase(ctx)
+		if err != nil {
+			return res, err
+		}
+	}
+
+	for _, account := range dump.Accounts {
+		lg.log.Infof("Insert account %s", account.Username)
+		err = lg.db.InsertAccount(ctx, &account)
+		if err != nil {
+			lg.log.Errorf("Insert account error: %v", err)
+		}
+	}
+	for _, grant := range dump.Grants {
+		lg.log.Infof("Insert grant %s for account %d", grant.Operation, grant.AccountID)
+		err = lg.db.InsertGrant(ctx, &grant)
+		if err != nil {
+			lg.log.Errorf("Insert account error: %v", err)
+		}
+	}
+
+	return res, err
+}
@@ -0,0 +1,148 @@
+package operator
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"mbase/pkg/descr"
+	"mbase/pkg/auxuuid"
+	"mbase/pkg/mbctl"
+)
+
+func (lg *Logic) SetGrant(ctx context.Context, accountID string, params *mbctl.SetGrantParams) (*mbctl.SetGrantResult, error) {
+	var err error
+	res := &mbctl.SetGrantResult{}
+
+	lg.WaitDumping()
+
+	grantExists, _, err := lg.db.GetGrant(ctx, accountID, descr.GrantModifyUsers)
+	if err != nil {
+		return res, err
+	}
+	if !grantExists {
+		err := fmt.Errorf("Operation not allowed for the user")
+		return res, err
+	}
+
+	grantTypes := []string{
+		descr.GrantModifyUsers,
+		descr.GrantModifyDatabase,
+	}
+	var grantOk bool
+	for _, grantType := range grantTypes {
+		if grantType == params.Operation {
+			grantOk = true
+			break
+		}
+	}
+	if !grantOk {
+		err := fmt.Errorf("Unknown grant type")
+		return res, err
+	}
+
+	var accountDescr *descr.Account
+	var accountExists bool
+	switch {
+	case params.AccountID != "":
+		accountExists, accountDescr, err = lg.db.GetAccountByID(ctx, params.AccountID)
+		if err != nil {
+			return res, err
+		}
+	case params.Username != "":
+		accountExists, accountDescr, err = lg.db.GetAccountByUsername(ctx, params.Username)
+		if err != nil {
+			return res, err
+		}
+	}
+	if !accountExists || accountDescr == nil {
+		err := fmt.Errorf("Account with this id or name dont exists")
+		return res, err
+	}
+
+	grantExists, _, err = lg.db.GetGrant(ctx, accountDescr.ID, params.Operation)
+	if err != nil {
+		return res, err
+	}
+	if grantExists {
+		err := fmt.Errorf("Grant %s for the user already exists", params.Operation)
+		return res, err
+	}
+	now := time.Now().Format(time.RFC3339)
+	grantDescr := &descr.Grant{
+		ID:        auxuuid.NewUUID(),
+		AccountID: accountDescr.ID,
+		CreatedAt: now,
+		Operation: params.Operation,
+	}
+	err = lg.db.InsertGrant(ctx, grantDescr)
+	if err != nil {
+		return res, err
+	}
+	return res, err
+}
+
+func (lg *Logic) DeleteGrant(ctx context.Context, accountID string, params *mbctl.DeleteGrantParams) (*mbctl.DeleteGrantResult, error) {
+	var err error
+	res := &mbctl.DeleteGrantResult{}
+
+	lg.WaitDumping()
+
+	grantExists, _, err := lg.db.GetGrant(ctx, accountID, descr.GrantModifyUsers)
+	if err != nil {
+		return res, err
+	}
+	if !grantExists {
+		err := fmt.Errorf("Operation not allowed for the user")
+		return res, err
+	}
+
+	grantTypes := []string{
+		descr.GrantModifyUsers,
+		descr.GrantModifyDatabase,
+	}
+	var grantOk bool
+	for _, grantType := range grantTypes {
+		if grantType == params.Operation {
+			grantOk = true
+			break
+		}
+	}
+	if !grantOk {
+		err := fmt.Errorf("Unknown grant type")
+		return res, err
+	}
+
+	var accountDescr *descr.Account
+	var accountExists bool
+	switch {
+	case params.AccountID != "":
+		accountExists, accountDescr, err = lg.db.GetAccountByID(ctx, params.AccountID)
+		if err != nil {
+			return res, err
+		}
+	case params.Username != "":
+		accountExists, accountDescr, err = lg.db.GetAccountByUsername(ctx, params.Username)
+		if err != nil {
+			return res, err
+		}
+	}
+	if !accountExists || accountDescr == nil {
+		err := fmt.Errorf("Account with this id or name dont exists")
+		return res, err
+	}
+
+	grantExists, _, err = lg.db.GetGrant(ctx, accountDescr.ID, params.Operation)
+	if err != nil {
+		return res, err
+	}
+	if !grantExists {
+		err := fmt.Errorf("Requested grant for the user not found")
+		return res, err
+	}
+	err = lg.db.DeleteGrantByAccountID(ctx, accountDescr.ID, params.Operation)
+	if err != nil {
+		return res, err
+	}
+	return res, err
+}
@@ -0,0 +1,15 @@
+package operator
+
+import (
+	"context"
+
+	"mbase/pkg/mbctl"
+)
+
+func (lg *Logic) GetHello(ctx context.Context, params *mbctl.GetHelloParams) (*mbctl.GetHelloResult, error) {
+	var err error
+	res := &mbctl.GetHelloResult{
+		Message: "hello",
+	}
+	return res, err
+}
@@ -0,0 +1,63 @@
+package operator
+
+import (
+	"sync/atomic"
+	"time"
+
+	"mbase/app/maindb"
+	"mbase/pkg/logger"
+)
+
+type LogicConfig struct {
+	Database *maindb.Database
+}
+
+type Logic struct {
+	log          *logger.Logger
+	db           *maindb.Database
+	dumpingSem   atomic.Bool
+	restoringSem atomic.Bool
+}
+
+func NewLogic(conf *LogicConfig) (*Logic, error) {
+	var err error
+	lg := &Logic{
+		db: conf.Database,
+	}
+	lg.log = logger.NewLogger("logic")
+	return lg, err
+}
+
+func (lg *Logic) DumpingSemUp() {
+	lg.dumpingSem.Store(true)
+}
+
+func (lg *Logic) DumpingSemDown() {
+	lg.dumpingSem.Store(false)
+}
+
+func (lg *Logic) WaitDumping() {
+	for {
+		if !lg.dumpingSem.Load() {
+			return
+		}
+		time.Sleep(1 * time.Millisecond)
+	}
+}
+
+func (lg *Logic) RestoringSemUp() {
+	lg.restoringSem.Store(true)
+}
+
+func (lg *Logic) RestoringSemDown() {
+	lg.restoringSem.Store(false)
+}
+
+func (lg *Logic) WaitRestoring() {
+	for {
+		if !lg.restoringSem.Load() {
+			return
+		}
+		time.Sleep(1 * time.Millisecond)
+	}
+}