Backup and Config endpoint

cmd/apiserver-mock/main.go

@@ -15,7 +15,9 @@ import (
 	"google.golang.org/grpc/reflection"
 
 	"github.com/skpr/api/internal/model"
+	"github.com/skpr/api/internal/server/mock/backup"
 	"github.com/skpr/api/internal/server/mock/compass"
+	"github.com/skpr/api/internal/server/mock/config"
 	"github.com/skpr/api/internal/server/mock/cron"
 	"github.com/skpr/api/internal/server/mock/environment"
 	"github.com/skpr/api/internal/server/mock/events"
@@ -63,9 +65,19 @@ func main() {
 		RunE: func(_ *cobra.Command, _ []string) error {
 			server := grpc.NewServer()
 
+			log.Println("Registering service: Backup")
+			pb.RegisterBackupServer(server, &backup.Server{
+				Model: globalModel,
+			})
+
 			log.Println("Registering service: Compass")
 			pb.RegisterCompassServer(server, &compass.Server{})
 
+			log.Println("Registering service: Config")
+			pb.RegisterConfigServer(server, &config.Server{
+				Model: globalModel,
+			})
+
 			log.Println("Registering service: Cron")
 			pb.RegisterCronServer(server, &cron.Server{
 				Model: globalModel,

internal/model/backup.go

@@ -0,0 +1,31 @@
+package model
+
+import (
+	"time"
+
+	"github.com/brianvoe/gofakeit/v7"
+
+	"github.com/skpr/api/pb"
+)
+
+type Backup struct {
+	Id        string
+	StartTime time.Time
+	Duration  time.Duration
+}
+
+func NewBackup() *Backup {
+	return &Backup{
+		Id:        gofakeit.UUID(),
+		StartTime: time.Now().Round(time.Second),
+		Duration:  120 * time.Second,
+	}
+}
+
+func (b *Backup) Status() pb.BackupStatus_Phase {
+	status := pb.BackupStatus_Completed
+	if b.StartTime.Add(b.Duration).After(time.Now()) {
+		status = pb.BackupStatus_InProgress
+	}
+	return status
+}

internal/model/model.go

@@ -115,10 +115,49 @@ func (s *Model) CreateEnvironment(name string, size int) {
 		},
 	}
 
+	backups := []*Backup{
+		{
+			Id:        "b84dd996-8113-4cd3-8dfe-018c990f5f1a",
+			StartTime: time.Now().Add(-12 * time.Hour).Round(time.Second),
+			Duration:  115 * time.Second,
+		},
+		{
+			Id:        "aabb7bee-ab04-4ae1-ba3f-1142aae1353f",
+			StartTime: time.Now().Add(-24 * time.Hour).Round(time.Second),
+			Duration:  134 * time.Second,
+		},
+		{
+			Id:        "7d419959-a3b7-483b-8fa7-769a0977e46b",
+			StartTime: time.Now().Add(-36 * time.Hour).Round(time.Second),
+			Duration:  123 * time.Second,
+		},
+	}
+
+	config := map[string]*pb.Config{
+		"mysql.default.database": {
+			Key:   "mysql.default.database",
+			Value: "heuu87bueoa8euua",
+			Type:  pb.ConfigType_System,
+		},
+		"mysql.default.password": {
+			Key:    "mysql.default.password",
+			Value:  "Passw0rd",
+			Secret: true,
+			Type:   pb.ConfigType_System,
+		},
+		"my.personal.key": {
+			Key:   "my.personal.key",
+			Value: "A_value",
+			Type:  pb.ConfigType_User,
+		},
+	}
+
 	s.storage[name] = &Environment{
 		Environment: environment,
+		Config:      config,
 		Cron:        cron,
 		Purge:       purge,
+		Backup:      backups,
 	}
 }
 
@@ -128,8 +167,10 @@ func (s *Model) DeleteEnvironment(name string) {
 
 type Environment struct {
 	Environment *pb.Environment
+	Config      map[string]*pb.Config
 	Cron        map[string]*Cron
 	Purge       []*Purge
+	Backup      []*Backup
 }
 
 type Cron struct {
@@ -153,3 +194,32 @@ func NewPurge(paths []string) *Purge {
 		Paths:   paths,
 	}
 }
+
+func (m *Environment) AppendBackup(backup *Backup) {
+	m.Backup = append(m.Backup, backup)
+}
+
+func (m *Environment) AddConfig(config *pb.Config) {
+	m.Config[config.Key] = config
+}
+
+func (m *Environment) GetConfig(key string) (*pb.Config, error) {
+	value, exists := m.Config[key]
+	if !exists {
+		return nil, fmt.Errorf("config key does not exist")
+	}
+
+	return value, nil
+}
+
+func (m *Environment) DeleteConfig(key string) error {
+	_, exists := m.Config[key]
+	if !exists {
+		return fmt.Errorf("config key does not exist")
+	}
+
+	if m.Config[key].Type != pb.ConfigType_System {
+		delete(m.Config, key)
+	}
+	return nil
+}

internal/server/mock/backup/server.go

@@ -0,0 +1,62 @@
+package backup
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"time"
+
+	"github.com/skpr/api/internal/model"
+	"github.com/skpr/api/pb"
+)
+
+// Server implements the GRPC "backup" definition.
+type Server struct {
+	Model *model.Model
+	pb.UnimplementedBackupServer
+}
+
+func (s *Server) Create(ctx context.Context, req *pb.BackupCreateRequest) (*pb.BackupCreateResponse, error) {
+	environment, err := s.Model.GetEnvironment(req.Environment)
+	if err != nil {
+		return nil, err
+	}
+
+	backup := model.NewBackup()
+	environment.AppendBackup(backup)
+	resp := &pb.BackupCreateResponse{
+		ID: backup.Id,
+	}
+	return resp, nil
+}
+
+func (s *Server) Get(ctx context.Context, req *pb.BackupGetRequest) (*pb.BackupGetResponse, error) {
+	return nil, fmt.Errorf("not yet implemented")
+}
+
+func (s *Server) List(ctx context.Context, req *pb.BackupListRequest) (*pb.BackupListResponse, error) {
+	environment, err := s.Model.GetEnvironment(req.Environment)
+	if err != nil {
+		return nil, err
+	}
+
+	resp := &pb.BackupListResponse{}
+
+	for _, value := range environment.Backup {
+		summary := &pb.BackupStatus{
+			Name:      value.Id,
+			Phase:     value.Status(),
+			StartTime: value.StartTime.Format(time.RFC3339),
+			Duration:  value.Duration.String(),
+			Databases: []string{"default"},
+			Volumes:   []string{"public", "private"},
+		}
+		resp.List = append(resp.List, summary)
+	}
+
+	sort.Slice(resp.List, func(i, j int) bool {
+		return resp.List[i].StartTime > resp.List[j].StartTime
+	})
+
+	return resp, nil
+}

internal/server/mock/config/server.go

@@ -0,0 +1,72 @@
+package config
+
+import (
+	"context"
+
+	"github.com/skpr/api/internal/model"
+	"github.com/skpr/api/pb"
+)
+
+// Server implements the GRPC "backup" definition.
+type Server struct {
+	Model *model.Model
+	pb.UnimplementedConfigServer
+}
+
+func (s *Server) List(ctx context.Context, req *pb.ConfigListRequest) (*pb.ConfigListResponse, error) {
+	environment, err := s.Model.GetEnvironment(req.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO Hide secrets if not asked for
+
+	resp := &pb.ConfigListResponse{}
+	for _, value := range environment.Config {
+		resp.List = append(resp.List, value)
+	}
+	return resp, nil
+}
+
+func (s *Server) Get(ctx context.Context, req *pb.ConfigGetRequest) (*pb.ConfigGetResponse, error) {
+	environment, err := s.Model.GetEnvironment(req.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	value, err := environment.GetConfig(req.Key)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO Hide secrets if not asked for
+
+	return &pb.ConfigGetResponse{
+		Config: value,
+	}, nil
+}
+
+func (s *Server) Set(ctx context.Context, req *pb.ConfigSetRequest) (*pb.ConfigSetResponse, error) {
+	environment, err := s.Model.GetEnvironment(req.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	environment.AddConfig(req.Config)
+
+	return &pb.ConfigSetResponse{}, nil
+}
+
+func (s *Server) Delete(ctx context.Context, req *pb.ConfigDeleteRequest) (*pb.ConfigDeleteResponse, error) {
+	environment, err := s.Model.GetEnvironment(req.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	err = environment.DeleteConfig(req.Key)
+	if err != nil {
+		return nil, err
+	}
+
+	return &pb.ConfigDeleteResponse{}, nil
+}