From 8ed7943f13e6391e0a8371e7b7dc0d31859d6626 Mon Sep 17 00:00:00 2001 From: Zuri Klaschka Date: Sat, 14 Dec 2024 18:26:41 +0100 Subject: [PATCH] Full rewrite of `backend-go` --- backend-go/.nats.conf | 6 - backend-go/Dockerfile | 26 +- backend-go/README.md | 29 +- backend-go/config.go | 274 +++++------------- backend-go/config_test.go | 52 ++++ backend-go/docker-compose.ci.yml | 24 -- backend-go/docker-compose.yml | 69 ----- backend-go/example_util_test.go | 24 -- backend-go/go.mod | 21 +- backend-go/go.sum | 66 +---- backend-go/lib.go | 237 +++------------ backend-go/lib_test.go | 128 ++------ backend-go/model.go | 39 +++ backend-go/nats.go | 64 ---- backend-go/samples/config/main.go | 23 ++ backend-go/samples/pub/file.go | 4 - backend-go/samples/pub/main.go | 44 --- .../samples/pub/run_multiple_instances.sh | 11 - backend-go/samples/sub/main.go | 41 --- backend-go/samples/subscribe/main.go | 29 ++ backend-go/samples/without-nats/main.go | 15 + backend-go/samples/without_nats/main.go | 17 -- backend-go/test.sh | 8 + backend-go/testbed/testbed.go | 61 ++++ backend-go/util.go | 11 + backend-go/util_test.go | 12 + 26 files changed, 424 insertions(+), 911 deletions(-) delete mode 100644 backend-go/.nats.conf create mode 100644 backend-go/config_test.go delete mode 100644 backend-go/docker-compose.ci.yml delete mode 100644 backend-go/docker-compose.yml delete mode 100644 backend-go/example_util_test.go create mode 100644 backend-go/model.go delete mode 100644 backend-go/nats.go create mode 100644 backend-go/samples/config/main.go delete mode 100644 backend-go/samples/pub/file.go delete mode 100644 backend-go/samples/pub/main.go delete mode 100755 backend-go/samples/pub/run_multiple_instances.sh delete mode 100644 backend-go/samples/sub/main.go create mode 100644 backend-go/samples/subscribe/main.go create mode 100644 backend-go/samples/without-nats/main.go delete mode 100644 backend-go/samples/without_nats/main.go create mode 100644 backend-go/test.sh create mode 100644 backend-go/testbed/testbed.go create mode 100644 backend-go/util_test.go diff --git a/backend-go/.nats.conf b/backend-go/.nats.conf deleted file mode 100644 index f5e81c41..00000000 --- a/backend-go/.nats.conf +++ /dev/null @@ -1,6 +0,0 @@ -http_port: 8222 - -websocket: { - port: 9222 - no_tls: true -} diff --git a/backend-go/Dockerfile b/backend-go/Dockerfile index b663c3bc..1a1f6ba2 100644 --- a/backend-go/Dockerfile +++ b/backend-go/Dockerfile @@ -1,9 +1,21 @@ -FROM golang:1.21-alpine +# Use the official Golang image as the base image +FROM golang:1.23-alpine -# creates an "invisible" docker volume during container startup -# by retaining the go builc cache from the image build -# to support different cpu architectures -VOLUME /go - -# switch to app +# Set the working directory inside the container WORKDIR /app + +# Copy the Go module files and download dependencies +COPY go.mod go.sum ./ +RUN go mod download + +# Copy the rest of the application code +COPY . . + +# Build the Go application +RUN go build -o /testbed ./testbed/testbed.go + +# Set the entrypoint to the built binary +ENTRYPOINT ["/testbed"] + +# Default command (can be overridden by CMD in docker run) +CMD [] \ No newline at end of file diff --git a/backend-go/README.md b/backend-go/README.md index f9bbea6a..e8739173 100644 --- a/backend-go/README.md +++ b/backend-go/README.md @@ -19,15 +19,10 @@ go get -u github.com/wuespace/telestion/backend-go@latest package main import ( - "github.com/wuespace/telestion/backend-go" "log" + "github.com/wuespace/telestion/backend-go" ) -type Person struct { - Name string `json:"name"` - Address string `json:"address"` -} - func main() { // start a new Telestion service service, err := telestion.StartService() @@ -35,27 +30,17 @@ func main() { log.Fatal(err) } log.Println("Service started") - + // publish a message on the message bus - service.Nc.Publish("my-topic", []byte("Hello from Go!")) - - // subscribe to receive messages from the message bus - // automatically unmarshal JSON message to go struct - _, err = service.NcJson.Subscribe("registered-person-topic", func(person *Person) { - log.Println("Received new personal information:", person) - }) - if err != nil { - log.Println(err) - } - + service.Nc.Publish(service.Config["OUT"], []byte("Hello from Go!")) + // wait for interrupts to prevent immediate shutdown of service telestion.WaitForInterrupt() - + // drain remaining messages and close connection - if err1, err2 := service.Drain(); err1 != nil || err2 != nil { - log.Fatal(err1, err2) - } + service.Drain() } + ``` ## Behavior Specification diff --git a/backend-go/config.go b/backend-go/config.go index e3225b5c..adc1be55 100644 --- a/backend-go/config.go +++ b/backend-go/config.go @@ -1,232 +1,104 @@ package telestion import ( - "encoding/json" - "flag" "fmt" - "github.com/mitchellh/mapstructure" - "github.com/nats-io/nats.go" - "log" "os" - "path/filepath" "strings" ) -// Config parsing process must at least yield the following minimal config scheme -type minimalConfig struct { - NatsUrl string `mapstructure:"NATS_URL"` - ServiceName string `mapstructure:"SERVICE_NAME"` - DataDir string `mapstructure:"DATA_DIR"` -} - -// Checks if the untyped map contains all required config parameters to successfully start the service. -func assertContainsMinimalConfig(mapping map[string]any) error { - mConf := minimalConfig{} +func withServiceConfig(service *Service) error { + // First Pass + service.Config = MergeMaps(EnvArgsMap(), CliArgsMap()) - decoderConfig := &mapstructure.DecoderConfig{ - ErrorUnused: false, - ErrorUnset: true, - Result: &mConf, + // Dev Mode + if service.Config["DEV"] == true { + service.Config = MergeMaps(map[string]any{ + "DATA_DIR": "/tmp", + "SERVICE_NAME": "dev", + "NATS_URL": "localhost:4222", + }, service.Config) } - decoder, err := mapstructure.NewDecoder(decoderConfig) - if err != nil { - // Decoder for minimal config inference could not be initialized! - return err + // Ensure Minimal Config + if service.Config["DATA_DIR"] == nil { + return fmt.Errorf("no DATA_DIR provided") } - - if err := decoder.Decode(mapping); err != nil { - // Minimal config could not be inferred from given map! - return fmt.Errorf("missing parameters in configuration. "+ - "The following parameters are required: NATS_URL, SERVICE_NAME, DATA_DIR. "+ - "Consider using --dev during development. Original error message: %s", err.Error()) + service.DataDir = service.Config["DATA_DIR"].(string) + if service.Config["SERVICE_NAME"] == nil { + return fmt.Errorf("no SERVICE_NAME provided") } - + service.ServiceName = service.Config["SERVICE_NAME"].(string) return nil } -// Parses an untyped map into a service configuration. -func parseConfig(mapping *map[string]any) (*Config, error) { - // gets populated by the mapstructure decoder - config := Config{} - - decoderConfig := &mapstructure.DecoderConfig{ - ErrorUnused: false, - ErrorUnset: false, - WeaklyTypedInput: true, - Result: &config, - } - - decoder, err := mapstructure.NewDecoder(decoderConfig) - if err != nil { - // Decoder for TelestionBaseConfig inference could not be initialized! - return nil, err - } - - if err := decoder.Decode(*mapping); err != nil { - // TelestionBaseConfig could not be inferred from given map! - return nil, err - } - - return &config, nil -} - -// Loads and parses the service [Config] from different configuration sources in the following order: -// -// 1. `overwriteArgs` -// 2. command line arguments -// 3. environment variables -// 4. default configuration, if `--dev` is passed in the steps from above -// 5. configuration file, if `CONFIG_FILE` parameter is defined, readable and parsable -func assembleConfig(overwriteArgs map[string]string) (*Config, error) { - config := &map[string]any{} - - // add config params from passed service options - updateWith(config, &overwriteArgs) - // add config params from command line arguments - updateWith(config, cliConfig()) - // add config params from environment variables - updateWith(config, envConfig()) - - // add default config if "dev" configuration is defined - if dev, ok := (*config)["DEV"].(bool); ok && dev { - fmt.Println("Running in development mode. Using default values for missing environment variables.") - dc, err := devModeDefaultConfig() - if err != nil { - return nil, err +// Merges multiple maps into one. +// If a key is present in multiple maps, the value of the last map is used. +func MergeMaps(maps ...map[string]any) map[string]any { + res := make(map[string]any) + for _, m := range maps { + for k, v := range m { + res[k] = v } - updateWith(config, dc) } - - // add config file parameters if "CONFIG_FILE" is defined and readable - if configPath, ok := (*config)["CONFIG_FILE"].(string); ok && len(configPath) != 0 { - fc, err := fileConfig(configPath) - if err != nil { - return nil, err - } - updateWith(config, fc) - } - - // verify if configuration is valid - if err := assertContainsMinimalConfig(*config); err != nil { - return nil, err - } - - return parseConfig(config) + return res } -// Adds entries from updates to base that don't exist in base. -func updateWith[V any | string](base *map[string]any, updates *map[string]V) { - for k, v := range *updates { - if _, contained := (*base)[k]; !contained { - (*base)[k] = v +// Returns a map of all CLI arguments in the form of --KEY=VALUE or --KEY VALUE +// where KEY is the uppercase key and VALUE is the value. +// If the argument is a flag (i.e., does not have a value), the value is true. +// Positional arguments are ignored. +func CliArgsMap() map[string]any { + res := make(map[string]any) + for /* don't include executable ($0) => start at 1 */ i := 1; i < len(os.Args); i++ { + key := os.Args[i] + + if !strings.HasPrefix(key, "--") { + // ignore positional arguments + continue } - } -} - -// Parses the console arguments and returns a map that holds the configuration parameters. -func cliConfig() *map[string]any { - // setup flags - var ( - dev bool - natsUrl string - natsUser string - natsPassword string - configFile string - configKey string - serviceName string - dataDir string - ) - - flag.BoolVar(&dev, "dev", false, "If set, program will start in development mode") - - flag.StringVar(&natsUrl, "NATS_URL", "", "NATS url of the server the service can connect to") - flag.StringVar(&natsUser, "NATS_USER", "", "NATS user name for the authentication with the server") - flag.StringVar(&natsPassword, "NATS_PASSWORD", "", "NATS password for the authentication with the server "+ - "(Note: It is recommended to set this via the environment variables or the config!)") - - flag.StringVar(&configFile, "CONFIG_FILE", "", "file path to the config of the service") - flag.StringVar(&configKey, "CONFIG_KEY", "", "object key of a config file") - - flag.StringVar(&serviceName, "SERVICE_NAME", "", "name of the service also used in the nats service "+ - "registration") - flag.StringVar(&dataDir, "DATA_DIR", "", "path where the service can store persistent data") - - // we don't really like the default message of the flag package - flag.Usage = func() { - fmt.Printf("Usage: %s [options] [field_0 ... field_n]\n\nParameters:\n", os.Args[0]) - flag.PrintDefaults() - } - flag.Parse() - - flagValues := map[string]any{ - "NATS_URL": natsUrl, - "NATS_USER": natsUser, - "NATS_PASSWORD": natsPassword, - "CONFIG_FILE": configFile, - "CONFIG_KEY": configKey, - "SERVICE_NAME": serviceName, - "DATA_DIR": dataDir, - } - - // prepare output map - parsedArgs := map[string]any{ - "DEV": dev, - } - // only populate parsedArgs with entries that were, indeed, given (dev is an exception) - flag.Visit(func(currentFlag *flag.Flag) { - if value, ok := flagValues[currentFlag.Name]; ok { - parsedArgs[currentFlag.Name] = value + key = strings.TrimPrefix(key, "--") + if strings.Contains(key, "=") { + // --KEY=VALUE + split := strings.Split(key, "=") + innerKey := strings.ToUpper(split[0]) // all config keys are uppercase + innerValue := strings.Join(split[1:], "=") + res[innerKey] = innerValue + continue } - }) - return &parsedArgs -} - -// Read the environment variables and provides them as map ready to be included in the service config. -func envConfig() *map[string]string { - result := make(map[string]string, len(os.Environ())) - for _, entry := range os.Environ() { - if key, value, ok := strings.Cut(entry, "="); ok { - result[key] = value - } - // we don't want to add empty env variables - } - return &result -} + // --KEY (VALUE) + // convert the key to uppercase as it doesn't contain the value in this case: + key = strings.ToUpper(key) -// Tries to read the configuration file and returns the content as untyped map. -// Fails, if the config file is not readable or if the content is not JSON parsable. -func fileConfig(configPath string) (*map[string]any, error) { - // Note that the file config is supposed to be a json config - jsonConfig := map[string]any{} - jsonConfigBytes, err := os.ReadFile(configPath) + hasValue := i+1 < len(os.Args) && + !strings.HasPrefix(os.Args[i+1], "--") - if err != nil { - log.Printf("Config file %s could not be read: %s\n", configPath, err) - return nil, err - } + if hasValue { + // it's a key-value pair + res[key] = os.Args[i+1] + i++ + continue + } - if err = json.Unmarshal(jsonConfigBytes, &jsonConfig); err != nil { - log.Printf("Config file %s could not be parsed: %s\n", configPath, err) - return nil, err + // it's a flag and not a key-value pair + res[key] = true } - - return &jsonConfig, nil + return res } -// Returns the default configuration for development purposes. -// Fails, if the process is not allowed to determine the current working directory. -func devModeDefaultConfig() (*map[string]string, error) { - dataDir, err := filepath.Abs("data") - if err != nil { - return nil, err - } - - return &map[string]string{ - "NATS_URL": nats.DefaultURL, - "SERVICE_NAME": fmt.Sprint("dev-", os.Getgid()), - "DATA_DIR": dataDir, - }, nil +// Returns a map of all environment variables, where the key is the uppercase key +// and the value is the value of the environment variable. +// +// While this does always return a string, for compatibility with MergeMaps, it is +// typed as map[string]any. +func EnvArgsMap() map[string]any { + res := make(map[string]any) + for _, env := range os.Environ() { + split := strings.Split(env, "=") + key := strings.ToUpper(split[0]) // all config keys are uppercase + value := strings.Join(split[1:], "=") + res[key] = value + } + return res } diff --git a/backend-go/config_test.go b/backend-go/config_test.go new file mode 100644 index 00000000..59b23568 --- /dev/null +++ b/backend-go/config_test.go @@ -0,0 +1,52 @@ +package telestion + +import ( + "fmt" + "maps" + "slices" +) + +// Use MergeMaps to merge two maps, and print the result to stdout. +func ExampleMergeMaps() { + map1 := map[string]any{ + "key1": "value1", + "key2": "value2", + } + map2 := map[string]any{ + "key3": "value3", + "key4": "value4", + } + map3 := map[string]any{ + "key1": "value1 modified", + "key3": "value3 modified", + } + + merged := MergeMaps(map1, map2, map3) + + for _, key := range slices.Sorted(maps.Keys(merged)) { + fmt.Printf("Merged key '%s' with value '%s'\n", key, merged[key]) + } + // Output: + // Merged key 'key1' with value 'value1 modified' + // Merged key 'key2' with value 'value2' + // Merged key 'key3' with value 'value3 modified' + // Merged key 'key4' with value 'value4' +} + +// Use CliArgsMap to get a map of all CLI arguments, and print them to stdout. +func ExampleCliArgsMap() { + CliArgs := CliArgsMap() + + for key, value := range CliArgs { + fmt.Printf("CLI argument '%s' with value '%s'\n", key, value) + } +} + +// Use EnvArgsMap to get a map of all environment variables, and print them to stdout. +func ExampleEnvArgsMap() { + EnvArgs := EnvArgsMap() + + for key, value := range EnvArgs { + fmt.Printf("Environment variable '%s' with value '%s'\n", key, value) + } +} diff --git a/backend-go/docker-compose.ci.yml b/backend-go/docker-compose.ci.yml deleted file mode 100644 index 785d0529..00000000 --- a/backend-go/docker-compose.ci.yml +++ /dev/null @@ -1,24 +0,0 @@ -## -## docker-compose configuration for GitHub Actions -## - -services: - style: - build: - context: . - dockerfile: Dockerfile - command: > - sh -c 'gofmt -e -l . && test "$(gofmt -e -l . | wc -l)" -eq 0' - volumes: - - .:/app - profiles: [ 'style' ] - - test: - build: - context: . - dockerfile: Dockerfile - command: [ 'go', 'test' ] - volumes: - - .:/app - - ../backend-features:/backend-features - profiles: [ 'test' ] diff --git a/backend-go/docker-compose.yml b/backend-go/docker-compose.yml deleted file mode 100644 index 0e8dcfcb..00000000 --- a/backend-go/docker-compose.yml +++ /dev/null @@ -1,69 +0,0 @@ -services: - - ## - ## go commands - ## - - style: - build: - context: . - dockerfile: Dockerfile - command: [ "gofmt", "-w", "." ] - volumes: - - .:/app - profiles: [ 'style' ] - - test: - build: - context: . - dockerfile: Dockerfile - command: [ 'go', 'test' ] - volumes: - - .:/app - - ../backend-features:/backend-features - profiles: [ 'test' ] - - ## - ## end-to-end example - ## - - sub: - build: - context: . - dockerfile: Dockerfile - command: [ 'go', 'run', 'samples/sub/main.go', '--dev', '--NATS_URL=nats://nats:4222' ] - volumes: - - .:/app - networks: [ 'nats-network' ] - profiles: [ 'dev' ] - depends_on: [ 'nats' ] - restart: unless-stopped - - pub: - build: - context: . - dockerfile: Dockerfile - command: [ 'go', 'run', 'samples/pub/main.go', '--dev', '--NATS_URL=nats://nats:4222' ] - volumes: - - .:/app - networks: [ 'nats-network' ] - profiles: [ 'dev' ] - depends_on: [ 'nats' ] - - nats: - image: nats:latest - command: [ '-c', '/etc/nats/nats.conf' ] - volumes: - - ./.nats.conf:/etc/nats/nats.conf - ports: - - '0.0.0.0:4222:4222' - - '127.0.0.1:8222:8222' - - '127.0.0.1:6222:6222' - - '0.0.0.0:9222:9222' - networks: [ 'nats-network' ] - profiles: [ 'dev' ] - restart: unless-stopped - -networks: - nats-network: - name: nats-network diff --git a/backend-go/example_util_test.go b/backend-go/example_util_test.go deleted file mode 100644 index 2013fbce..00000000 --- a/backend-go/example_util_test.go +++ /dev/null @@ -1,24 +0,0 @@ -package telestion_test - -import ( - "github.com/nats-io/nats.go" - "github.com/wuespace/telestion/backend-go" -) - -// The WaitForInterrupt function waits for an external interrupt -// to prevent immediate shutdown of the service. -func ExampleWaitForInterrupt() { - // start a new Telestion service - service, _ := telestion.StartService() - - // subscribe to a subject on the message bus - _, _ = service.Nc.Subscribe("subject", func(msg *nats.Msg) { - //... - }) - - // wait for external interrupt to prevent immediate shutdown of service - telestion.WaitForInterrupt() - - // drain NATS connections - _, _ = service.Drain() -} diff --git a/backend-go/go.mod b/backend-go/go.mod index b210ab49..42187d62 100644 --- a/backend-go/go.mod +++ b/backend-go/go.mod @@ -1,24 +1,13 @@ module github.com/wuespace/telestion/backend-go -go 1.21.4 +go 1.23 -require ( - github.com/cucumber/godog v0.13.0 - github.com/mitchellh/mapstructure v1.5.0 - github.com/nats-io/nats.go v1.31.0 -) +require github.com/nats-io/nats.go v1.37.0 require ( - github.com/cucumber/gherkin/go/v26 v26.2.0 // indirect - github.com/cucumber/messages/go/v21 v21.0.1 // indirect - github.com/gofrs/uuid v4.4.0+incompatible // indirect - github.com/hashicorp/go-immutable-radix v1.3.1 // indirect - github.com/hashicorp/go-memdb v1.3.4 // indirect - github.com/hashicorp/golang-lru v1.0.2 // indirect - github.com/klauspost/compress v1.17.4 // indirect + github.com/klauspost/compress v1.17.2 // indirect github.com/nats-io/nkeys v0.4.7 // indirect github.com/nats-io/nuid v1.0.1 // indirect - github.com/spf13/pflag v1.0.5 // indirect - golang.org/x/crypto v0.17.0 // indirect - golang.org/x/sys v0.15.0 // indirect + golang.org/x/crypto v0.31.0 // indirect + golang.org/x/sys v0.28.0 // indirect ) diff --git a/backend-go/go.sum b/backend-go/go.sum index 428cb0f9..0143e4d0 100644 --- a/backend-go/go.sum +++ b/backend-go/go.sum @@ -1,64 +1,6 @@ -github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/cucumber/gherkin/go/v26 v26.2.0 h1:EgIjePLWiPeslwIWmNQ3XHcypPsWAHoMCz/YEBKP4GI= -github.com/cucumber/gherkin/go/v26 v26.2.0/go.mod h1:t2GAPnB8maCT4lkHL99BDCVNzCh1d7dBhCLt150Nr/0= -github.com/cucumber/godog v0.13.0 h1:KvX9kNWmAJwp882HmObGOyBbNUP5SXQ+SDLNajsuV7A= -github.com/cucumber/godog v0.13.0/go.mod h1:FX3rzIDybWABU4kuIXLZ/qtqEe1Ac5RdXmqvACJOces= -github.com/cucumber/messages/go/v21 v21.0.1 h1:wzA0LxwjlWQYZd32VTlAVDTkW6inOFmSM+RuOwHZiMI= -github.com/cucumber/messages/go/v21 v21.0.1/go.mod h1:zheH/2HS9JLVFukdrsPWoPdmUtmYQAQPLk7w5vWsk5s= -github.com/cucumber/messages/go/v22 v22.0.0/go.mod h1:aZipXTKc0JnjCsXrJnuZpWhtay93k7Rn3Dee7iyPJjs= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/gofrs/uuid v4.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= -github.com/gofrs/uuid v4.3.1+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= -github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA= -github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= -github.com/hashicorp/go-immutable-radix v1.3.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= -github.com/hashicorp/go-immutable-radix v1.3.1 h1:DKHmCUm2hRBK510BaiZlwvpD40f8bJFeZnpfm2KLowc= -github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= -github.com/hashicorp/go-memdb v1.3.4 h1:XSL3NR682X/cVk2IeV0d70N4DZ9ljI885xAEU8IoK3c= -github.com/hashicorp/go-memdb v1.3.4/go.mod h1:uBTr1oQbtuMgd1SSGoR8YV27eT3sBHbYiNm53bMpgSg= -github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= -github.com/hashicorp/go-uuid v1.0.2 h1:cfejS+Tpcp13yd5nYHWDI6qVCny6wyX2Mt5SGur2IGE= -github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= -github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= -github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c= -github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= -github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= -github.com/klauspost/compress v1.17.4 h1:Ej5ixsIri7BrIjBkRZLTo6ghwrEtHFk7ijlczPW4fZ4= -github.com/klauspost/compress v1.17.4/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= -github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/nats-io/nats.go v1.31.0 h1:/WFBHEc/dOKBF6qf1TZhrdEfTmOZ5JzdJ+Y3m6Y/p7E= -github.com/nats-io/nats.go v1.31.0/go.mod h1:di3Bm5MLsoB4Bx61CBTsxuarI36WbhAwOm8QrW39+i8= -github.com/nats-io/nkeys v0.4.7 h1:RwNJbbIdYCoClSDNY7QVKZlyb/wfT6ugvFCiKy6vDvI= +github.com/klauspost/compress v1.17.2/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= +github.com/nats-io/nats.go v1.37.0/go.mod h1:Ubdu4Nh9exXdSz0RVWRFBbRfrbSxOYd26oF0wkWclB8= github.com/nats-io/nkeys v0.4.7/go.mod h1:kqXRgRDPlGy7nGaEDMuYzmiJCIAAWDK0IMBtDmGD0nc= -github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw= github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0= -github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= -github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= -github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8= -github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k= -golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= -golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc= -golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= +golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= diff --git a/backend-go/lib.go b/backend-go/lib.go index beb2bc5d..a3be8715 100644 --- a/backend-go/lib.go +++ b/backend-go/lib.go @@ -1,229 +1,66 @@ -// Package telestion provides a framework for building [Telestion] services in Go. -// -// [Telestion]: https://telestion.wuespace.de/ package telestion import ( - "errors" + "fmt" "github.com/nats-io/nats.go" - "path/filepath" ) -// Config configures the Telestion service. -// The parsed configuration returned from the startService function for further usage. -type Config struct { - - // Dev if enabled, adds minimal required configuration parameters to the configuration object. - Dev bool `mapstructure:"DEV"` - - // NatsUrl describes the url that NATS uses to connect to the NATS server. - NatsUrl string `mapstructure:"NATS_URL"` - - // NatsUser is the username that the NATS client uses to log in on the NATS server. - // This property can be undefined (empty) if no configuration source provided this parameter. - NatsUser string `mapstructure:"NATS_USER"` - - // NatsPassword is the password that the NATS client uses to log in on the NATS server. - // This property can be undefined (empty) if no configuration source provided this parameter. - NatsPassword string `mapstructure:"NATS_PASSWORD"` - - // ConfigFile contains the path to the configuration file that [StartService] reads during startup. - // This property can be undefined (empty) if no configuration source provided this parameter. - ConfigFile string `mapstructure:"CONFIG_FILE"` - - // ConfigKey describes a key in config file's root object that configures this service. - // This property can be undefined if no configuration source provided this parameter. - ConfigKey string `mapstructure:"CONFIG_KEY"` - - // ServiceName contains the name of the service. - // This is used to create a unique queue group for the service and support running multiple - // parallel instances. - ServiceName string `mapstructure:"SERVICE_NAME"` - - // DataDir is the path to the data directory. - // This is where the service should store any data it needs to persist. - // The data is shared between multiple services. - // To ensure that the service doesn't overwrite data from other services, - // you should create a subdirectory for your service. - DataDir string `mapstructure:"DATA_DIR"` - - // CustomConfig contains unparsed configuration from all configuration sources. - // To use these configuration parameter you need to type cast these to a suitable type. - CustomConfig map[string]any `json:"-" ,mapstructure:",remain"` -} - -// Options describes the different options [Option] can change to modify the startup behaviour of [StartService]. -type Options struct { - - // Nats instructs [StartService] whether a NATS connection should be initialized. - Nats bool - - // OverwriteArgs provides additional configuration parameters - // that have precedence over any other configuration source. - OverwriteArgs map[string]string - - // CustomNc is a NATS connection that is externally managed and passed to [StartService] during startup. - // If `CustomNc != nil` [StartService] does not create another NATS connection - // and uses the provided connection instead. - // Used for testing. - CustomNc *nats.Conn - - // CustomNcJson is an abstraction of [Options.CustomNc]. - // It provides automatic JSON marshaling and unmarshalling of NATS message bodies. - // Used for testing. - CustomNcJson *nats.EncodedConn -} - -// Option takes the startup options from [StartService] and modifies the startup behaviour. -type Option func(*Options) error - -// WithoutNats disables the NATS initialization step in [StartService]. -func WithoutNats() Option { - return func(options *Options) error { - options.Nats = false - return nil - } -} - -// WithOverwriteArgs passes additional configuration parameters to [StartService]. -// These parameters have precedence over any other configuration source. -func WithOverwriteArgs(args map[string]string) Option { - return func(options *Options) error { - options.OverwriteArgs = args - return nil - } -} - -// WithCustomNc gives [StartService] externally managed NATS connections. -// This option prevents [StartService] to initialize another NATS connection. -// Both arguments must be a valid NATS connection. -func WithCustomNc(nc *nats.Conn, ncJson *nats.EncodedConn) Option { - return func(options *Options) error { - if nc == nil { - return errors.New("custom nats connection is not defined (nc == nil)") - } - if ncJson == nil { - return errors.New("custom encoded nats connection is not defined (ncJson == nil)") - } - - options.CustomNc = nc - options.CustomNcJson = ncJson - // enable usage of NATS to register health check - options.Nats = true - return nil - } -} - -// Service is a Telestion service that provides the available APIs. -type Service struct { - - // Nc is the NATS connection the service uses to communicate with other services on the NATS network. - Nc *nats.Conn - - // NcJson is an abstraction of [Service.Nc] - // that provides automatic JSON marshaling and unmarshalling of NATS message bodies. - NcJson *nats.EncodedConn - - // DataDir is an absolute path to the data directory of the service. - // This is where the service should store any data it needs to persist. - // The data is shared between multiple services. - // To ensure that the service doesn't overwrite data from other services, - // you should create a subdirectory for your service. - DataDir string - - // ServiceName is the name of the service. - // This is used to create a unique queue group for the service. - ServiceName string - - // Config is the assembled configuration from all available configuration sources. - // It configures the service. - Config *Config -} - -// StartService starts a new Telestion service and returns the available APIs. -// Additional options passed are applied in the order in they appear and modify the startup procedure. -// -// During startup the service parses the service [Config] from different configuration sources with the following priorities: +// Starts the Telestion service with the given options. +// The service can be configured using functions implementing the ServiceOption interface. +// Examples for such functions are: +// - WithoutNats. // -// 1. `overwriteArgs` from [WithOverwriteArgs] -// 2. command line arguments -// 3. environment variables -// 4. default configuration, if `--dev` is passed in the steps from above -// 5. configuration file, if `CONFIG_FILE` parameter is defined, readable and parsable -func StartService(opts ...Option) (*Service, error) { - options := Options{ - Nats: true, - OverwriteArgs: map[string]string{}, - CustomNc: nil, - CustomNcJson: nil, +// If the service cannot be started, an error is returned. +// Otherwise, a Service object including various APIs is returned. +func StartService(opts ...ServiceOption) (*Service, error) { + service := &Service{ + Nc: nil, + Config: nil, + DataDir: "", + ServiceName: "", + NatsDisabled: false, } - // run through each option modifier passing the current options for _, opt := range opts { - if opt != nil { - if err := opt(&options); err != nil { - return nil, err - } + if err := opt(service); err != nil { + return nil, err } } - // load the service configuration - config, err := assembleConfig(options.OverwriteArgs) + err := withServiceConfig(service) if err != nil { return nil, err } - // resolve data directory as absolute path - dataDir, err := filepath.Abs(config.DataDir) - if err != nil { - return nil, err + if service.NatsDisabled { + return service, nil } // initialize NATS connections - // explicitly set to nil if NATS is disabled - var nc *nats.Conn = nil - var ncJson *nats.EncodedConn = nil - if options.Nats { - nc, ncJson, err = initializeNats(config, options.CustomNc, options.CustomNcJson) - if err != nil { - // only close nats connections that aren't externally managed - if options.CustomNc == nil && ncJson != nil { - nc.Close() - } - if options.CustomNcJson == nil && nc != nil { - ncJson.Close() - } - return nil, err - } + if service.Config["NATS_URL"] == nil { + return nil, fmt.Errorf("no NATS_URL provided") } - return &Service{ - Nc: nc, - NcJson: ncJson, - DataDir: dataDir, - ServiceName: config.ServiceName, - Config: config, - }, nil -} + credentials := nats.UserInfo( + GetStringOrDefault(service.Config, "NATS_USER", ""), + GetStringOrDefault(service.Config, "NATS_PASSWORD", ""), + ) -// Drain tries to drain any NATS connections of the service. -func (service *Service) Drain() (errNcJson error, errNc error) { - if service.NcJson != nil { - errNcJson = service.NcJson.Drain() - } - if service.Nc != nil { - errNc = service.Nc.Drain() + nc, err := nats.Connect(service.Config["NATS_URL"].(string), credentials) + if err != nil { + return nil, err } + service.Nc = nc - return + return service, nil } -// Close closes any NATS connections of the service. -func (service *Service) Close() { - if service.NcJson != nil { - service.NcJson.Close() - } - if service.Nc != nil { - service.Nc.Close() +// A ServiceOption that modifies a service to run without connecting to NATS. +// This is useful for deploying local services with the Telestion infrastructure without having +// interactions with other services. +func WithoutNats() ServiceOption { + return func(s *Service) error { + s.NatsDisabled = true + return nil } } diff --git a/backend-go/lib_test.go b/backend-go/lib_test.go index 6407af28..ae32b39f 100644 --- a/backend-go/lib_test.go +++ b/backend-go/lib_test.go @@ -1,109 +1,39 @@ package telestion -import ( - "github.com/cucumber/godog" - "testing" -) - -func iHaveANATSServerRunningOn(arg1 string) error { - return godog.ErrPending -} - -func iHaveAnEnvironmentVariableNamedWithValue(arg1, arg2 string) error { - return godog.ErrPending -} - -func iHaveNoServiceConfiguration() error { - return godog.ErrPending -} - -func iHaveTheBasicServiceConfiguration() error { - return godog.ErrPending -} - -func iStartTheService() error { - return godog.ErrPending -} - -func iStartTheServiceWith(arg1 string) error { - return godog.ErrPending -} - -func iStartTheServiceWithWithoutNATS(arg1 string) error { - return godog.ErrPending -} - -func iStartTheServiceWithoutNATS() error { - return godog.ErrPending -} - -func isANATSUserWithPassword(arg1, arg2 string) error { - return godog.ErrPending -} - -func theNATSConnectionAPIShouldBeAvailableToTheService() error { - return godog.ErrPending -} - -func theNATSServerIsOffline() error { - return godog.ErrPending -} - -func theNATSServerRequiresAuthentication() error { - return godog.ErrPending -} - -func theServiceShouldBeConfiguredWithSetTo(arg1, arg2 string) error { - return godog.ErrPending -} - -func theServiceShouldConnectToNATS() error { - return godog.ErrPending -} - -func theServiceShouldFailToStart() error { - return godog.ErrPending -} - -func theServiceShouldNotConnectToNATS() error { - return godog.ErrPending -} +import "github.com/nats-io/nats.go" + +// The bare-bones Telestion service code. +func Example() { + // Start the service with the WithoutNats option. + service, err := StartService() + if err != nil { + // Handle the error. + panic(err) + } -func theServiceShouldStart() error { - return godog.ErrPending -} + _, err = service.Nc.Subscribe(service.ServiceName+"-inbox", func(msg *nats.Msg) { + // Handle the message. + }) + if err != nil { + panic(err) + } -func InitializeScenario(ctx *godog.ScenarioContext) { - ctx.Step(`^I have a NATS server running on "([^"]*)"$`, iHaveANATSServerRunningOn) - ctx.Step(`^I have an environment variable named "([^"]*)" with value "([^"]*)"$`, iHaveAnEnvironmentVariableNamedWithValue) - ctx.Step(`^I have no service configuration$`, iHaveNoServiceConfiguration) - ctx.Step(`^I have the basic service configuration$`, iHaveTheBasicServiceConfiguration) - ctx.Step(`^I start the service$`, iStartTheService) - ctx.Step(`^I start the service with "([^"]*)"$`, iStartTheServiceWith) - ctx.Step(`^I start the service with "([^"]*)" without NATS$`, iStartTheServiceWithWithoutNATS) - ctx.Step(`^I start the service without NATS$`, iStartTheServiceWithoutNATS) - ctx.Step(`^"([^"]*)" is a NATS user with password "([^"]*)"$`, isANATSUserWithPassword) - ctx.Step(`^the NATS connection API should be available to the service$`, theNATSConnectionAPIShouldBeAvailableToTheService) - ctx.Step(`^the NATS server is offline$`, theNATSServerIsOffline) - ctx.Step(`^the NATS server requires authentication$`, theNATSServerRequiresAuthentication) - ctx.Step(`^the service should be configured with "([^"]*)" set to "([^"]*)"$`, theServiceShouldBeConfiguredWithSetTo) - ctx.Step(`^the service should connect to NATS$`, theServiceShouldConnectToNATS) - ctx.Step(`^the service should fail to start$`, theServiceShouldFailToStart) - ctx.Step(`^the service should not connect to NATS$`, theServiceShouldNotConnectToNATS) - ctx.Step(`^the service should start$`, theServiceShouldStart) + // Wait until the user interrupts the service. + WaitForInterrupt() + // Drain the service, publishing any remaining messages. + service.Drain() } -func TestFeatures(t *testing.T) { - suite := godog.TestSuite{ - ScenarioInitializer: InitializeScenario, - Options: &godog.Options{ - Format: "pretty", - Paths: []string{"../backend-features"}, - TestingT: t, // Testing instance that will run subtests. - }, +// Start a Telestion service without the NATS connection. +func ExampleWithoutNats() { + // Start the service without NATS. + service, err := StartService(WithoutNats()) + if err != nil { + // Handle the error. + panic(err) } - if suite.Run() != 0 { - t.Fatal("non-zero status returned, failed to run feature tests") + if service.HasNatsAPI() { + panic("NATS API should not be available.") } } diff --git a/backend-go/model.go b/backend-go/model.go new file mode 100644 index 00000000..f00d3cc9 --- /dev/null +++ b/backend-go/model.go @@ -0,0 +1,39 @@ +package telestion + +import "github.com/nats-io/nats.go" + +type Service struct { + Nc *nats.Conn + Config map[string]any + DataDir string + ServiceName string + NatsDisabled bool +} + +// Drain tries to drain any NATS connections of the service. +func (service Service) Drain() { + if service.Nc != nil { + err := service.Nc.Drain() + if err != nil { + panic(err) + } + } +} + +// IsConnected returns true if the service is connected to the NATS server. +func (service Service) IsConnected() bool { + if service.Nc != nil { + return service.Nc.IsConnected() + } + return false +} + +// HasNatsAPI returns true if the service has a NATS API available. +func (service Service) HasNatsAPI() bool { + return service.Nc != nil +} + +// ServiceOption is a function that modifies a service. +// It returns an error if the modification fails. +// Can be used to pass various options to StartService. +type ServiceOption func(*Service) error diff --git a/backend-go/nats.go b/backend-go/nats.go deleted file mode 100644 index 7a9c7587..00000000 --- a/backend-go/nats.go +++ /dev/null @@ -1,64 +0,0 @@ -package telestion - -import ( - "encoding/json" - "errors" - "github.com/nats-io/nats.go" -) - -// Initialize the NATS connection and register the health check subscriber. -func initializeNats(config *Config, customNc *nats.Conn, customNcJson *nats.EncodedConn) (*nats.Conn, *nats.EncodedConn, error) { - var ( - nc *nats.Conn - ncJson *nats.EncodedConn - err error - ) - - if customNc != nil { - if customNcJson == nil { - return nil, nil, errors.New("customNcJson is not defined but required if a customNc gets used (nc != nil && ncJson == nil)") - } - - nc = customNc - ncJson = customNcJson - } else { - nc, ncJson, err = connectNats(config) - if err != nil { - return nil, nil, err - } - } - - // setup health check - _, _ = nc.Subscribe("__telestion__/health", func(msg *nats.Msg) { - response, _ := json.Marshal(healthcheck{0, config.ServiceName}) - _ = msg.Respond(response) - }) - - return nc, ncJson, nil -} - -type healthcheck struct { - errors int - name string -} - -// Connect to NATS server with the provided information from the service configuration. -func connectNats(config *Config) (*nats.Conn, *nats.EncodedConn, error) { - var natsOption nats.Option = nil - if len(config.NatsUser) != 0 && len(config.NatsPassword) != 0 { - // use username/password authentication - natsOption = nats.UserInfo(config.NatsUser, config.NatsPassword) - } - - nc, err := nats.Connect(config.NatsUrl, natsOption) - if err != nil { - return nil, nil, err - } - ncJson, err := nats.NewEncodedConn(nc, nats.JSON_ENCODER) - if err != nil { - nc.Close() - return nil, nil, err - } - - return nc, ncJson, nil -} diff --git a/backend-go/samples/config/main.go b/backend-go/samples/config/main.go new file mode 100644 index 00000000..17614409 --- /dev/null +++ b/backend-go/samples/config/main.go @@ -0,0 +1,23 @@ +package main + +import ( + "fmt" + . "github.com/wuespace/telestion/backend-go" +) + +func main() { + service, err := StartService(WithoutNats()) + if err != nil { + panic(err) + } + fmt.Printf("Service Name: %s\n", service.ServiceName) + fmt.Printf("Data Directory: %s\n", service.DataDir) + fmt.Printf("Config: %v\n", service.Config) + + // Check for custom config variable "ABC" + if val, ok := service.Config["ABC"]; ok { + fmt.Printf("ABC: %v\n", val) + } else { + fmt.Println("ABC not found in custom config") + } +} diff --git a/backend-go/samples/pub/file.go b/backend-go/samples/pub/file.go deleted file mode 100644 index fe737c67..00000000 --- a/backend-go/samples/pub/file.go +++ /dev/null @@ -1,4 +0,0 @@ -package main - -// TelestionLogo is a base64 string that contains the Telestion Logo. -const TelestionLogo = "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" diff --git a/backend-go/samples/pub/main.go b/backend-go/samples/pub/main.go deleted file mode 100644 index 463dc4ce..00000000 --- a/backend-go/samples/pub/main.go +++ /dev/null @@ -1,44 +0,0 @@ -package main - -import ( - "github.com/wuespace/telestion/backend-go" - "log" - "time" -) - -const ( - // PublishCount is the number of messages the publisher should send. - PublishCount = 100_000 - - // PublishSubject is the message bus subject the publisher should send the message. - PublishSubject = "sample_data" - - // PublishMessage is the message that the publisher sends on the message bus. - PublishMessage = "Hello from Telestion!" // or use TelestionLogo for a big message (~163 KiB) - - // SleepTime is the between two publications. - SleepTime = 1 * time.Millisecond -) - -func main() { - // start a new Telestion service - service, err := telestion.StartService() - if err != nil { - log.Fatal(err) - } - log.Println("Service started") - - log.Printf("Publish %d messages...", PublishCount) - for i := 0; i < PublishCount; i++ { - // publish a message on the message bus - _ = service.Nc.Publish(PublishSubject, []byte(PublishMessage)) - time.Sleep(SleepTime) - } - log.Printf("Finished!") - - // drain remaining messages and close connection - if err1, err2 := service.Drain(); err1 != nil || err2 != nil { - log.Fatal(err1, err2) - } - log.Printf("Service stopped") -} diff --git a/backend-go/samples/pub/run_multiple_instances.sh b/backend-go/samples/pub/run_multiple_instances.sh deleted file mode 100755 index 19ca9d24..00000000 --- a/backend-go/samples/pub/run_multiple_instances.sh +++ /dev/null @@ -1,11 +0,0 @@ -#!/bin/bash - -# This script starts the publisher multiple times in development mode. - -# change this number to increase/decrease the process count -for i in {1..5}; do - go run . --dev & -done - -# wait for all shell jobs to finish -wait diff --git a/backend-go/samples/sub/main.go b/backend-go/samples/sub/main.go deleted file mode 100644 index d2a180f6..00000000 --- a/backend-go/samples/sub/main.go +++ /dev/null @@ -1,41 +0,0 @@ -package main - -import ( - "github.com/nats-io/nats.go" - "github.com/wuespace/telestion/backend-go" - "log" -) - -const ( - // MonitoredSubject is the message bus subject the subscriber listens for new messages. - MonitoredSubject = "sample_data" -) - -func main() { - // start a new Telestion service - service, err := telestion.StartService() - if err != nil { - log.Fatal(err) - } - log.Println("Service started") - - counter := 0 - // subscribe to message bus subject - _, err = service.Nc.Subscribe(MonitoredSubject, func(msg *nats.Msg) { - counter++ - log.Printf("Counter: %d", counter) - log.Printf("%s\n", string(msg.Data)) - }) - if err != nil { - log.Println(err) - } - - log.Println("Waiting for incoming messages...") - telestion.WaitForInterrupt() - - // drain remaining messages and close connection - if err1, err2 := service.Drain(); err1 != nil || err2 != nil { - log.Println(err1, err2) - } - log.Println("Service stopped") -} diff --git a/backend-go/samples/subscribe/main.go b/backend-go/samples/subscribe/main.go new file mode 100644 index 00000000..f85f04e1 --- /dev/null +++ b/backend-go/samples/subscribe/main.go @@ -0,0 +1,29 @@ +package main + +import ( + "fmt" + "github.com/nats-io/nats.go" + . "github.com/wuespace/telestion/backend-go" +) + +func main() { + service, err := StartService() + if err != nil { + panic(err) + } + defer service.Drain() + + sub, err := service.Nc.Subscribe("subject", func(msg *nats.Msg) { + fmt.Printf("Received message: %s\n", string(msg.Data)) + }) + if err != nil { + panic(err) + } + + err = sub.AutoUnsubscribe(10) + if err != nil { + panic(err) + } + + WaitForInterrupt() +} diff --git a/backend-go/samples/without-nats/main.go b/backend-go/samples/without-nats/main.go new file mode 100644 index 00000000..40b5676e --- /dev/null +++ b/backend-go/samples/without-nats/main.go @@ -0,0 +1,15 @@ +package main + +import ( + "fmt" + . "github.com/wuespace/telestion/backend-go" +) + +func main() { + service, err := StartService(WithoutNats()) + if err != nil { + panic(err) + } + fmt.Println(service.Config) + service.Drain() +} diff --git a/backend-go/samples/without_nats/main.go b/backend-go/samples/without_nats/main.go deleted file mode 100644 index ccfe0607..00000000 --- a/backend-go/samples/without_nats/main.go +++ /dev/null @@ -1,17 +0,0 @@ -package main - -import ( - "github.com/wuespace/telestion/backend-go" - "log" -) - -func main() { - // Run without establishing a NATS connection. Especially useful during development - service, err := telestion.StartService(telestion.WithoutNats()) - if err != nil { - log.Fatal(err) - } - log.Println("Telestion service is running!") - - log.Printf("Data directory: %s", service.DataDir) -} diff --git a/backend-go/test.sh b/backend-go/test.sh new file mode 100644 index 00000000..2f6f49e2 --- /dev/null +++ b/backend-go/test.sh @@ -0,0 +1,8 @@ +echo "Running Tests" + +FILE_DIR=$(realpath $(dirname $0)) + +source ~/WebstormProjects/telestion/backend-features/.venv/bin/activate +set -x +echo "File Dir: $FILE_DIR" +python ~/WebstormProjects/telestion/backend-features/run-tests.py "$FILE_DIR" diff --git a/backend-go/testbed/testbed.go b/backend-go/testbed/testbed.go new file mode 100644 index 00000000..6f3d3707 --- /dev/null +++ b/backend-go/testbed/testbed.go @@ -0,0 +1,61 @@ +package main + +import ( + "encoding/json" + "fmt" + . "github.com/wuespace/telestion/backend-go" + "os" +) + +func main() { + result := Response{ + Env: EnvArgsMap(), + Started: false, + NatsAvailable: false, + NatsConnected: false, + Error: "", + Config: nil, + } + + service, err := StartService(WithNatsDisabledIfRequested()) + if err != nil { + result.Error = err.Error() + PrintResponse(&result) + return + } + result.Started = true + result.NatsAvailable = service.HasNatsAPI() + result.NatsConnected = service.IsConnected() + result.Config = service.Config + PrintResponse(&result) + return +} + +type Response struct { + Env map[string]any `json:"env"` + Started bool `json:"started"` + NatsAvailable bool `json:"nats_api_available"` + NatsConnected bool `json:"nats_connected"` + Error string `json:"error,omitempty"` + Config map[string]any `json:"config,omitempty"` +} + +func PrintResponse(response *Response) { + jsonString, jsonErr := json.Marshal(response) + if jsonErr != nil { + panic(jsonErr) + } + fmt.Println(string(jsonString)) +} + +func WithNatsDisabledIfRequested() ServiceOption { + for _, env := range os.Environ() { + if env == "X_DISABLE_NATS=1" { + return WithoutNats() + } + } + return func(_ *Service) error { + // no-op + return nil + } +} diff --git a/backend-go/util.go b/backend-go/util.go index f9b2d5dd..f65d931e 100644 --- a/backend-go/util.go +++ b/backend-go/util.go @@ -12,3 +12,14 @@ func WaitForInterrupt() os.Signal { signal.Notify(c, os.Interrupt) return <-c } + +// Returns the value associated with the key in the map if it exists and is a string, +// otherwise returns the default value. +func GetStringOrDefault(m map[string]any, key string, defaultValue string) string { + if value, ok := m[key]; ok { + if strValue, isString := value.(string); isString { + return strValue + } + } + return defaultValue +} diff --git a/backend-go/util_test.go b/backend-go/util_test.go new file mode 100644 index 00000000..b06b16c0 --- /dev/null +++ b/backend-go/util_test.go @@ -0,0 +1,12 @@ +package telestion + +// Run the Service until an interrupt signal is received. +func ExampleWaitForInterrupt() { + service, _ := StartService() + + // [...] + + WaitForInterrupt() + println("Interrupted, exiting...") + service.Drain() +}