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

split out from net and misc module namespaces

Browse Source
This commit is contained in:
Joel Wetzell
2025-12-11 19:34:57 -06:00
parent b59da597ba
commit 00f78b5a50
7 changed files with 49 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
internal/module/http-client.go
View File

@@ -20,7 +20,7 @@ type HTTPClient struct {
func init() {
RegisterModule(ModuleRegistration{
Type: "net.http.client",
Type: "http.client",
New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
return &HTTPClient{config: config, ctx: ctx, router: router}, nil
@@ -52,11 +52,11 @@ func (hc *HTTPClient) Output(payload any) error {
payloadRequest, ok := payload.(*http.Request)
if !ok {
return fmt.Errorf("net.http.client is only able to output an http.Request")
return fmt.Errorf("http.client is only able to output an http.Request")
}
if hc.client == nil {
return fmt.Errorf("net.http.client client is nil")
return fmt.Errorf("http.client client is nil")
}
response, err := hc.client.Do(payloadRequest)

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

@@ -25,18 +25,18 @@ type ResponseData struct {
func init() {
RegisterModule(ModuleRegistration{
Type: "net.http.server",
Type: "http.server",
New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
params := config.Params
port, ok := params["port"]
if !ok {
return nil, fmt.Errorf("net.http.server requires a port parameter")
return nil, fmt.Errorf("http.server requires a port parameter")
}
portNum, ok := port.(float64)
if !ok {
return nil, fmt.Errorf("net.http.server port must be uint16")
return nil, fmt.Errorf("http.server port must be uint16")
}
return &HTTPServer{Port: uint16(portNum), config: config, ctx: ctx, router: router}, nil
@@ -94,7 +94,7 @@ func (hs *HTTPServer) Run() error {
}()
err := httpServer.ListenAndServe()
slog.Debug("net.http.server closed", "id", hs.Id())
slog.Debug("http.server closed", "id", hs.Id())
// TODO(jwetzell): handle server closed error differently
if err != nil {
return err
@@ -105,5 +105,5 @@ func (hs *HTTPServer) Run() error {
}
func (hs *HTTPServer) Output(payload any) error {
return fmt.Errorf("net.http.server output is not implemented")
return fmt.Errorf("http.server output is not implemented")
}

18
internal/module/midi-client.go
View File

@@ -25,31 +25,31 @@ type MIDIClient struct {
func init() {
RegisterModule(ModuleRegistration{
//TODO(jwetzell): find a better namespace than "misc"
Type: "misc.midi.client",
Type: "midi.client",
New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
params := config.Params
input, ok := params["input"]
if !ok {
return nil, fmt.Errorf("misc.midi.client requires a input parameter")
return nil, fmt.Errorf("midi.client requires a input parameter")
}
inputString, ok := input.(string)
if !ok {
return nil, fmt.Errorf("misc.midi.client input must be a string")
return nil, fmt.Errorf("midi.client input must be a string")
}
output, ok := params["output"]
if !ok {
return nil, fmt.Errorf("misc.midi.client requires a output parameter")
return nil, fmt.Errorf("midi.client requires a output parameter")
}
outputString, ok := output.(string)
if !ok {
return nil, fmt.Errorf("misc.midi.client output must be a string")
return nil, fmt.Errorf("midi.client output must be a string")
}
return &MIDIClient{config: config, InputPort: inputString, OutputPort: outputString, ctx: ctx, router: router}, nil
@@ -70,7 +70,7 @@ func (mc *MIDIClient) Run() error {
in, err := midi.FindInPort(mc.InputPort)
if err != nil {
return fmt.Errorf("misc.midi.client can't find input port: %s", mc.InputPort)
return fmt.Errorf("midi.client can't find input port: %s", mc.InputPort)
}
stop, err := midi.ListenTo(in, func(msg midi.Message, timestampms int32) {
@@ -89,7 +89,7 @@ func (mc *MIDIClient) Run() error {
out, err := midi.FindOutPort(mc.OutputPort)
if err != nil {
return fmt.Errorf("misc.midi.client can't find output port: %s", mc.OutputPort)
return fmt.Errorf("midi.client can't find output port: %s", mc.OutputPort)
}
send, err := midi.SendTo(out)
@@ -106,13 +106,13 @@ func (mc *MIDIClient) Run() error {
func (mc *MIDIClient) Output(payload any) error {
if mc.SendFunc == nil {
return fmt.Errorf("misc.midi.client output is not setup")
return fmt.Errorf("midi.client output is not setup")
}
payloadMessage, ok := payload.(midi.Message)
if !ok {
return fmt.Errorf("misc.midi.client can only ouptut midi.Message")
return fmt.Errorf("midi.client can only ouptut midi.Message")
}
return mc.SendFunc(payloadMessage)

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

@@ -22,43 +22,43 @@ type MQTTClient struct {
func init() {
RegisterModule(ModuleRegistration{
Type: "net.mqtt.client",
Type: "mqtt.client",
New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
params := config.Params
broker, ok := params["broker"]
if !ok {
return nil, fmt.Errorf("net.mqtt.client requires a broker parameter")
return nil, fmt.Errorf("mqtt.client requires a broker parameter")
}
brokerString, ok := broker.(string)
if !ok {
return nil, fmt.Errorf("net.mqtt.client broker must be string")
return nil, fmt.Errorf("mqtt.client broker must be string")
}
topic, ok := params["topic"]
if !ok {
return nil, fmt.Errorf("net.mqtt.client requires a topic parameter")
return nil, fmt.Errorf("mqtt.client requires a topic parameter")
}
topicString, ok := topic.(string)
if !ok {
return nil, fmt.Errorf("net.mqtt.client topic must be string")
return nil, fmt.Errorf("mqtt.client topic must be string")
}
clientId, ok := params["clientId"]
if !ok {
return nil, fmt.Errorf("net.mqtt.client requires a clientId parameter")
return nil, fmt.Errorf("mqtt.client requires a clientId parameter")
}
clientIdString, ok := clientId.(string)
if !ok {
return nil, fmt.Errorf("net.mqtt.client clientId must be string")
return nil, fmt.Errorf("mqtt.client clientId must be string")
}
return &MQTTClient{config: config, Broker: brokerString, Topic: topicString, ClientID: clientIdString, ctx: ctx, router: router}, nil
@@ -109,15 +109,15 @@ func (mc *MQTTClient) Output(payload any) error {
fmt.Printf("payload type: %T\n", payload)
if !ok {
return fmt.Errorf("net.mqtt.client is only able to output a MQTTMessage")
return fmt.Errorf("mqtt.client is only able to output a MQTTMessage")
}
if mc.client == nil {
return fmt.Errorf("net.mqtt.client client is not setup")
return fmt.Errorf("mqtt.client client is not setup")
}
if !mc.client.IsConnected() {
return fmt.Errorf("net.mqtt.client is not connected")
return fmt.Errorf("mqtt.client is not connected")
}
token := mc.client.Publish(payloadMessage.Topic(), payloadMessage.Qos(), payloadMessage.Retained(), payloadMessage.Payload())

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

@@ -22,31 +22,31 @@ type NATSClient struct {
func init() {
RegisterModule(ModuleRegistration{
Type: "net.nats.client",
Type: "nats.client",
New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
params := config.Params
url, ok := params["url"]
if !ok {
return nil, fmt.Errorf("net.nats.client requires a url parameter")
return nil, fmt.Errorf("nats.client requires a url parameter")
}
urlString, ok := url.(string)
if !ok {
return nil, fmt.Errorf("net.nats.client url must be string")
return nil, fmt.Errorf("nats.client url must be string")
}
subject, ok := params["subject"]
if !ok {
return nil, fmt.Errorf("net.nats.client requires a subject parameter")
return nil, fmt.Errorf("nats.client requires a subject parameter")
}
subjectString, ok := subject.(string)
if !ok {
return nil, fmt.Errorf("net.nats.client subject must be string")
return nil, fmt.Errorf("nats.client subject must be string")
}
return &NATSClient{config: config, URL: urlString, Subject: subjectString, ctx: ctx, router: router}, nil
@@ -96,15 +96,15 @@ func (nc *NATSClient) Output(payload any) error {
payloadMessage, ok := payload.(processor.NATSMessage)
if !ok {
return fmt.Errorf("net.nats.client is only able to output NATSMessage")
return fmt.Errorf("nats.client is only able to output NATSMessage")
}
if nc.client == nil {
return fmt.Errorf("net.nats.client client is not setup")
return fmt.Errorf("nats.client client is not setup")
}
if !nc.client.IsConnected() {
return fmt.Errorf("net.nats.client is not connected")
return fmt.Errorf("nats.client is not connected")
}
err := nc.client.Publish(payloadMessage.Subject, payloadMessage.Payload)

8
internal/module/psn-client.go
View File

@@ -22,7 +22,7 @@ type PSNClient struct {
func init() {
RegisterModule(ModuleRegistration{
Type: "net.psn.client",
Type: "psn.client",
New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
return &PSNClient{config: config, decoder: psn.NewDecoder(), ctx: ctx, router: router}, nil
@@ -76,7 +76,7 @@ func (pc *PSNClient) Run() error {
message := buffer[:numBytes]
err := pc.decoder.Decode(message)
if err != nil {
slog.Error("net.psn.client problem decoding psn traffic", "id", pc.Id(), "error", err)
slog.Error("psn.client problem decoding psn traffic", "id", pc.Id(), "error", err)
}
if pc.router != nil {
@@ -84,7 +84,7 @@ func (pc *PSNClient) Run() error {
pc.router.HandleInput(pc.Id(), tracker)
}
} else {
slog.Error("net.psn.client has no router", "id", pc.Id())
slog.Error("psn.client has no router", "id", pc.Id())
}
}
}
@@ -92,5 +92,5 @@ func (pc *PSNClient) Run() error {
}
func (pc *PSNClient) Output(payload any) error {
return fmt.Errorf("net.psn.client output is not implemented")
return fmt.Errorf("psn.client output is not implemented")
}

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

@@ -27,19 +27,19 @@ type SerialClient struct {
func init() {
RegisterModule(ModuleRegistration{
//TODO(jwetzell): find a better namespace than "misc"
Type: "misc.serial.client",
Type: "serial.client",
New: func(ctx context.Context, config config.ModuleConfig, router route.RouteIO) (Module, error) {
params := config.Params
port, ok := params["port"]
if !ok {
return nil, fmt.Errorf("misc.serial.client requires a port parameter")
return nil, fmt.Errorf("serial.client requires a port parameter")
}
portString, ok := port.(string)
if !ok {
return nil, fmt.Errorf("misc.serial.client port must be a string")
return nil, fmt.Errorf("serial.client port must be a string")
}
framingMethod := "RAW"
@@ -50,7 +50,7 @@ func init() {
framingMethodString, ok := framingMethodRaw.(string)
if !ok {
return nil, fmt.Errorf("misc.serial.client framing method must be a string")
return nil, fmt.Errorf("serial.client framing method must be a string")
}
framingMethod = framingMethodString
}
@@ -63,12 +63,12 @@ func init() {
buadRate, ok := params["baudRate"]
if !ok {
return nil, fmt.Errorf("misc.serial.client requires a baudRate parameter")
return nil, fmt.Errorf("serial.client requires a baudRate parameter")
}
baudRateNum, ok := buadRate.(float64)
if !ok {
return nil, fmt.Errorf("misc.serial.client baudRate must be a number")
return nil, fmt.Errorf("serial.client baudRate must be a number")
}
mode := serial.Mode{
@@ -92,7 +92,7 @@ func (mc *SerialClient) SetupPort() error {
port, err := serial.Open(mc.Port, mc.Mode)
if err != nil {
return fmt.Errorf("misc.serial.client can't open input port: %s", mc.Port)
return fmt.Errorf("serial.client can't open input port: %s", mc.Port)
}
mc.port = port
@@ -118,7 +118,7 @@ func (mc *SerialClient) Run() error {
slog.Debug("router context done in module", "id", mc.Id())
return nil
}
slog.Error("misc.serial.client", "id", mc.Id(), "error", err.Error())
slog.Error("serial.client", "id", mc.Id(), "error", err.Error())
time.Sleep(time.Second * 2)
continue
}
@@ -150,7 +150,7 @@ func (mc *SerialClient) Run() error {
if mc.router != nil {
mc.router.HandleInput(mc.Id(), message)
} else {
slog.Error("misc.serial.client has no router", "id", mc.Id())
slog.Error("serial.client has no router", "id", mc.Id())
}
}
}
@@ -166,7 +166,7 @@ func (mc *SerialClient) Output(payload any) error {
payloadBytes, ok := payload.([]byte)
if !ok {
return fmt.Errorf("misc.serial.client can only ouptut bytes")
return fmt.Errorf("serial.client can only ouptut bytes")
}
_, err := mc.port.Write(mc.Framer.Encode(payloadBytes))