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

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, args []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()
 }