Refactor to use babyapi CLI

- The main thing here is that the API resources need to exist without
  all external integrations
- This required creating all API resources and then adding clients
  as a separate step after starting the server

Taskfile.yml

@@ -51,14 +51,14 @@ tasks:
  aliases: [rs]
  dir: ./garden-app
  cmds:
- - go run main.go server --config config.yaml
+ - go run main.go serve --config config.yaml
 
  run-dev:
  desc: Run backend Go app server and read UI templates from local FS
  aliases: [dev]
  dir: ./garden-app
  cmds:
- - DEV_TEMPLATE=server/templates/* go run main.go server --config config.yaml
+ - DEV_TEMPLATE=server/templates/* go run main.go serve --config config.yaml
 
  run-controller:
  desc: Run mock controller
@@ -77,7 +77,7 @@ tasks:
  -v ./gardens.yaml:/gardens.yaml \
  -v ./config.yaml:/config.yaml \
  ghcr.io/calvinmclean/garden-app:{{.CLI_ARGS | default "latest"}} \
- server --config /config.yaml
+ serve --config /config.yaml
 
  generate-mocks:
  desc: Use mockery to generate mocks from Go interfaces

deploy/base/garden_app.yaml

@@ -25,7 +25,7 @@ spec:
  - name: config
  mountPath: /config
  args:
- - server
+ - serve
  - --config=/config/config.yaml
  volumes:
  - name: config

deploy/docker-compose.yml

@@ -84,7 +84,7 @@ services:
  volumes:
  - "./configs/garden-app:/app/configs"
  command:
- - "server"
+ - "serve"
  - "--config=/app/configs/config.yaml"
  profiles:
  - demo

docs/app_advanced.md

@@ -19,7 +19,7 @@ This section goes into additional details of the main functionality of the `gard
 
 ### Usage
 ```shell
-garden-app server --help
+garden-app --help
 ```
 
 ### Configuration
@@ -128,7 +128,7 @@ storage:
 ```
 
 ## Controller
-The `controller` command behaves as a mock `garden-controller` that makes it easier to develop, test, and debug the `garden-app server` without using a standalone microcontroller. This has extensive options using flags to control different behaviors. In most cases, the defaults will work perfectly fine.
+The `controller` command behaves as a mock `garden-controller` that makes it easier to develop, test, and debug the `garden-app serve` without using a standalone microcontroller. This has extensive options using flags to control different behaviors. In most cases, the defaults will work perfectly fine.
 
 ### Usage
 ```shell

docs/rest_api.md

@@ -1,5 +1,5 @@
 # REST API
-The `garden-app server` provides a robust REST API for interacting with the application.
+The `garden-app serve` provides a robust REST API for interacting with the application.
 
 The OpenAPI specification can be found [here](https://github.com/calvinmclean/automated-garden/blob/main/garden-app/api/openapi.yaml).
 Use [this link](https://petstore.swagger.io/?url=https://raw.githubusercontent.com/calvinmclean/automated-garden/main/garden-app/api/openapi.yaml) to open in Swagger UI.

garden-app/Dockerfile

@@ -12,7 +12,7 @@ WORKDIR /app
 COPY --from=build /build/garden-app .
 COPY gardens.yaml.example /app/gardens.yaml
 COPY config.yaml.example /app/config.yaml
-ENTRYPOINT ["/app/garden-app", "server", "--readonly"]
+ENTRYPOINT ["/app/garden-app", "serve", "--readonly"]
 
 FROM alpine:latest AS production
 RUN mkdir /app

garden-app/README.md

@@ -21,7 +21,7 @@ This is a Go application with a CLI and web backend for working with the garden
  ```
 1. Run the server:
  ```shell
- go run main.go server --config config.yaml
+ go run main.go serve --config config.yaml
  ```
 
 To run this in a more long-term setup, I recommend using [K3s](https://k3s.io) and deploying the manifests from `/deploy/k8s`.

garden-app/cmd/controller.go

@@ -28,7 +28,7 @@ var (
  Aliases: []string{"controller run"},
  Short: "Run a mock garden-controller",
  Long: `Subscribes on a MQTT topic to act as a mock garden-controller for testing purposes`,
- Run: Controller,
+ Run: runController,
  }
 )
 
@@ -40,9 +40,13 @@ func init() {
  viper.BindPFlag("controller.num_zones", controllerCommand.PersistentFlags().Lookup("zones"))
 
  controllerCommand.PersistentFlags().StringVar(&moistureStrategy, "moisture-strategy", "random", "Strategy for creating moisture data")
- controllerCommand.RegisterFlagCompletionFunc("moisture-strategy", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
+ err := controllerCommand.RegisterFlagCompletionFunc("moisture-strategy", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
  return []string{"random", "constant", "increasing", "decreasing"}, cobra.ShellCompDirectiveDefault
  })
+ if err != nil {
+ panic(err)
+ }
+
  viper.BindPFlag("controller.moisture_strategy", controllerCommand.PersistentFlags().Lookup("moisture-strategy"))
 
  controllerCommand.PersistentFlags().IntVar(&moistureValue, "moisture-value", 100, "The value, or starting value, to use for moisture data publishing")
@@ -74,12 +78,10 @@ func init() {
 
  controllerCommand.PersistentFlags().Float64Var(&humidityValue, "humidity-value", 100, "The value to use for humidity data publishing")
  viper.BindPFlag("controller.humidity_value", controllerCommand.PersistentFlags().Lookup("humidity-value"))
-
- rootCommand.AddCommand(controllerCommand)
 }
 
-// Controller will start up the mock garden-controller
-func Controller(cmd *cobra.Command, _ []string) {
+// runController will start up the mock garden-controller
+func runController(cmd *cobra.Command, _ []string) {
  var config controller.Config
  if err := viper.Unmarshal(&config); err != nil {
  cmd.PrintErrln("unable to read config from file:", err)

garden-app/cmd/root.go

@@ -1,46 +1,89 @@
 package cmd
 
 import (
+ "fmt"
  "log/slog"
  "strings"
 
+ "github.com/calvinmclean/automated-garden/garden-app/server"
  "github.com/spf13/cobra"
  "github.com/spf13/viper"
 )
 
 var (
- // Used for flags.
  configFilename string
  logLevel string
-
- rootCommand = &cobra.Command{
- Use: "garden-app",
- Short: "A command line application for the automated home garden",
- Long: `This CLI is used to run and interact with this webserver application for your automated home garden`,
- }
 )
 
-// Execute executes the root command.
-func Execute() error {
- return rootCommand.Execute()
-}
+func Execute() {
+ api := server.NewAPI()
+ command := api.Command()
+
+ command.AddCommand(controllerCommand)
 
-func init() {
  viper.SetEnvPrefix("GARDEN_APP")
  viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
  viper.AutomaticEnv()
 
  cobra.OnInitialize(initConfig)
 
- rootCommand.PersistentFlags().StringVar(&configFilename, "config", "config.yaml", "path to config file")
+ command.PersistentFlags().StringVar(&configFilename, "config", "config.yaml", "path to config file")
 
- rootCommand.PersistentFlags().StringVarP(&logLevel, "log-level", "l", "info", "level of logging to display")
- rootCommand.RegisterFlagCompletionFunc("log-level", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
+ command.PersistentFlags().StringVarP(&logLevel, "log-level", "l", "info", "level of logging to display")
+ err := command.RegisterFlagCompletionFunc("log-level", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
  return []string{
  "debug", "info", "warn", "error",
  }, cobra.ShellCompDirectiveDefault
  })
- viper.BindPFlag("log.level", rootCommand.PersistentFlags().Lookup("log-level"))
+ if err != nil {
+ panic(err)
+ }
+
+ viper.BindPFlag("log.level", command.PersistentFlags().Lookup("log-level"))
+
+ command.PersistentPreRunE = func(c *cobra.Command, _ []string) error {
+ if c.Name() != "serve" {
+ return nil
+ }
+
+ var config server.Config
+ err := viper.Unmarshal(&config)
+ if err != nil {
+ return fmt.Errorf("unable to read config from file: %w", err)
+ }
+
+ err = api.Setup(config, true)
+ if err != nil {
+ return fmt.Errorf("error setting up API: %w", err)
+ }
+
+ return nil
+ }
+
+ for _, c := range command.Commands() {
+ if c.Name() != "serve" {
+ continue
+ }
+
+ c.Flags().Int("port", 80, "port to run Application server on")
+ viper.BindPFlag("web_server.port", c.Flags().Lookup("port"))
+
+ c.Flags().Bool("readonly", false, "run in read-only mode so server will only allow GET requests")
+ viper.BindPFlag("web_server.readonly", c.Flags().Lookup("readonly"))
+ }
+
+ err = command.Execute()
+ if err != nil {
+ fmt.Printf("error: %v\n", err)
+ }
+}
+
+func init() {
+ viper.SetEnvPrefix("GARDEN_APP")
+ viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+ viper.AutomaticEnv()
+
+ cobra.OnInitialize(initConfig)
 }
 
 func initConfig() {

garden-app/integration_tests/main_test.go

@@ -35,17 +35,23 @@ func TestIntegration(t *testing.T) {
 
  serverConfig, controllerConfig := getConfigs(t)
 
- s, err := server.NewServer(serverConfig, true)
+ api := server.NewAPI()
+ err := api.Setup(serverConfig, true)
  require.NoError(t, err)
 
  c, err = controller.NewController(controllerConfig)
  require.NoError(t, err)
 
  go c.Start()
- go s.Start()
+ go func() {
+ serveErr := api.Serve(":8080")
+ if serveErr != nil {
+ panic(serveErr.Error())
+ }
+ }()
 
  defer c.Stop()
- defer s.Stop()
+ defer api.Stop()
 
  time.Sleep(500 * time.Millisecond)
 

garden-app/main.go

@@ -1,13 +1,9 @@
 package main
 
 import (
- "os"
-
  "github.com/calvinmclean/automated-garden/garden-app/cmd"
 )
 
 func main() {
- if err := cmd.Execute(); err != nil {
- os.Exit(1)
- }
+ cmd.Execute()
 }