Move accountant to it's own deployment using gRCP

cmd/rove-accountant/Dockerfile

@@ -0,0 +1,11 @@
+FROM golang:latest
+LABEL maintainer="Marc Di Luzio <marc.diluzio@gmail.com>"
+
+WORKDIR /app
+COPY . .
+RUN go mod download
+
+RUN go build -o rove-accountant -ldflags="-X 'github.com/mdiluz/rove/pkg/version.Version=$(git describe --always --long --dirty --tags)'" cmd/rove-accountant/main.go
+
+CMD [ "./rove-accountant" ]
+

cmd/rove-accountant/internal/accounts.go

@@ -0,0 +1,76 @@
+package internal
+
+import (
+	"fmt"
+)
+
+const kAccountsFileName = "rove-accounts.json"
+
+// Account represents a registered user
+type Account struct {
+	// Name simply describes the account and must be unique
+	Name string `json:"name"`
+
+	// Data represents internal account data
+	Data map[string]string `json:"data"`
+}
+
+// Represents the accountant data to store
+type accountantData struct {
+}
+
+// Accountant manages a set of accounts
+type Accountant struct {
+	Accounts map[string]Account `json:"accounts"`
+}
+
+// NewAccountant creates a new accountant
+func NewAccountant() *Accountant {
+	return &Accountant{
+		Accounts: make(map[string]Account),
+	}
+}
+
+// RegisterAccount adds an account to the set of internal accounts
+func (a *Accountant) RegisterAccount(name string) (acc Account, err error) {
+
+	// Set the account name
+	acc.Name = name
+	acc.Data = make(map[string]string)
+
+	// Verify this acount isn't already registered
+	for _, a := range a.Accounts {
+		if a.Name == acc.Name {
+			return Account{}, fmt.Errorf("Account name already registered")
+		}
+	}
+
+	// Simply add the account to the map
+	a.Accounts[acc.Name] = acc
+
+	return
+}
+
+// AssignRover assigns data to an account
+func (a *Accountant) AssignData(account string, key string, value string) error {
+
+	// Find the account matching the ID
+	if this, ok := a.Accounts[account]; ok {
+		this.Data[key] = value
+		a.Accounts[account] = this
+	} else {
+		return fmt.Errorf("no account found for id: %s", account)
+	}
+
+	return nil
+}
+
+// GetRover gets the rover rover for the account
+func (a *Accountant) GetValue(account string, key string) (string, error) {
+	// Find the account matching the ID
+	if this, ok := a.Accounts[account]; !ok {
+		return "", fmt.Errorf("no account found for id: %s", account)
+	} else {
+		return this.Data[key], nil
+	}
+}

cmd/rove-accountant/internal/accounts_test.go

@@ -0,0 +1,66 @@
+package internal
+
+import (
+	"testing"
+
+	"github.com/google/uuid"
+)
+
+func TestNewAccountant(t *testing.T) {
+	// Very basic verify here for now
+	accountant := NewAccountant()
+	if accountant == nil {
+		t.Error("Failed to create accountant")
+	}
+}
+
+func TestAccountant_RegisterAccount(t *testing.T) {
+
+	accountant := NewAccountant()
+
+	// Start by making two accounts
+
+	namea := uuid.New().String()
+	acca, err := accountant.RegisterAccount(namea)
+	if err != nil {
+		t.Error(err)
+	} else if acca.Name != namea {
+		t.Errorf("Missmatched account name after register, expected: %s, actual: %s", namea, acca.Name)
+	}
+
+	nameb := uuid.New().String()
+	accb, err := accountant.RegisterAccount(nameb)
+	if err != nil {
+		t.Error(err)
+	} else if accb.Name != nameb {
+		t.Errorf("Missmatched account name after register, expected: %s, actual: %s", nameb, acca.Name)
+	}
+
+	// Verify another request gets rejected
+	_, err = accountant.RegisterAccount(namea)
+	if err == nil {
+		t.Error("Duplicate account name did not produce error")
+	}
+}
+
+func TestAccountant_AssignGetData(t *testing.T) {
+	accountant := NewAccountant()
+	if len(accountant.Accounts) != 0 {
+		t.Error("New accountant created with non-zero account number")
+	}
+
+	name := uuid.New().String()
+	a, err := accountant.RegisterAccount(name)
+	if err != nil {
+		t.Error(err)
+	}
+
+	err = accountant.AssignData(a.Name, "key", "value")
+	if err != nil {
+		t.Error("Failed to set data for created account")
+	} else if id, err := accountant.GetValue(a.Name, "key"); err != nil {
+		t.Error("Failed to get data for account")
+	} else if id != "value" {
+		t.Error("Fetched data is incorrect for account")
+	}
+}

cmd/rove-accountant/main.go

@@ -0,0 +1,130 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log"
+	"net"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+
+	"github.com/mdiluz/rove/cmd/rove-accountant/internal"
+	"github.com/mdiluz/rove/pkg/accounts"
+	"github.com/mdiluz/rove/pkg/persistence"
+	"google.golang.org/grpc"
+)
+
+var address = flag.String("address", "", "port to server the accountant on")
+var data = flag.String("data", os.TempDir(), "path to persistent data")
+
+// accountantServer is the internal object to manage the requests
+type accountantServer struct {
+	accountant *internal.Accountant
+	sync       sync.RWMutex
+}
+
+// Register will register an account
+func (a *accountantServer) Register(ctx context.Context, in *accounts.RegisterInfo) (*accounts.RegisterResponse, error) {
+	a.sync.Lock()
+	defer a.sync.Unlock()
+
+	// Try and register the account itself
+	fmt.Printf("Registering account: %s\n", in.Name)
+	if _, err := a.accountant.RegisterAccount(in.Name); err != nil {
+		fmt.Printf("Error: %s\n", err)
+		return &accounts.RegisterResponse{Success: false, Error: fmt.Sprintf("error registering account: %s", err)}, nil
+	}
+
+	// Save out the accounts
+	if err := persistence.Save("accounts", a.accountant); err != nil {
+		fmt.Printf("Error: %s\n", err)
+		return &accounts.RegisterResponse{Success: false, Error: fmt.Sprintf("failed to save accounts: %s", err)}, nil
+	}
+
+	return &accounts.RegisterResponse{Success: true}, nil
+}
+
+// AssignData assigns a key value pair to an account
+func (a *accountantServer) AssignValue(_ context.Context, in *accounts.DataKeyValue) (*accounts.Response, error) {
+	a.sync.RLock()
+	defer a.sync.RUnlock()
+
+	// Try and assign the data
+	fmt.Printf("Assigning value for account %s: %s->%s\n", in.Account, in.Key, in.Value)
+	err := a.accountant.AssignData(in.Account, in.Key, in.Value)
+	if err != nil {
+		fmt.Printf("Error: %s\n", err)
+		return &accounts.Response{Success: false, Error: err.Error()}, nil
+	}
+
+	return &accounts.Response{Success: true}, nil
+
+}
+
+// GetData gets the value for a key
+func (a *accountantServer) GetValue(_ context.Context, in *accounts.DataKey) (*accounts.DataResponse, error) {
+	a.sync.RLock()
+	defer a.sync.RUnlock()
+
+	// Try and fetch the rover
+	fmt.Printf("Getting value for account %s: %s\n", in.Account, in.Key)
+	data, err := a.accountant.GetValue(in.Account, in.Key)
+	if err != nil {
+		fmt.Printf("Error: %s\n", err)
+		return &accounts.DataResponse{Success: false, Error: err.Error()}, nil
+	}
+
+	return &accounts.DataResponse{Success: true, Value: data}, nil
+
+}
+
+// main
+func main() {
+	flag.Parse()
+
+	// Verify the input
+	if len(*address) == 0 {
+		log.Fatal("No address set with --address")
+	}
+
+	persistence.SetPath(*data)
+
+	// Initialise and load the accountant
+	accountant := &internal.Accountant{}
+	if err := persistence.Load("accounts", accountant); err != nil {
+		log.Fatalf("failed to load account data: %s", err)
+	}
+
+	// Set up the RPC server and register
+	lis, err := net.Listen("tcp", *address)
+	if err != nil {
+		log.Fatalf("failed to listen: %v", err)
+	}
+	grpcServer := grpc.NewServer()
+	accounts.RegisterAccountantServer(grpcServer, &accountantServer{
+		accountant: accountant,
+	})
+
+	// Set up the close handler
+	c := make(chan os.Signal)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-c
+		fmt.Println("Quit requested, exiting...")
+		grpcServer.Stop()
+	}()
+
+	// Serve the RPC server
+	fmt.Printf("Serving accountant on %s\n", *address)
+	if err := grpcServer.Serve(lis); err != nil {
+		log.Fatalf("failed to server gRPC: %s", err)
+	}
+
+	// Save out the accountant data
+	if err := persistence.Save("accounts", accountant); err != nil {
+		log.Fatalf("failed to save accounts: %s", err)
+	}
+}