backup/showbridge-go
1
0
Fork 0
mirror of https://github.com/jwetzell/showbridge-go.git synced 2026-04-26 21:05:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

add convenience method to pull params from config

Browse Source
This commit is contained in:
Joel Wetzell
2026-03-01 14:57:19 -06:00
parent 183182e6cd
commit c298f63ffc
69 changed files with 591 additions and 1081 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
internal/module/http-server.go
View File

@@ -57,17 +57,10 @@ func init() {
Type: "http.server",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
port, ok := params["port"]
if !ok {
return nil, errors.New("http.server requires a port parameter")
portNum, err := params.GetInt("port")
if err != nil {
return nil, fmt.Errorf("http.server port error: %w", err)
}
portNum, ok := port.(float64)
if !ok {
return nil, errors.New("http.server port must be a number")
}
return &HTTPServer{Port: uint16(portNum), config: config, logger: CreateLogger(config)}, nil
},
})

13
internal/module/midi-input.go
View File

@@ -29,16 +29,9 @@ func init() {
Type: "midi.input",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
port, ok := params["port"]
if !ok {
return nil, errors.New("midi.input requires a port parameter")
}
portString, ok := port.(string)
if !ok {
return nil, errors.New("midi.input port must be a string")
portString, err := params.GetString("port")
if err != nil {
return nil, fmt.Errorf("midi.input port error: %w", err)
}
return &MIDIInput{config: config, Port: portString, logger: CreateLogger(config)}, nil

13
internal/module/midi-output.go
View File

@@ -30,16 +30,9 @@ func init() {
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
port, ok := params["port"]
if !ok {
return nil, errors.New("midi.output requires a port parameter")
}
portString, ok := port.(string)
if !ok {
return nil, errors.New("midi.output port must be a string")
portString, err := params.GetString("port")
if err != nil {
return nil, fmt.Errorf("midi.output port error: %w", err)
}
return &MIDIOutput{config: config, Port: portString, logger: CreateLogger(config)}, nil

37
internal/module/mqtt-client.go
View File

@@ -3,6 +3,7 @@ package module
import (
"context"
"errors"
"fmt"
"log/slog"
mqtt "github.com/eclipse/paho.mqtt.golang"
@@ -27,40 +28,22 @@ func init() {
Type: "mqtt.client",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
broker, ok := params["broker"]
brokerString, err := params.GetString("broker")
if !ok {
return nil, errors.New("mqtt.client requires a broker parameter")
if err != nil {
return nil, fmt.Errorf("mqtt.client broker error: %w", err)
}
brokerString, ok := broker.(string)
topicString, err := params.GetString("topic")
if !ok {
return nil, errors.New("mqtt.client broker must be a string")
if err != nil {
return nil, fmt.Errorf("mqtt.client topic error: %w", err)
}
topic, ok := params["topic"]
clientIdString, err := params.GetString("clientId")
if !ok {
return nil, errors.New("mqtt.client requires a topic parameter")
}
topicString, ok := topic.(string)
if !ok {
return nil, errors.New("mqtt.client topic must be a string")
}
clientId, ok := params["clientId"]
if !ok {
return nil, errors.New("mqtt.client requires a clientId parameter")
}
clientIdString, ok := clientId.(string)
if !ok {
return nil, errors.New("mqtt.client clientId must be a string")
if err != nil {
return nil, fmt.Errorf("mqtt.client clientId error: %w", err)
}
return &MQTTClient{config: config, Broker: brokerString, Topic: topicString, ClientID: clientIdString, logger: CreateLogger(config)}, nil

25
internal/module/nats-client.go
View File

@@ -27,28 +27,15 @@ func init() {
Type: "nats.client",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
url, ok := params["url"]
if !ok {
return nil, errors.New("nats.client requires a url parameter")
urlString, err := params.GetString("url")
if err != nil {
return nil, errors.New("nats.client url error: " + err.Error())
}
urlString, ok := url.(string)
subjectString, err := params.GetString("subject")
if !ok {
return nil, errors.New("nats.client url must be a string")
}
subject, ok := params["subject"]
if !ok {
return nil, errors.New("nats.client requires a subject parameter")
}
subjectString, ok := subject.(string)
if !ok {
return nil, errors.New("nats.client subject must be a string")
if err != nil {
return nil, errors.New("nats.client subject error: " + err.Error())
}
return &NATSClient{config: config, URL: urlString, Subject: subjectString, logger: CreateLogger(config)}, nil

41
internal/module/nats-server.go
View File

@@ -27,42 +27,31 @@ type NATSServer struct {
func init() {
RegisterModule(ModuleRegistration{
Type: "nats.server",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
portNum := 4222
port, ok := params["port"]
if ok {
specificportNum, ok := port.(int)
if !ok {
specificportNum, ok := port.(float64)
if !ok {
return nil, errors.New("nats.server port must be a number")
}
portNum = int(specificportNum)
New: func(moduleConfig config.ModuleConfig) (Module, error) {
params := moduleConfig.Params
portNum, err := params.GetInt("port")
if err != nil {
if errors.Is(err, config.ErrParamNotFound) {
portNum = 4222
} else {
portNum = int(specificportNum)
return nil, fmt.Errorf("nats.server port error: %w", err)
}
}
ipString := "0.0.0.0"
ip, ok := params["ip"]
if ok {
specificIpString, ok := ip.(string)
if !ok {
return nil, errors.New("nats.server ip must be a string")
ipString, err := params.GetString("ip")
if err != nil {
if errors.Is(err, config.ErrParamNotFound) {
ipString = "0.0.0.0"
} else {
return nil, fmt.Errorf("nats.server ip error: %w", err)
}
ipString = specificIpString
}
_, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", ipString, uint16(portNum)))
_, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", ipString, uint16(portNum)))
if err != nil {
return nil, err
}
return &NATSServer{config: config, logger: CreateLogger(config), Ip: ipString, Port: portNum}, nil
return &NATSServer{config: moduleConfig, logger: CreateLogger(moduleConfig), Ip: ipString, Port: portNum}, nil
},
})
}

41
internal/module/serial-client.go
View File

@@ -32,48 +32,29 @@ func init() {
Type: "serial.client",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
port, ok := params["port"]
if !ok {
return nil, errors.New("serial.client requires a port parameter")
portString, err := params.GetString("port")
if err != nil {
return nil, fmt.Errorf("serial.client port error: %w", err)
}
portString, ok := port.(string)
if !ok {
return nil, errors.New("serial.client port must be a string")
}
framingMethod, ok := params["framing"]
if !ok {
return nil, errors.New("serial.client requires a framing parameter")
}
framingMethodString, ok := framingMethod.(string)
if !ok {
return nil, errors.New("serial.client framing method must be a string")
framingMethodString, err := params.GetString("framing")
if err != nil {
return nil, fmt.Errorf("serial.client framing error: %w", err)
}
framer := framer.GetFramer(framingMethodString)
if framer == nil {
return nil, fmt.Errorf("serial.client unknown framing method: %s", framingMethod)
return nil, fmt.Errorf("serial.client unknown framing method: %s", framingMethodString)
}
buadRate, ok := params["baudRate"]
if !ok {
return nil, errors.New("serial.client requires a baudRate parameter")
}
baudRateNum, ok := buadRate.(float64)
if !ok {
return nil, errors.New("serial.client baudRate must be a number")
baudRateInt, err := params.GetInt("baudRate")
if err != nil {
return nil, fmt.Errorf("serial.client baudRate error: %w", err)
}
mode := serial.Mode{
BaudRate: int(baudRateNum),
BaudRate: baudRateInt,
}
return &SerialClient{config: config, Port: portString, Framer: framer, Mode: &mode, logger: CreateLogger(config)}, nil

68
internal/module/sip-call-server.go
View File

@@ -46,60 +46,46 @@ type sipCallContextKey string
func init() {
RegisterModule(ModuleRegistration{
Type: "sip.call.server",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
portNum := 5060
New: func(moduleConfig config.ModuleConfig) (Module, error) {
params := moduleConfig.Params
portNum, err := params.GetInt("port")
if err != nil {
port, ok := params["port"]
if ok {
specificPortNum, ok := port.(float64)
if !ok {
return nil, errors.New("sip.call.server port must be a number")
if errors.Is(err, config.ErrParamNotFound) {
portNum = 5060
} else {
return nil, fmt.Errorf("sip.call.server port error: %w", err)
}
portNum = int(specificPortNum)
}
ipString := "0.0.0.0"
ip, ok := params["ip"]
if ok {
specificIpString, ok := ip.(string)
if !ok {
return nil, errors.New("sip.call.server ip must be a string")
ipString, err := params.GetString("ip")
if err != nil {
if errors.Is(err, config.ErrParamNotFound) {
ipString = "0.0.0.0"
} else {
return nil, fmt.Errorf("sip.call.server ip error: %w", err)
}
ipString = specificIpString
}
transportString := "udp"
transport, ok := params["transport"]
if ok {
specificTransportString, ok := transport.(string)
if !ok {
return nil, errors.New("sip.call.server transport must be a string")
transportString, err := params.GetString("transport")
if err != nil {
if errors.Is(err, config.ErrParamNotFound) {
transportString = "udp"
} else {
return nil, fmt.Errorf("sip.call.server transport error: %w", err)
}
transportString = specificTransportString
}
userAgentString := "showbridge"
userAgent, ok := params["userAgent"]
if ok {
specificUserAgentString, ok := userAgent.(string)
if !ok {
return nil, errors.New("sip.call.server userAgent must be a string")
userAgentString, err := params.GetString("userAgent")
if err != nil {
if errors.Is(err, config.ErrParamNotFound) {
userAgentString = "showbridge"
} else {
return nil, fmt.Errorf("sip.call.server userAgent error: %w", err)
}
userAgentString = specificUserAgentString
}
return &SIPCallServer{config: config, IP: ipString, Port: int(portNum), Transport: transportString, UserAgent: userAgentString, logger: CreateLogger(config)}, nil
return &SIPCallServer{config: moduleConfig, IP: ipString, Port: int(portNum), Transport: transportString, UserAgent: userAgentString, logger: CreateLogger(moduleConfig)}, nil
},
})
}

77
internal/module/sip-dtmf-server.go
View File

@@ -46,66 +46,49 @@ type SIPDTMFCall struct {
func init() {
RegisterModule(ModuleRegistration{
Type: "sip.dtmf.server",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
portNum := 5060
New: func(moduleConfig config.ModuleConfig) (Module, error) {
params := moduleConfig.Params
port, ok := params["port"]
if ok {
specificPortNum, ok := port.(float64)
portNum, err := params.GetInt("port")
if err != nil {
if !ok {
return nil, errors.New("sip.dtmf.server port must be a number")
if errors.Is(err, config.ErrParamNotFound) {
portNum = 5060
} else {
return nil, fmt.Errorf("sip.dtmf.server port error: %w", err)
}
portNum = int(specificPortNum)
}
ipString := "0.0.0.0"
ip, ok := params["ip"]
if ok {
specificIpString, ok := ip.(string)
if !ok {
return nil, errors.New("sip.dtmf.server ip must be a string")
ipString, err := params.GetString("ip")
if err != nil {
if errors.Is(err, config.ErrParamNotFound) {
ipString = "0.0.0.0"
} else {
return nil, fmt.Errorf("sip.dtmf.server ip error: %w", err)
}
ipString = specificIpString
}
transportString := "udp"
transport, ok := params["transport"]
if ok {
specificTransportString, ok := transport.(string)
if !ok {
return nil, errors.New("sip.dtmf.server transport must be a string")
transportString, err := params.GetString("transport")
if err != nil {
if errors.Is(err, config.ErrParamNotFound) {
transportString = "udp"
} else {
return nil, fmt.Errorf("sip.dtmf.server transport error: %w", err)
}
transportString = specificTransportString
}
userAgentString := "showbridge"
userAgent, ok := params["userAgent"]
if ok {
specificUserAgentString, ok := userAgent.(string)
if !ok {
return nil, errors.New("sip.dtmf.server userAgent must be a string")
userAgentString, err := params.GetString("userAgent")
if err != nil {
if errors.Is(err, config.ErrParamNotFound) {
userAgentString = "showbridge"
} else {
return nil, fmt.Errorf("sip.dtmf.server userAgent error: %w", err)
}
userAgentString = specificUserAgentString
}
separator, ok := params["separator"]
if !ok {
return nil, errors.New("sip.dtmf.server requires a separator parameter")
}
separatorString, ok := separator.(string)
if !ok {
return nil, errors.New("sip.dtmf.server separator must be a string")
separatorString, err := params.GetString("separator")
if err != nil {
return nil, fmt.Errorf("sip.dtmf.server separator error: %w", err)
}
if len(separatorString) != 1 {
@@ -115,7 +98,7 @@ func init() {
if !strings.ContainsRune("0123456789*#ABCD", rune(separatorString[0])) {
return nil, errors.New("sip.dtmf.server separator must be a valid DTMF character")
}
return &SIPDTMFServer{config: config, IP: ipString, Port: int(portNum), Transport: transportString, UserAgent: userAgentString, Separator: separatorString, logger: CreateLogger(config)}, nil
return &SIPDTMFServer{config: moduleConfig, IP: ipString, Port: int(portNum), Transport: transportString, UserAgent: userAgentString, Separator: separatorString, logger: CreateLogger(moduleConfig)}, nil
},
})
}

40
internal/module/tcp-client.go
View File

@@ -29,27 +29,14 @@ func init() {
Type: "net.tcp.client",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
host, ok := params["host"]
if !ok {
return nil, errors.New("net.tcp.client requires a host parameter")
hostString, err := params.GetString("host")
if err != nil {
return nil, fmt.Errorf("net.tcp.client host error: %w", err)
}
hostString, ok := host.(string)
if !ok {
return nil, errors.New("net.tcp.client host must be a string")
}
port, ok := params["port"]
if !ok {
return nil, errors.New("net.tcp.client requires a port parameter")
}
portNum, ok := port.(float64)
if !ok {
return nil, errors.New("net.tcp.client port must be a number")
portNum, err := params.GetInt("port")
if err != nil {
return nil, fmt.Errorf("net.tcp.client port error: %w", err)
}
addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", hostString, uint16(portNum)))
@@ -57,22 +44,15 @@ func init() {
return nil, err
}
framingMethod, ok := params["framing"]
if !ok {
return nil, errors.New("net.tcp.client requires a framing parameter")
}
framingMethodString, ok := framingMethod.(string)
if !ok {
return nil, errors.New("net.tcp.client framing method must be a string")
framingMethodString, err := params.GetString("framing")
if err != nil {
return nil, fmt.Errorf("net.tcp.client framing error: %w", err)
}
framer := framer.GetFramer(framingMethodString)
if framer == nil {
return nil, fmt.Errorf("net.tcp.client unknown framing method: %s", framingMethod)
return nil, fmt.Errorf("net.tcp.client unknown framing method: %s", framingMethodString)
}
return &TCPClient{framer: framer, Addr: addr, config: config, logger: CreateLogger(config)}, nil
},

49
internal/module/tcp-server.go
View File

@@ -33,55 +33,38 @@ type TCPServer struct {
func init() {
RegisterModule(ModuleRegistration{
Type: "net.tcp.server",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
port, ok := params["port"]
if !ok {
return nil, errors.New("net.tcp.server requires a port parameter")
New: func(moduleConfig config.ModuleConfig) (Module, error) {
params := moduleConfig.Params
portNum, err := params.GetInt("port")
if err != nil {
return nil, fmt.Errorf("net.tcp.server port error: %w", err)
}
portNum, ok := port.(float64)
if !ok {
return nil, errors.New("net.tcp.server port must be a number")
}
framingMethod, ok := params["framing"]
if !ok {
return nil, errors.New("net.tcp.server requires a framing parameter")
}
framingMethodString, ok := framingMethod.(string)
if !ok {
return nil, errors.New("net.tcp.server framing method must be a string")
framingMethodString, err := params.GetString("framing")
if err != nil {
return nil, fmt.Errorf("net.tcp.server framing error: %w", err)
}
framer := framer.GetFramer(framingMethodString)
if framer == nil {
return nil, fmt.Errorf("net.tcp.server unknown framing method: %s", framingMethod)
return nil, fmt.Errorf("net.tcp.server unknown framing method: %s", framingMethodString)
}
ipString := "0.0.0.0"
ip, ok := params["ip"]
if ok {
specificIpString, ok := ip.(string)
if !ok {
return nil, errors.New("net.tcp.server ip must be a string")
ipString, err := params.GetString("ip")
if err != nil {
if errors.Is(err, config.ErrParamNotFound) {
ipString = "0.0.0.0"
} else {
return nil, fmt.Errorf("net.tcp.server ip error: %w", err)
}
ipString = specificIpString
}
addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", ipString, uint16(portNum)))
if err != nil {
return nil, err
}
return &TCPServer{Framer: framer, Addr: addr, config: config, quit: make(chan interface{}), logger: CreateLogger(config)}, nil
return &TCPServer{Framer: framer, Addr: addr, config: moduleConfig, quit: make(chan interface{}), logger: CreateLogger(moduleConfig)}, nil
},
})
}

4
internal/module/test/http-server_test.go
View File

@@ -43,12 +43,12 @@ func TestBadHTTPServer(t *testing.T) {
{
name: "no port param",
params: map[string]any{},
errorString: "http.server requires a port parameter",
errorString: "http.server port error: not found",
},
{
name: "non-numeric port",
params: map[string]any{"port": "3000"},
errorString: "http.server port must be a number",
errorString: "http.server port error: not a number",
},
}

4
internal/module/test/midi-input_test.go
View File

@@ -43,12 +43,12 @@ func TestBadMIDIInput(t *testing.T) {
{
name: "no port param",
params: map[string]any{},
errorString: "midi.input requires a port parameter",
errorString: "midi.input port error: not found",
},
{
name: "non-string port",
params: map[string]any{"port": 123},
errorString: "midi.input port must be a string",
errorString: "midi.input port error: not a string",
},
}

4
internal/module/test/midi-output_test.go
View File

@@ -43,12 +43,12 @@ func TestBadMIDIOutput(t *testing.T) {
{
name: "no port param",
params: map[string]any{},
errorString: "midi.output requires a port parameter",
errorString: "midi.output port error: not found",
},
{
name: "non-string port",
params: map[string]any{"port": 123},
errorString: "midi.output port must be a string",
errorString: "midi.output port error: not a string",
},
}

12
internal/module/test/mqtt-client_test.go
View File

@@ -48,7 +48,7 @@ func TestBadMQTTClient(t *testing.T) {
"topic": "test/topic",
"clientId": "test",
},
errorString: "mqtt.client requires a broker parameter",
errorString: "mqtt.client broker error: not found",
},
{
name: "non-string broker",
@@ -57,7 +57,7 @@ func TestBadMQTTClient(t *testing.T) {
"topic": "test/topic",
"clientId": "test",
},
errorString: "mqtt.client broker must be a string",
errorString: "mqtt.client broker error: not a string",
},
{
name: "no topic param",
@@ -65,7 +65,7 @@ func TestBadMQTTClient(t *testing.T) {
"broker": "mqtt://localhost:1883",
"clientId": "test",
},
errorString: "mqtt.client requires a topic parameter",
errorString: "mqtt.client topic error: not found",
},
{
name: "non-string topic",
@@ -74,7 +74,7 @@ func TestBadMQTTClient(t *testing.T) {
"topic": 123,
"clientId": "test",
},
errorString: "mqtt.client topic must be a string",
errorString: "mqtt.client topic error: not a string",
},
{
name: "no clientId param",
@@ -82,7 +82,7 @@ func TestBadMQTTClient(t *testing.T) {
"broker": "mqtt://localhost:1883",
"topic": "test/topic",
},
errorString: "mqtt.client requires a clientId parameter",
errorString: "mqtt.client clientId error: not found",
},
{
name: "non-string clientId",
@@ -91,7 +91,7 @@ func TestBadMQTTClient(t *testing.T) {
"topic": "test/topic",
"clientId": 123,
},
errorString: "mqtt.client clientId must be a string",
errorString: "mqtt.client clientId error: not a string",
},
}

8
internal/module/test/nats-client_test.go
View File

@@ -46,7 +46,7 @@ func TestBadNATSClient(t *testing.T) {
params: map[string]any{
"subject": "test/subject",
},
errorString: "nats.client requires a url parameter",
errorString: "nats.client url error: not found",
},
{
name: "non-string url",
@@ -54,14 +54,14 @@ func TestBadNATSClient(t *testing.T) {
"url": 123,
"subject": "test/subject",
},
errorString: "nats.client url must be a string",
errorString: "nats.client url error: not a string",
},
{
name: "no subject param",
params: map[string]any{
"url": "nats://127.0.0.1:4222",
},
errorString: "nats.client requires a subject parameter",
errorString: "nats.client subject error: not found",
},
{
name: "non-string subject",
@@ -69,7 +69,7 @@ func TestBadNATSClient(t *testing.T) {
"url": "nats://127.0.0.1:4222",
"subject": 123,
},
errorString: "nats.client subject must be a string",
errorString: "nats.client subject error: not a string",
},
}

2
internal/module/test/nats-server_test.go
View File

@@ -46,7 +46,7 @@ func TestBadNATSServer(t *testing.T) {
params: map[string]any{
"ip": 123,
},
errorString: "nats.server ip must be a string",
errorString: "nats.server ip error: not a string",
},
}

8
internal/module/test/serial-client_test.go
View File

@@ -47,7 +47,7 @@ func TestBadSerialClient(t *testing.T) {
params: map[string]any{
"framing": "LF",
},
errorString: "serial.client requires a port parameter",
errorString: "serial.client port error: not found",
},
{
name: "non-string port param",
@@ -55,14 +55,14 @@ func TestBadSerialClient(t *testing.T) {
"port": 8000,
"framing": "LF",
},
errorString: "serial.client port must be a string",
errorString: "serial.client port error: not a string",
},
{
name: "no framing param",
params: map[string]any{
"port": "/dev/ttyUSB0",
},
errorString: "serial.client requires a framing parameter",
errorString: "serial.client framing error: not found",
},
{
name: "non-string framing param",
@@ -70,7 +70,7 @@ func TestBadSerialClient(t *testing.T) {
"port": "/dev/ttyUSB0",
"framing": 1,
},
errorString: "serial.client framing method must be a string",
errorString: "serial.client framing error: not a string",
},
{
name: "unkown framing method",

8
internal/module/test/sip-call-server_test.go
View File

@@ -42,28 +42,28 @@ func TestBadSIPCallServer(t *testing.T) {
params: map[string]any{
"port": "8000",
},
errorString: "sip.call.server port must be a number",
errorString: "sip.call.server port error: not a number",
},
{
name: "non-string ip param",
params: map[string]any{
"ip": 123,
},
errorString: "sip.call.server ip must be a string",
errorString: "sip.call.server ip error: not a string",
},
{
name: "non-string transport param",
params: map[string]any{
"transport": 123,
},
errorString: "sip.call.server transport must be a string",
errorString: "sip.call.server transport error: not a string",
},
{
name: "non-string userAgent param",
params: map[string]any{
"userAgent": 123,
},
errorString: "sip.call.server userAgent must be a string",
errorString: "sip.call.server userAgent error: not a string",
},
}

12
internal/module/test/sip-dtmf-server_test.go
View File

@@ -43,14 +43,14 @@ func TestBadSIPDTMFServer(t *testing.T) {
{
name: "no separator param",
params: map[string]any{},
errorString: "sip.dtmf.server requires a separator parameter",
errorString: "sip.dtmf.server separator error: not found",
},
{
name: "non-string separator param",
params: map[string]any{
"separator": 123,
},
errorString: "sip.dtmf.server separator must be a string",
errorString: "sip.dtmf.server separator error: not a string",
},
{
name: "non-number port param",
@@ -58,7 +58,7 @@ func TestBadSIPDTMFServer(t *testing.T) {
"separator": "#",
"port": "8000",
},
errorString: "sip.dtmf.server port must be a number",
errorString: "sip.dtmf.server port error: not a number",
},
{
name: "non-string ip param",
@@ -66,7 +66,7 @@ func TestBadSIPDTMFServer(t *testing.T) {
"separator": "#",
"ip": 123,
},
errorString: "sip.dtmf.server ip must be a string",
errorString: "sip.dtmf.server ip error: not a string",
},
{
name: "non-string transport param",
@@ -74,7 +74,7 @@ func TestBadSIPDTMFServer(t *testing.T) {
"separator": "#",
"transport": 123,
},
errorString: "sip.dtmf.server transport must be a string",
errorString: "sip.dtmf.server transport error: not a string",
},
{
name: "non-string userAgent param",
@@ -82,7 +82,7 @@ func TestBadSIPDTMFServer(t *testing.T) {
"separator": "#",
"userAgent": 123,
},
errorString: "sip.dtmf.server userAgent must be a string",
errorString: "sip.dtmf.server userAgent error: not a string",
},
}

8
internal/module/test/tcp-client_test.go
View File

@@ -47,7 +47,7 @@ func TestBadTCPClient(t *testing.T) {
params: map[string]any{
"host": "localhost",
},
errorString: "net.tcp.client requires a port parameter",
errorString: "net.tcp.client port error: not found",
},
{
name: "non-number port param",
@@ -55,14 +55,14 @@ func TestBadTCPClient(t *testing.T) {
"host": "localhost",
"port": "8000",
},
errorString: "net.tcp.client port must be a number",
errorString: "net.tcp.client port error: not a number",
},
{
name: "no host param",
params: map[string]any{
"port": 8000.0,
},
errorString: "net.tcp.client requires a host parameter",
errorString: "net.tcp.client host error: not found",
},
{
name: "non-string host param",
@@ -70,7 +70,7 @@ func TestBadTCPClient(t *testing.T) {
"host": 123,
"port": 8000.0,
},
errorString: "net.tcp.client host must be a string",
errorString: "net.tcp.client host error: not a string",
},
}

10
internal/module/test/tcp-server_test.go
View File

@@ -46,7 +46,7 @@ func TestBadTCPServer(t *testing.T) {
params: map[string]any{
"framing": "LF",
},
errorString: "net.tcp.server requires a port parameter",
errorString: "net.tcp.server port error: not found",
},
{
name: "non-number port param",
@@ -54,14 +54,14 @@ func TestBadTCPServer(t *testing.T) {
"port": "8000",
"framing": "LF",
},
errorString: "net.tcp.server port must be a number",
errorString: "net.tcp.server port error: not a number",
},
{
name: "no framing param",
params: map[string]any{
"port": 8000.0,
},
errorString: "net.tcp.server requires a framing parameter",
errorString: "net.tcp.server framing error: not found",
},
{
name: "non-string framing param",
@@ -69,7 +69,7 @@ func TestBadTCPServer(t *testing.T) {
"port": 8000.0,
"framing": 1,
},
errorString: "net.tcp.server framing method must be a string",
errorString: "net.tcp.server framing error: not a string",
},
{
name: "unkown framing method",
@@ -86,7 +86,7 @@ func TestBadTCPServer(t *testing.T) {
"framing": "LF",
"ip": 123,
},
errorString: "net.tcp.server ip must be a string",
errorString: "net.tcp.server ip error: not a string",
},
{
name: "invalid addr",

4
internal/module/test/time-interval_test.go
View File

@@ -43,14 +43,14 @@ func TestBadTimeInterval(t *testing.T) {
{
name: "no duration param",
params: map[string]any{},
errorString: "time.interval requires a duration parameter",
errorString: "time.interval duration error: not found",
},
{
name: "non-number duration param",
params: map[string]any{
"duration": "8000",
},
errorString: "time.interval duration must be a number",
errorString: "time.interval duration error: not a number",
},
}

4
internal/module/test/time-timer_test.go
View File

@@ -43,14 +43,14 @@ func TestBadTimeTimer(t *testing.T) {
{
name: "no duration param",
params: map[string]any{},
errorString: "time.timer requires a duration parameter",
errorString: "time.timer duration error: not found",
},
{
name: "non-number duration param",
params: map[string]any{
"duration": "8000",
},
errorString: "time.timer duration must be a number",
errorString: "time.timer duration error: not a number",
},
}

8
internal/module/test/udp-client_test.go
View File

@@ -47,7 +47,7 @@ func TestBadUDPClient(t *testing.T) {
params: map[string]any{
"host": "localhost",
},
errorString: "net.udp.client requires a port parameter",
errorString: "net.udp.client port error: not found",
},
{
name: "non-number port param",
@@ -55,14 +55,14 @@ func TestBadUDPClient(t *testing.T) {
"host": "localhost",
"port": "8000",
},
errorString: "net.udp.client port must be a number",
errorString: "net.udp.client port error: not a number",
},
{
name: "no host param",
params: map[string]any{
"port": 8000.0,
},
errorString: "net.udp.client requires a host parameter",
errorString: "net.udp.client host error: not found",
},
{
name: "non-string host param",
@@ -70,7 +70,7 @@ func TestBadUDPClient(t *testing.T) {
"host": 123,
"port": 8000.0,
},
errorString: "net.udp.client host must be a string",
errorString: "net.udp.client host error: not a string",
},
}

8
internal/module/test/udp-multicast_test.go
View File

@@ -46,7 +46,7 @@ func TestBadUDPMulticast(t *testing.T) {
params: map[string]any{
"ip": "localhost",
},
errorString: "net.udp.multicast requires a port parameter",
errorString: "net.udp.multicast port error: not found",
},
{
name: "non-number port param",
@@ -54,14 +54,14 @@ func TestBadUDPMulticast(t *testing.T) {
"ip": "localhost",
"port": "8000",
},
errorString: "net.udp.multicast port must be a number",
errorString: "net.udp.multicast port error: not a number",
},
{
name: "no ip param",
params: map[string]any{
"port": 8000.0,
},
errorString: "net.udp.multicast requires an ip parameter",
errorString: "net.udp.multicast ip error: not found",
},
{
name: "non-string ip param",
@@ -69,7 +69,7 @@ func TestBadUDPMulticast(t *testing.T) {
"ip": 123,
"port": 8000.0,
},
errorString: "net.udp.multicast ip must be a string",
errorString: "net.udp.multicast ip error: not a string",
},
{
name: "invalid addr",

8
internal/module/test/udp-server_test.go
View File

@@ -43,14 +43,14 @@ func TestBadUDPServer(t *testing.T) {
{
name: "no port param",
params: map[string]any{},
errorString: "net.udp.server requires a port parameter",
errorString: "net.udp.server port error: not found",
},
{
name: "non-number port param",
params: map[string]any{
"port": "8000",
},
errorString: "net.udp.server port must be a number",
errorString: "net.udp.server port error: not a number",
},
{
name: "non-string ip param",
@@ -58,7 +58,7 @@ func TestBadUDPServer(t *testing.T) {
"port": 8000.0,
"ip": 123,
},
errorString: "net.udp.server ip must be a string",
errorString: "net.udp.server ip error: not a string",
},
{
name: "non-number bufferSize param",
@@ -66,7 +66,7 @@ func TestBadUDPServer(t *testing.T) {
"port": 8000.0,
"bufferSize": "1024",
},
errorString: "net.udp.server bufferSize must be a number",
errorString: "net.udp.server bufferSize error: not a number",
},
{
name: "invalid addr",

15
internal/module/time-interval.go
View File

@@ -3,6 +3,7 @@ package module
import (
"context"
"errors"
"fmt"
"log/slog"
"time"
@@ -26,17 +27,11 @@ func init() {
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
duration, ok := params["duration"]
if !ok {
return nil, errors.New("time.interval requires a duration parameter")
durationInt, err := params.GetInt("duration")
if err != nil {
return nil, fmt.Errorf("time.interval duration error: %w", err)
}
durationNum, ok := duration.(float64)
if !ok {
return nil, errors.New("time.interval duration must be a number")
}
return &TimeInterval{Duration: uint32(durationNum), config: config, logger: CreateLogger(config)}, nil
return &TimeInterval{Duration: uint32(durationInt), config: config, logger: CreateLogger(config)}, nil
},
})
}

13
internal/module/time-timer.go
View File

@@ -3,6 +3,7 @@ package module
import (
"context"
"errors"
"fmt"
"log/slog"
"time"
@@ -26,15 +27,9 @@ func init() {
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
duration, ok := params["duration"]
if !ok {
return nil, errors.New("time.timer requires a duration parameter")
}
durationNum, ok := duration.(float64)
if !ok {
return nil, errors.New("time.timer duration must be a number")
durationNum, err := params.GetInt("duration")
if err != nil {
return nil, fmt.Errorf("time.timer duration error: %w", err)
}
return &TimeTimer{Duration: uint32(durationNum), config: config, logger: CreateLogger(config)}, nil

25
internal/module/udp-client.go
View File

@@ -27,27 +27,14 @@ func init() {
Type: "net.udp.client",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
host, ok := params["host"]
if !ok {
return nil, errors.New("net.udp.client requires a host parameter")
hostString, err := params.GetString("host")
if err != nil {
return nil, fmt.Errorf("net.udp.client host error: %w", err)
}
hostString, ok := host.(string)
if !ok {
return nil, errors.New("net.udp.client host must be a string")
}
port, ok := params["port"]
if !ok {
return nil, errors.New("net.udp.client requires a port parameter")
}
portNum, ok := port.(float64)
if !ok {
return nil, errors.New("net.udp.client port must be a number")
portNum, err := params.GetInt("port")
if err != nil {
return nil, fmt.Errorf("net.udp.client port error: %w", err)
}
addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", hostString, uint16(portNum)))

31
internal/module/udp-multicast.go
View File

@@ -25,36 +25,23 @@ type UDPMulticast struct {
func init() {
RegisterModule(ModuleRegistration{
Type: "net.udp.multicast",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
ip, ok := params["ip"]
if !ok {
return nil, errors.New("net.udp.multicast requires an ip parameter")
New: func(moduleConfig config.ModuleConfig) (Module, error) {
params := moduleConfig.Params
ipString, err := params.GetString("ip")
if err != nil {
return nil, fmt.Errorf("net.udp.multicast ip error: %w", err)
}
ipString, ok := ip.(string)
if !ok {
return nil, errors.New("net.udp.multicast ip must be a string")
}
port, ok := params["port"]
if !ok {
return nil, errors.New("net.udp.multicast requires a port parameter")
}
portNum, ok := port.(float64)
if !ok {
return nil, errors.New("net.udp.multicast port must be a number")
portNum, err := params.GetInt("port")
if err != nil {
return nil, fmt.Errorf("net.udp.multicast port error: %w", err)
}
addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", ipString, uint16(portNum)))
if err != nil {
return nil, err
}
return &UDPMulticast{config: config, Addr: addr, logger: CreateLogger(config)}, nil
return &UDPMulticast{config: moduleConfig, Addr: addr, logger: CreateLogger(moduleConfig)}, nil
},
})
}

49
internal/module/udp-server.go
View File

@@ -25,30 +25,20 @@ type UDPServer struct {
func init() {
RegisterModule(ModuleRegistration{
Type: "net.udp.server",
New: func(config config.ModuleConfig) (Module, error) {
params := config.Params
port, ok := params["port"]
if !ok {
return nil, errors.New("net.udp.server requires a port parameter")
New: func(moduleConfig config.ModuleConfig) (Module, error) {
params := moduleConfig.Params
portNum, err := params.GetInt("port")
if err != nil {
return nil, fmt.Errorf("net.udp.server port error: %w", err)
}
portNum, ok := port.(float64)
if !ok {
return nil, errors.New("net.udp.server port must be a number")
}
ipString := "0.0.0.0"
ip, ok := params["ip"]
if ok {
specificIpString, ok := ip.(string)
if !ok {
return nil, errors.New("net.udp.server ip must be a string")
ipString, err := params.GetString("ip")
if err != nil {
if errors.Is(err, config.ErrParamNotFound) {
ipString = "0.0.0.0"
} else {
return nil, fmt.Errorf("net.udp.server ip error: %w", err)
}
ipString = specificIpString
}
addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", ipString, uint16(portNum)))
@@ -56,18 +46,15 @@ func init() {
return nil, err
}
bufferSizeNum := 2048
bufferSize, ok := params["bufferSize"]
if ok {
bufferSizeFloat, ok := bufferSize.(float64)
if !ok {
return nil, errors.New("net.udp.server bufferSize must be a number")
bufferSizeNum, err := params.GetInt("bufferSize")
if err != nil {
if errors.Is(err, config.ErrParamNotFound) {
bufferSizeNum = 2048
} else {
return nil, fmt.Errorf("net.udp.server bufferSize error: %w", err)
}
bufferSizeNum = int(bufferSizeFloat)
}
return &UDPServer{Addr: addr, BufferSize: bufferSizeNum, config: config, logger: CreateLogger(config)}, nil
return &UDPServer{Addr: addr, BufferSize: bufferSizeNum, config: moduleConfig, logger: CreateLogger(moduleConfig)}, nil
},
})
}