From ff1949ce69329d506ed179e5716ac108af5483f3 Mon Sep 17 00:00:00 2001 From: Joel Wetzell Date: Tue, 23 Dec 2025 15:00:30 -0600 Subject: [PATCH] use errors.New when not formatting --- cmd/showbridge/main.go | 4 +- internal/module/http-client.go | 6 +-- internal/module/http-server.go | 7 ++-- internal/module/interval.go | 6 +-- internal/module/midi-input.go | 7 ++-- internal/module/midi-ouptut.go | 9 +++-- internal/module/mqtt-client.go | 19 ++++----- internal/module/nats-client.go | 16 ++++---- internal/module/serial-client.go | 13 +++--- internal/module/sip-call-server.go | 23 ++++++----- internal/module/sip-dtmf-server.go | 18 ++++----- internal/module/tcp-client.go | 13 +++--- internal/module/tcp-server.go | 12 +++--- internal/module/timer.go | 6 +-- internal/module/udp-client.go | 13 +++--- internal/module/udp-multicast.go | 13 +++--- internal/module/udp-server.go | 9 +++-- internal/processor/float-parse.go | 4 +- internal/processor/free-d-create.go | 38 ++++++++--------- internal/processor/free-d-decode.go | 4 +- internal/processor/free-d-encode.go | 4 +- internal/processor/http-request-create.go | 10 ++--- internal/processor/http-request-encode.go | 4 +- internal/processor/http-request-filter.go | 9 +++-- internal/processor/http-response-encode.go | 4 +- internal/processor/int-parse.go | 4 +- internal/processor/midi-message-create.go | 45 +++++++++++---------- internal/processor/midi-message-decode.go | 4 +- internal/processor/midi-message-encode.go | 4 +- internal/processor/midi-message-filter.go | 8 ++-- internal/processor/midi-message-unpack.go | 3 +- internal/processor/mqtt-message-create.go | 18 ++++----- internal/processor/mqtt-message-encode.go | 4 +- internal/processor/nats-message-create.go | 10 ++--- internal/processor/nats-message-encode.go | 4 +- internal/processor/osc-message-create.go | 17 ++++---- internal/processor/osc-message-decode.go | 8 ++-- internal/processor/osc-message-encode.go | 4 +- internal/processor/osc-message-filter.go | 7 ++-- internal/processor/osc-message-transform.go | 12 +++--- internal/processor/script-expr.go | 6 +-- internal/processor/script-js.go | 6 +-- internal/processor/string-create.go | 6 +-- internal/processor/string-decode.go | 4 +- internal/processor/string-encode.go | 4 +- internal/processor/string-filter.go | 8 ++-- internal/processor/string-split.go | 8 ++-- internal/processor/uint-parse.go | 4 +- router.go | 5 ++- 49 files changed, 245 insertions(+), 229 deletions(-) diff --git a/cmd/showbridge/main.go b/cmd/showbridge/main.go index d20b66e..e2eb34c 100644 --- a/cmd/showbridge/main.go +++ b/cmd/showbridge/main.go @@ -2,7 +2,7 @@ package main import ( "context" - "fmt" + "errors" "log/slog" "os" "os/signal" @@ -42,7 +42,7 @@ func main() { Action: func(ctx context.Context, c *cli.Command) error { configPath := c.String("config") if configPath == "" { - return fmt.Errorf("config value cannot be empty") + return errors.New("config value cannot be empty") } config, err := readConfig(configPath) diff --git a/internal/module/http-client.go b/internal/module/http-client.go index 32f7c9f..93639dc 100644 --- a/internal/module/http-client.go +++ b/internal/module/http-client.go @@ -2,7 +2,7 @@ package module import ( "context" - "fmt" + "errors" "log/slog" "net/http" "time" @@ -53,11 +53,11 @@ func (hc *HTTPClient) Output(payload any) error { payloadRequest, ok := payload.(*http.Request) if !ok { - return fmt.Errorf("http.client is only able to output an http.Request") + return errors.New("http.client is only able to output an http.Request") } if hc.client == nil { - return fmt.Errorf("http.client client is nil") + return errors.New("http.client client is nil") } response, err := hc.client.Do(payloadRequest) diff --git a/internal/module/http-server.go b/internal/module/http-server.go index f16055c..b0b24c0 100644 --- a/internal/module/http-server.go +++ b/internal/module/http-server.go @@ -3,6 +3,7 @@ package module import ( "context" "encoding/json" + "errors" "fmt" "log/slog" "net/http" @@ -31,13 +32,13 @@ func init() { params := config.Params port, ok := params["port"] if !ok { - return nil, fmt.Errorf("http.server requires a port parameter") + return nil, errors.New("http.server requires a port parameter") } portNum, ok := port.(float64) if !ok { - return nil, fmt.Errorf("http.server port must be uint16") + return nil, errors.New("http.server port must be uint16") } return &HTTPServer{Port: uint16(portNum), config: config, ctx: ctx, router: router, logger: slog.Default().With("component", "module", "id", config.Id)}, nil @@ -105,5 +106,5 @@ func (hs *HTTPServer) Run() error { } func (hs *HTTPServer) Output(payload any) error { - return fmt.Errorf("http.server output is not implemented") + return errors.New("http.server output is not implemented") } diff --git a/internal/module/interval.go b/internal/module/interval.go index 2ebbf52..a9f277c 100644 --- a/internal/module/interval.go +++ b/internal/module/interval.go @@ -2,7 +2,7 @@ package module import ( "context" - "fmt" + "errors" "log/slog" "time" @@ -27,13 +27,13 @@ func init() { duration, ok := params["duration"] if !ok { - return nil, fmt.Errorf("gen.interval requires a duration parameter") + return nil, errors.New("gen.interval requires a duration parameter") } durationNum, ok := duration.(float64) if !ok { - return nil, fmt.Errorf("gen.interval duration must be number") + return nil, errors.New("gen.interval duration must be number") } return &Interval{Duration: uint32(durationNum), config: config, ctx: ctx, router: router, logger: slog.Default().With("component", "module", "id", config.Id)}, nil diff --git a/internal/module/midi-input.go b/internal/module/midi-input.go index 0a63d7e..247c77b 100644 --- a/internal/module/midi-input.go +++ b/internal/module/midi-input.go @@ -4,6 +4,7 @@ package module import ( "context" + "errors" "fmt" "log/slog" @@ -30,13 +31,13 @@ func init() { port, ok := params["port"] if !ok { - return nil, fmt.Errorf("midi.input requires a port parameter") + return nil, errors.New("midi.input requires a port parameter") } portString, ok := port.(string) if !ok { - return nil, fmt.Errorf("midi.input port must be a string") + return nil, errors.New("midi.input port must be a string") } return &MIDIInput{config: config, Port: portString, ctx: ctx, router: router, logger: slog.Default().With("component", "module", "id", config.Id)}, nil @@ -78,5 +79,5 @@ func (mi *MIDIInput) Run() error { } func (mi *MIDIInput) Output(payload any) error { - return fmt.Errorf("midi.input output is not implemented") + return errors.New("midi.input output is not implemented") } diff --git a/internal/module/midi-ouptut.go b/internal/module/midi-ouptut.go index dc78529..9cc60cc 100644 --- a/internal/module/midi-ouptut.go +++ b/internal/module/midi-ouptut.go @@ -4,6 +4,7 @@ package module import ( "context" + "errors" "fmt" "log/slog" @@ -31,13 +32,13 @@ func init() { port, ok := params["port"] if !ok { - return nil, fmt.Errorf("midi.output requires a port parameter") + return nil, errors.New("midi.output requires a port parameter") } portString, ok := port.(string) if !ok { - return nil, fmt.Errorf("midi.output port must be a string") + return nil, errors.New("midi.output port must be a string") } return &MIDIOutput{config: config, Port: portString, ctx: ctx, router: router, logger: slog.Default().With("component", "module", "id", config.Id)}, nil @@ -76,13 +77,13 @@ func (mo *MIDIOutput) Run() error { func (mo *MIDIOutput) Output(payload any) error { if mo.SendFunc == nil { - return fmt.Errorf("midi.output output is not setup") + return errors.New("midi.output output is not setup") } payloadMessage, ok := payload.(midi.Message) if !ok { - return fmt.Errorf("midi.output can only ouptut midi.Message") + return errors.New("midi.output can only ouptut midi.Message") } return mo.SendFunc(payloadMessage) diff --git a/internal/module/mqtt-client.go b/internal/module/mqtt-client.go index 6970fd9..8f8d999 100644 --- a/internal/module/mqtt-client.go +++ b/internal/module/mqtt-client.go @@ -2,6 +2,7 @@ package module import ( "context" + "errors" "fmt" "log/slog" @@ -29,37 +30,37 @@ func init() { broker, ok := params["broker"] if !ok { - return nil, fmt.Errorf("mqtt.client requires a broker parameter") + return nil, errors.New("mqtt.client requires a broker parameter") } brokerString, ok := broker.(string) if !ok { - return nil, fmt.Errorf("mqtt.client broker must be string") + return nil, errors.New("mqtt.client broker must be string") } topic, ok := params["topic"] if !ok { - return nil, fmt.Errorf("mqtt.client requires a topic parameter") + return nil, errors.New("mqtt.client requires a topic parameter") } topicString, ok := topic.(string) if !ok { - return nil, fmt.Errorf("mqtt.client topic must be string") + return nil, errors.New("mqtt.client topic must be string") } clientId, ok := params["clientId"] if !ok { - return nil, fmt.Errorf("mqtt.client requires a clientId parameter") + return nil, errors.New("mqtt.client requires a clientId parameter") } clientIdString, ok := clientId.(string) if !ok { - return nil, fmt.Errorf("mqtt.client clientId must be string") + return nil, errors.New("mqtt.client clientId must be string") } return &MQTTClient{config: config, Broker: brokerString, Topic: topicString, ClientID: clientIdString, ctx: ctx, router: router, logger: slog.Default().With("component", "module", "id", config.Id)}, nil @@ -110,15 +111,15 @@ func (mc *MQTTClient) Output(payload any) error { fmt.Printf("payload type: %T\n", payload) if !ok { - return fmt.Errorf("mqtt.client is only able to output a MQTTMessage") + return errors.New("mqtt.client is only able to output a MQTTMessage") } if mc.client == nil { - return fmt.Errorf("mqtt.client client is not setup") + return errors.New("mqtt.client client is not setup") } if !mc.client.IsConnected() { - return fmt.Errorf("mqtt.client is not connected") + return errors.New("mqtt.client is not connected") } token := mc.client.Publish(payloadMessage.Topic(), payloadMessage.Qos(), payloadMessage.Retained(), payloadMessage.Payload()) diff --git a/internal/module/nats-client.go b/internal/module/nats-client.go index 4416f1f..5f2a0ff 100644 --- a/internal/module/nats-client.go +++ b/internal/module/nats-client.go @@ -2,7 +2,7 @@ package module import ( "context" - "fmt" + "errors" "log/slog" "github.com/jwetzell/showbridge-go/internal/config" @@ -29,25 +29,25 @@ func init() { url, ok := params["url"] if !ok { - return nil, fmt.Errorf("nats.client requires a url parameter") + return nil, errors.New("nats.client requires a url parameter") } urlString, ok := url.(string) if !ok { - return nil, fmt.Errorf("nats.client url must be string") + return nil, errors.New("nats.client url must be string") } subject, ok := params["subject"] if !ok { - return nil, fmt.Errorf("nats.client requires a subject parameter") + return nil, errors.New("nats.client requires a subject parameter") } subjectString, ok := subject.(string) if !ok { - return nil, fmt.Errorf("nats.client subject must be string") + return nil, errors.New("nats.client subject must be string") } return &NATSClient{config: config, URL: urlString, Subject: subjectString, ctx: ctx, router: router, logger: slog.Default().With("component", "module", "id", config.Id)}, nil @@ -97,15 +97,15 @@ func (nc *NATSClient) Output(payload any) error { payloadMessage, ok := payload.(processor.NATSMessage) if !ok { - return fmt.Errorf("nats.client is only able to output NATSMessage") + return errors.New("nats.client is only able to output NATSMessage") } if nc.client == nil { - return fmt.Errorf("nats.client client is not setup") + return errors.New("nats.client client is not setup") } if !nc.client.IsConnected() { - return fmt.Errorf("nats.client is not connected") + return errors.New("nats.client is not connected") } err := nc.client.Publish(payloadMessage.Subject, payloadMessage.Payload) diff --git a/internal/module/serial-client.go b/internal/module/serial-client.go index 1b2c337..dd4a0c8 100644 --- a/internal/module/serial-client.go +++ b/internal/module/serial-client.go @@ -4,6 +4,7 @@ package module import ( "context" + "errors" "fmt" "log/slog" "time" @@ -33,13 +34,13 @@ func init() { port, ok := params["port"] if !ok { - return nil, fmt.Errorf("serial.client requires a port parameter") + return nil, errors.New("serial.client requires a port parameter") } portString, ok := port.(string) if !ok { - return nil, fmt.Errorf("serial.client port must be a string") + return nil, errors.New("serial.client port must be a string") } framingMethod := "RAW" @@ -50,7 +51,7 @@ func init() { framingMethodString, ok := framingMethodRaw.(string) if !ok { - return nil, fmt.Errorf("serial.client framing method must be a string") + return nil, errors.New("serial.client framing method must be a string") } framingMethod = framingMethodString } @@ -63,12 +64,12 @@ func init() { buadRate, ok := params["baudRate"] if !ok { - return nil, fmt.Errorf("serial.client requires a baudRate parameter") + return nil, errors.New("serial.client requires a baudRate parameter") } baudRateNum, ok := buadRate.(float64) if !ok { - return nil, fmt.Errorf("serial.client baudRate must be a number") + return nil, errors.New("serial.client baudRate must be a number") } mode := serial.Mode{ @@ -166,7 +167,7 @@ func (sc *SerialClient) Output(payload any) error { payloadBytes, ok := payload.([]byte) if !ok { - return fmt.Errorf("serial.client can only ouptut bytes") + return errors.New("serial.client can only ouptut bytes") } _, err := sc.port.Write(sc.Framer.Encode(payloadBytes)) diff --git a/internal/module/sip-call-server.go b/internal/module/sip-call-server.go index 9f9181b..f25e7a5 100644 --- a/internal/module/sip-call-server.go +++ b/internal/module/sip-call-server.go @@ -2,6 +2,7 @@ package module import ( "context" + "errors" "fmt" "io" "log/slog" @@ -43,7 +44,7 @@ func init() { specificPortNum, ok := port.(float64) if !ok { - return nil, fmt.Errorf("sip.call.server port must be a number") + return nil, errors.New("sip.call.server port must be a number") } portNum = int(specificPortNum) } @@ -56,7 +57,7 @@ func init() { specificIpString, ok := ip.(string) if !ok { - return nil, fmt.Errorf("sip.call.server ip must be a string") + return nil, errors.New("sip.call.server ip must be a string") } ipString = specificIpString } @@ -69,7 +70,7 @@ func init() { specificTransportString, ok := transport.(string) if !ok { - return nil, fmt.Errorf("sip.call.server transport must be a string") + return nil, errors.New("sip.call.server transport must be a string") } transportString = specificTransportString } @@ -82,7 +83,7 @@ func init() { specificTransportString, ok := userAgent.(string) if !ok { - return nil, fmt.Errorf("sip.call.server userAgent must be a string") + return nil, errors.New("sip.call.server userAgent must be a string") } userAgentString = specificTransportString } @@ -146,41 +147,41 @@ func (scs *SIPCallServer) Output(payload any) error { payloadMsg, ok := payload.(string) if !ok { - return fmt.Errorf("sip.call.server output payload must be of type string") + return errors.New("sip.call.server output payload must be of type string") } if scs.dg == nil { - return fmt.Errorf("sip.call.server diago is not initialized") + return errors.New("sip.call.server diago is not initialized") } var uri sip.Uri err := sip.ParseUri(payloadMsg, &uri) if err != nil { - return fmt.Errorf("sip.call.server output payload is not a valid SIP URI: %v", err) + return fmt.Errorf("sip.call.server output payload is not a valid SIP URI: %s", err) } outDialog, err := scs.dg.NewDialog(uri, diago.NewDialogOptions{ Transport: scs.Transport, }) if err != nil { - return fmt.Errorf("sip.call.server failed to create new dialog: %v", err) + return fmt.Errorf("sip.call.server failed to create new dialog: %s", err) } err = outDialog.Invite(scs.ctx, diago.InviteClientOptions{}) if err != nil { - return fmt.Errorf("sip.call.server failed to send invite: %v", err) + return fmt.Errorf("sip.call.server failed to send invite: %s", err) } err = outDialog.Ack(scs.ctx) if err != nil { - return fmt.Errorf("sip.call.server failed to send ack: %v", err) + return fmt.Errorf("sip.call.server failed to send ack: %s", err) } // TODO(jwetzell): make this configurable // NOTE(jwetzell): wait 5 seconds before hanging up the call time.Sleep(5 * time.Second) err = outDialog.Hangup(scs.ctx) if err != nil { - return fmt.Errorf("sip.call.server failed to hangup call: %v", err) + return fmt.Errorf("sip.call.server failed to hangup call: %s", err) } return nil } diff --git a/internal/module/sip-dtmf-server.go b/internal/module/sip-dtmf-server.go index d84db96..b787073 100644 --- a/internal/module/sip-dtmf-server.go +++ b/internal/module/sip-dtmf-server.go @@ -2,7 +2,7 @@ package module import ( "context" - "fmt" + "errors" "io" "log/slog" "strings" @@ -44,7 +44,7 @@ func init() { specificPortNum, ok := port.(float64) if !ok { - return nil, fmt.Errorf("sip.dtmf.server port must be a number") + return nil, errors.New("sip.dtmf.server port must be a number") } portNum = int(specificPortNum) } @@ -57,7 +57,7 @@ func init() { specificIpString, ok := ip.(string) if !ok { - return nil, fmt.Errorf("sip.dtmf.server ip must be a string") + return nil, errors.New("sip.dtmf.server ip must be a string") } ipString = specificIpString } @@ -70,26 +70,26 @@ func init() { specificTransportString, ok := transport.(string) if !ok { - return nil, fmt.Errorf("sip.dtmf.server transport must be a string") + return nil, errors.New("sip.dtmf.server transport must be a string") } transportString = specificTransportString } separator, ok := params["separator"] if !ok { - return nil, fmt.Errorf("sip.dtmf.server requires a separator parameter") + return nil, errors.New("sip.dtmf.server requires a separator parameter") } separatorString, ok := separator.(string) if !ok { - return nil, fmt.Errorf("sip.dtmf.server separator must be a string") + return nil, errors.New("sip.dtmf.server separator must be a string") } if len(separatorString) != 1 { - return nil, fmt.Errorf("sip.dtmf.server separator must be a single character") + return nil, errors.New("sip.dtmf.server separator must be a single character") } if !strings.ContainsRune("0123456789*#ABCD", rune(separatorString[0])) { - return nil, fmt.Errorf("sip.dtmf.server separator must be a valid DTMF character") + return nil, errors.New("sip.dtmf.server separator must be a valid DTMF character") } return &SIPDTMFServer{config: config, ctx: ctx, router: router, IP: ipString, Port: int(portNum), Transport: transportString, Separator: separatorString, logger: slog.Default().With("component", "module", "id", config.Id)}, nil }, @@ -160,5 +160,5 @@ func (sds *SIPDTMFServer) HandleCall(inDialog *diago.DialogServerSession) error } func (sds *SIPDTMFServer) Output(payload any) error { - return fmt.Errorf("sip.dtmf.server output is not implemented") + return errors.New("sip.dtmf.server output is not implemented") } diff --git a/internal/module/tcp-client.go b/internal/module/tcp-client.go index 91dd702..7a2e4ba 100644 --- a/internal/module/tcp-client.go +++ b/internal/module/tcp-client.go @@ -2,6 +2,7 @@ package module import ( "context" + "errors" "fmt" "log/slog" "net" @@ -30,24 +31,24 @@ func init() { host, ok := params["host"] if !ok { - return nil, fmt.Errorf("net.tcp.client requires a host parameter") + return nil, errors.New("net.tcp.client requires a host parameter") } hostString, ok := host.(string) if !ok { - return nil, fmt.Errorf("net.tcp.client host must be string") + return nil, errors.New("net.tcp.client host must be string") } port, ok := params["port"] if !ok { - return nil, fmt.Errorf("net.tcp.client requires a port parameter") + return nil, errors.New("net.tcp.client requires a port parameter") } portNum, ok := port.(float64) if !ok { - return nil, fmt.Errorf("net.tcp.client port must be a number") + return nil, errors.New("net.tcp.client port must be a number") } addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", hostString, uint16(portNum))) @@ -63,7 +64,7 @@ func init() { framingMethodString, ok := framingMethodRaw.(string) if !ok { - return nil, fmt.Errorf("misc.serial.client framing method must be a string") + return nil, errors.New("misc.serial.client framing method must be a string") } framingMethod = framingMethodString } @@ -164,7 +165,7 @@ func (tc *TCPClient) Output(payload any) error { } payloadBytes, ok := payload.([]byte) if !ok { - return fmt.Errorf("net.tcp.client is only able to output bytes") + return errors.New("net.tcp.client is only able to output bytes") } _, err := tc.conn.Write(tc.framer.Encode(payloadBytes)) return err diff --git a/internal/module/tcp-server.go b/internal/module/tcp-server.go index c782791..9227e2f 100644 --- a/internal/module/tcp-server.go +++ b/internal/module/tcp-server.go @@ -36,13 +36,13 @@ func init() { params := config.Params port, ok := params["port"] if !ok { - return nil, fmt.Errorf("net.tcp.server requires a port parameter") + return nil, errors.New("net.tcp.server requires a port parameter") } portNum, ok := port.(float64) if !ok { - return nil, fmt.Errorf("net.tcp.server port must be a number") + return nil, errors.New("net.tcp.server port must be a number") } framingMethod := "RAW" @@ -53,7 +53,7 @@ func init() { framingMethodString, ok := framingMethodRaw.(string) if !ok { - return nil, fmt.Errorf("misc.serial.client framing method must be a string") + return nil, errors.New("misc.serial.client framing method must be a string") } framingMethod = framingMethodString } @@ -72,7 +72,7 @@ func init() { specificIpString, ok := ip.(string) if !ok { - return nil, fmt.Errorf("net.tcp.server ip must be a string") + return nil, errors.New("net.tcp.server ip must be a string") } ipString = specificIpString } @@ -201,7 +201,7 @@ func (ts *TCPServer) Output(payload any) error { payloadBytes, ok := payload.([]byte) if !ok { - return fmt.Errorf("net.tcp.server is only able to output bytes") + return errors.New("net.tcp.server is only able to output bytes") } ts.connectionsMu.Lock() errorString := "" @@ -217,5 +217,5 @@ func (ts *TCPServer) Output(payload any) error { if errorString == "" { return nil } - return fmt.Errorf("%s", errorString) + return fmt.Errorf("net.tcp.server error during output: %s", errorString) } diff --git a/internal/module/timer.go b/internal/module/timer.go index 7526e58..bd26dee 100644 --- a/internal/module/timer.go +++ b/internal/module/timer.go @@ -2,7 +2,7 @@ package module import ( "context" - "fmt" + "errors" "log/slog" "time" @@ -27,13 +27,13 @@ func init() { duration, ok := params["duration"] if !ok { - return nil, fmt.Errorf("gen.timer requires a duration parameter") + return nil, errors.New("gen.timer requires a duration parameter") } durationNum, ok := duration.(float64) if !ok { - return nil, fmt.Errorf("gen.timer duration must be a number") + return nil, errors.New("gen.timer duration must be a number") } return &Timer{Duration: uint32(durationNum), config: config, ctx: ctx, router: router, logger: slog.Default().With("component", "module", "id", config.Id)}, nil diff --git a/internal/module/udp-client.go b/internal/module/udp-client.go index 7be0765..2612ad1 100644 --- a/internal/module/udp-client.go +++ b/internal/module/udp-client.go @@ -2,6 +2,7 @@ package module import ( "context" + "errors" "fmt" "log/slog" "net" @@ -28,24 +29,24 @@ func init() { host, ok := params["host"] if !ok { - return nil, fmt.Errorf("net.udp.client requires a host parameter") + return nil, errors.New("net.udp.client requires a host parameter") } hostString, ok := host.(string) if !ok { - return nil, fmt.Errorf("net.udp.client host must be a string") + return nil, errors.New("net.udp.client host must be a string") } port, ok := params["port"] if !ok { - return nil, fmt.Errorf("net.udp.client requires a port parameter") + return nil, errors.New("net.udp.client requires a port parameter") } portNum, ok := port.(float64) if !ok { - return nil, fmt.Errorf("net.udp.client port must be a number") + return nil, errors.New("net.udp.client port must be a number") } addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", hostString, uint16(portNum))) @@ -91,7 +92,7 @@ func (uc *UDPClient) Output(payload any) error { payloadBytes, ok := payload.([]byte) if !ok { - return fmt.Errorf("net.udp.client is only able to output bytes") + return errors.New("net.udp.client is only able to output bytes") } if uc.conn != nil { _, err := uc.conn.Write(payloadBytes) @@ -100,7 +101,7 @@ func (uc *UDPClient) Output(payload any) error { return err } } else { - return fmt.Errorf("net.udp.client client is not setup") + return errors.New("net.udp.client client is not setup") } return nil } diff --git a/internal/module/udp-multicast.go b/internal/module/udp-multicast.go index 7195e97..046efc2 100644 --- a/internal/module/udp-multicast.go +++ b/internal/module/udp-multicast.go @@ -2,6 +2,7 @@ package module import ( "context" + "errors" "fmt" "log/slog" "net" @@ -28,24 +29,24 @@ func init() { ip, ok := params["ip"] if !ok { - return nil, fmt.Errorf("net.udp.multicast requires an ip parameter") + return nil, errors.New("net.udp.multicast requires an ip parameter") } ipString, ok := ip.(string) if !ok { - return nil, fmt.Errorf("net.udp.multicast ip must be a string") + return nil, errors.New("net.udp.multicast ip must be a string") } port, ok := params["port"] if !ok { - return nil, fmt.Errorf("net.udp.multicast requires a port parameter") + return nil, errors.New("net.udp.multicast requires a port parameter") } portNum, ok := port.(float64) if !ok { - return nil, fmt.Errorf("net.udp.multicast port must be a number") + return nil, errors.New("net.udp.multicast port must be a number") } addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", ipString, uint16(portNum))) @@ -111,11 +112,11 @@ func (um *UDPMulticast) Output(payload any) error { payloadBytes, ok := payload.([]byte) if !ok { - return fmt.Errorf("net.udp.multicast can only output bytes") + return errors.New("net.udp.multicast can only output bytes") } if um.conn == nil { - return fmt.Errorf("net.udp.multicast connection is not setup") + return errors.New("net.udp.multicast connection is not setup") } _, err := um.conn.Write(payloadBytes) diff --git a/internal/module/udp-server.go b/internal/module/udp-server.go index 67d2e59..5c0ec46 100644 --- a/internal/module/udp-server.go +++ b/internal/module/udp-server.go @@ -2,6 +2,7 @@ package module import ( "context" + "errors" "fmt" "log" "log/slog" @@ -27,13 +28,13 @@ func init() { params := config.Params port, ok := params["port"] if !ok { - return nil, fmt.Errorf("net.udp.server requires a port parameter") + return nil, errors.New("net.udp.server requires a port parameter") } portNum, ok := port.(float64) if !ok { - return nil, fmt.Errorf("net.udp.server port must be a number") + return nil, errors.New("net.udp.server port must be a number") } ipString := "0.0.0.0" @@ -44,7 +45,7 @@ func init() { specificIpString, ok := ip.(string) if !ok { - return nil, fmt.Errorf("net.udp.server ip must be a string") + return nil, errors.New("net.udp.server ip must be a string") } ipString = specificIpString } @@ -107,5 +108,5 @@ func (us *UDPServer) Run() error { } func (us *UDPServer) Output(payload any) error { - return fmt.Errorf("net.udp.server output is not implemented") + return errors.New("net.udp.server output is not implemented") } diff --git a/internal/processor/float-parse.go b/internal/processor/float-parse.go index e399375..d2b99c8 100644 --- a/internal/processor/float-parse.go +++ b/internal/processor/float-parse.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" "strconv" "github.com/jwetzell/showbridge-go/internal/config" @@ -16,7 +16,7 @@ func (fp *FloatParse) Process(ctx context.Context, payload any) (any, error) { payloadString, ok := payload.(string) if !ok { - return nil, fmt.Errorf("float.parse processor only accepts a string") + return nil, errors.New("float.parse processor only accepts a string") } // TODO(jwetzell): make bitSize configurable diff --git a/internal/processor/free-d-create.go b/internal/processor/free-d-create.go index 50fd0fc..81d5594 100644 --- a/internal/processor/free-d-create.go +++ b/internal/processor/free-d-create.go @@ -3,7 +3,7 @@ package processor import ( "bytes" "context" - "fmt" + "errors" "strconv" "text/template" @@ -190,13 +190,13 @@ func init() { id, ok := params["id"] if !ok { - return nil, fmt.Errorf("freed.create requires an id parameter") + return nil, errors.New("freed.create requires an id parameter") } idString, ok := id.(string) if !ok { - return nil, fmt.Errorf("freed.create id must be a string") + return nil, errors.New("freed.create id must be a string") } idTemplate, err := template.New("id").Parse(idString) @@ -208,13 +208,13 @@ func init() { pan, ok := params["pan"] if !ok { - return nil, fmt.Errorf("freed.create requires a pan parameter") + return nil, errors.New("freed.create requires a pan parameter") } panString, ok := pan.(string) if !ok { - return nil, fmt.Errorf("freed.create pan must be a string") + return nil, errors.New("freed.create pan must be a string") } panTemplate, err := template.New("pan").Parse(panString) @@ -222,13 +222,13 @@ func init() { tilt, ok := params["tilt"] if !ok { - return nil, fmt.Errorf("freed.create requires a tilt parameter") + return nil, errors.New("freed.create requires a tilt parameter") } tiltString, ok := tilt.(string) if !ok { - return nil, fmt.Errorf("freed.create tilt must be a string") + return nil, errors.New("freed.create tilt must be a string") } tiltTemplate, err := template.New("tilt").Parse(tiltString) @@ -236,13 +236,13 @@ func init() { roll, ok := params["roll"] if !ok { - return nil, fmt.Errorf("freed.create requires a roll parameter") + return nil, errors.New("freed.create requires a roll parameter") } rollString, ok := roll.(string) if !ok { - return nil, fmt.Errorf("freed.create roll must be a string") + return nil, errors.New("freed.create roll must be a string") } rollTemplate, err := template.New("roll").Parse(rollString) @@ -254,13 +254,13 @@ func init() { posX, ok := params["posX"] if !ok { - return nil, fmt.Errorf("freed.create requires a posX parameter") + return nil, errors.New("freed.create requires a posX parameter") } posXString, ok := posX.(string) if !ok { - return nil, fmt.Errorf("freed.create posX must be a string") + return nil, errors.New("freed.create posX must be a string") } posXTemplate, err := template.New("posX").Parse(posXString) @@ -272,13 +272,13 @@ func init() { posY, ok := params["posY"] if !ok { - return nil, fmt.Errorf("freed.create requires a posY parameter") + return nil, errors.New("freed.create requires a posY parameter") } posYString, ok := posY.(string) if !ok { - return nil, fmt.Errorf("freed.create posY must be a string") + return nil, errors.New("freed.create posY must be a string") } posYTemplate, err := template.New("posY").Parse(posYString) @@ -290,13 +290,13 @@ func init() { posZ, ok := params["posZ"] if !ok { - return nil, fmt.Errorf("freed.create requires a posZ parameter") + return nil, errors.New("freed.create requires a posZ parameter") } posZString, ok := posZ.(string) if !ok { - return nil, fmt.Errorf("freed.create posZ must be a string") + return nil, errors.New("freed.create posZ must be a string") } posZTemplate, err := template.New("posZ").Parse(posZString) @@ -308,13 +308,13 @@ func init() { zoom, ok := params["zoom"] if !ok { - return nil, fmt.Errorf("freed.create requires a zoom parameter") + return nil, errors.New("freed.create requires a zoom parameter") } zoomString, ok := zoom.(string) if !ok { - return nil, fmt.Errorf("freed.create zoom must be a string") + return nil, errors.New("freed.create zoom must be a string") } zoomTemplate, err := template.New("zoom").Parse(zoomString) @@ -322,13 +322,13 @@ func init() { focus, ok := params["focus"] if !ok { - return nil, fmt.Errorf("freed.create requires a focus parameter") + return nil, errors.New("freed.create requires a focus parameter") } focusString, ok := focus.(string) if !ok { - return nil, fmt.Errorf("freed.create focus must be a string") + return nil, errors.New("freed.create focus must be a string") } focusTemplate, err := template.New("focus").Parse(focusString) diff --git a/internal/processor/free-d-decode.go b/internal/processor/free-d-decode.go index 4903c51..3329b01 100644 --- a/internal/processor/free-d-decode.go +++ b/internal/processor/free-d-decode.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" freeD "github.com/jwetzell/free-d-go" "github.com/jwetzell/showbridge-go/internal/config" @@ -16,7 +16,7 @@ func (fdd *FreeDDecode) Process(ctx context.Context, payload any) (any, error) { payloadBytes, ok := payload.([]byte) if !ok { - return nil, fmt.Errorf("freed.decode processor only accepts a []byte") + return nil, errors.New("freed.decode processor only accepts a []byte") } payloadMessage, err := freeD.Decode(payloadBytes) diff --git a/internal/processor/free-d-encode.go b/internal/processor/free-d-encode.go index 0509eea..e6e903c 100644 --- a/internal/processor/free-d-encode.go +++ b/internal/processor/free-d-encode.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" freeD "github.com/jwetzell/free-d-go" "github.com/jwetzell/showbridge-go/internal/config" @@ -16,7 +16,7 @@ func (fde *FreeDEncode) Process(ctx context.Context, payload any) (any, error) { payloadPosition, ok := payload.(freeD.FreeDPosition) if !ok { - return nil, fmt.Errorf("freed.decode processor only accepts a FreeDEncode") + return nil, errors.New("freed.decode processor only accepts a FreeDEncode") } payloadBytes := freeD.Encode(payloadPosition) diff --git a/internal/processor/http-request-create.go b/internal/processor/http-request-create.go index f62f034..dd5c45b 100644 --- a/internal/processor/http-request-create.go +++ b/internal/processor/http-request-create.go @@ -3,7 +3,7 @@ package processor import ( "bytes" "context" - "fmt" + "errors" "net/http" "text/template" @@ -50,25 +50,25 @@ func init() { method, ok := params["method"] if !ok { - return nil, fmt.Errorf("http.request.create requires a method parameter") + return nil, errors.New("http.request.create requires a method parameter") } methodString, ok := method.(string) if !ok { - return nil, fmt.Errorf("http.request.create url must be a string") + return nil, errors.New("http.request.create url must be a string") } url, ok := params["url"] if !ok { - return nil, fmt.Errorf("http.request.create requires a url parameter") + return nil, errors.New("http.request.create requires a url parameter") } urlString, ok := url.(string) if !ok { - return nil, fmt.Errorf("http.request.create url must be a string") + return nil, errors.New("http.request.create url must be a string") } urlTemplate, err := template.New("url").Parse(urlString) diff --git a/internal/processor/http-request-encode.go b/internal/processor/http-request-encode.go index 549560e..0fd503d 100644 --- a/internal/processor/http-request-encode.go +++ b/internal/processor/http-request-encode.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" "io" "net/http" @@ -17,7 +17,7 @@ func (hre *HTTPRequestEncode) Process(ctx context.Context, payload any) (any, er payloadRequest, ok := payload.(*http.Request) if !ok { - return nil, fmt.Errorf("http.request.encode processor only accepts an http.Request") + return nil, errors.New("http.request.encode processor only accepts an http.Request") } bytes, err := io.ReadAll(payloadRequest.Body) diff --git a/internal/processor/http-request-filter.go b/internal/processor/http-request-filter.go index 5125c1d..136be23 100644 --- a/internal/processor/http-request-filter.go +++ b/internal/processor/http-request-filter.go @@ -2,6 +2,7 @@ package processor import ( "context" + "errors" "fmt" "net/http" "regexp" @@ -20,7 +21,7 @@ func (hrf *HTTPRequestFilter) Process(ctx context.Context, payload any) (any, er payloadRequest, ok := payload.(*http.Request) if !ok { - return nil, fmt.Errorf("http.request.filter can only operate on http.Request payloads") + return nil, errors.New("http.request.filter can only operate on http.Request payloads") } if hrf.Method != "" { @@ -48,13 +49,13 @@ func init() { path, ok := params["path"] if !ok { - return nil, fmt.Errorf("http.request.filter requires a path parameter") + return nil, errors.New("http.request.filter requires a path parameter") } pathString, ok := path.(string) if !ok { - return nil, fmt.Errorf("http.request.filter path must be a string") + return nil, errors.New("http.request.filter path must be a string") } pathRegexp, err := regexp.Compile(fmt.Sprintf("^%s$", pathString)) @@ -69,7 +70,7 @@ func init() { methodString, ok := method.(string) if !ok { - return nil, fmt.Errorf("http.request.filter method must be a string") + return nil, errors.New("http.request.filter method must be a string") } return &HTTPRequestFilter{config: config, Path: pathRegexp, Method: methodString}, nil } diff --git a/internal/processor/http-response-encode.go b/internal/processor/http-response-encode.go index 9441f70..ea5973b 100644 --- a/internal/processor/http-response-encode.go +++ b/internal/processor/http-response-encode.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" "io" "net/http" @@ -17,7 +17,7 @@ func (hre *HTTPResponseEncode) Process(ctx context.Context, payload any) (any, e payloadResponse, ok := payload.(*http.Response) if !ok { - return nil, fmt.Errorf("http.response.encode processor only accepts an http.Response") + return nil, errors.New("http.response.encode processor only accepts an http.Response") } defer payloadResponse.Body.Close() diff --git a/internal/processor/int-parse.go b/internal/processor/int-parse.go index f5e0fab..eb4ae45 100644 --- a/internal/processor/int-parse.go +++ b/internal/processor/int-parse.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" "strconv" "github.com/jwetzell/showbridge-go/internal/config" @@ -16,7 +16,7 @@ func (ip *IntParse) Process(ctx context.Context, payload any) (any, error) { payloadString, ok := payload.(string) if !ok { - return nil, fmt.Errorf("int.parse processor only accepts a string") + return nil, errors.New("int.parse processor only accepts a string") } // TODO(jwetzell): make base and bitSize configurable diff --git a/internal/processor/midi-message-create.go b/internal/processor/midi-message-create.go index 9033604..6d80e66 100644 --- a/internal/processor/midi-message-create.go +++ b/internal/processor/midi-message-create.go @@ -5,6 +5,7 @@ package processor import ( "bytes" "context" + "errors" "fmt" "strconv" "text/template" @@ -34,13 +35,13 @@ func newMidiNoteOnCreate(config config.ProcessorConfig) (Processor, error) { channel, ok := params["channel"] if !ok { - return nil, fmt.Errorf("midi.message.create NoteOn requires a channel parameter") + return nil, errors.New("midi.message.create NoteOn requires a channel parameter") } channelString, ok := channel.(string) if !ok { - return nil, fmt.Errorf("midi.message.create NoteOn channel must be a string") + return nil, errors.New("midi.message.create NoteOn channel must be a string") } channelTemplate, err := template.New("channel").Parse(channelString) @@ -52,13 +53,13 @@ func newMidiNoteOnCreate(config config.ProcessorConfig) (Processor, error) { note, ok := params["note"] if !ok { - return nil, fmt.Errorf("midi.message.create NoteOn requires a note parameter") + return nil, errors.New("midi.message.create NoteOn requires a note parameter") } noteString, ok := note.(string) if !ok { - return nil, fmt.Errorf("midi.message.create NoteOn note must be a string") + return nil, errors.New("midi.message.create NoteOn note must be a string") } noteTemplate, err := template.New("note").Parse(noteString) @@ -70,13 +71,13 @@ func newMidiNoteOnCreate(config config.ProcessorConfig) (Processor, error) { velocity, ok := params["velocity"] if !ok { - return nil, fmt.Errorf("midi.message.create NoteOn requires a velocity parameter") + return nil, errors.New("midi.message.create NoteOn requires a velocity parameter") } velocityString, ok := velocity.(string) if !ok { - return nil, fmt.Errorf("midi.message.create NoteOn velocity must be a string") + return nil, errors.New("midi.message.create NoteOn velocity must be a string") } velocityTemplate, err := template.New("velocity").Parse(velocityString) @@ -125,13 +126,13 @@ func newMidiNoteOffCreate(config config.ProcessorConfig) (Processor, error) { channel, ok := params["channel"] if !ok { - return nil, fmt.Errorf("midi.message.create NoteOn requires a channel parameter") + return nil, errors.New("midi.message.create NoteOn requires a channel parameter") } channelString, ok := channel.(string) if !ok { - return nil, fmt.Errorf("midi.message.create NoteOn channel must be a string") + return nil, errors.New("midi.message.create NoteOn channel must be a string") } channelTemplate, err := template.New("channel").Parse(channelString) @@ -143,13 +144,13 @@ func newMidiNoteOffCreate(config config.ProcessorConfig) (Processor, error) { note, ok := params["note"] if !ok { - return nil, fmt.Errorf("midi.message.create NoteOn requires a note parameter") + return nil, errors.New("midi.message.create NoteOn requires a note parameter") } noteString, ok := note.(string) if !ok { - return nil, fmt.Errorf("midi.message.create NoteOn note must be a string") + return nil, errors.New("midi.message.create NoteOn note must be a string") } noteTemplate, err := template.New("note").Parse(noteString) @@ -190,13 +191,13 @@ func newMidiControlChangeCreate(config config.ProcessorConfig) (Processor, error channel, ok := params["channel"] if !ok { - return nil, fmt.Errorf("midi.message.create ControlChange requires a channel parameter") + return nil, errors.New("midi.message.create ControlChange requires a channel parameter") } channelString, ok := channel.(string) if !ok { - return nil, fmt.Errorf("midi.message.create ControlChange channel must be a string") + return nil, errors.New("midi.message.create ControlChange channel must be a string") } channelTemplate, err := template.New("channel").Parse(channelString) @@ -208,13 +209,13 @@ func newMidiControlChangeCreate(config config.ProcessorConfig) (Processor, error controller, ok := params["controller"] if !ok { - return nil, fmt.Errorf("midi.message.create ControlChange requires a controller parameter") + return nil, errors.New("midi.message.create ControlChange requires a controller parameter") } controllerString, ok := controller.(string) if !ok { - return nil, fmt.Errorf("midi.message.create ControlChange controller must be a string") + return nil, errors.New("midi.message.create ControlChange controller must be a string") } controllerTemplate, err := template.New("controller").Parse(controllerString) @@ -226,13 +227,13 @@ func newMidiControlChangeCreate(config config.ProcessorConfig) (Processor, error value, ok := params["value"] if !ok { - return nil, fmt.Errorf("midi.message.create ControlChange requires a value parameter") + return nil, errors.New("midi.message.create ControlChange requires a value parameter") } valueString, ok := value.(string) if !ok { - return nil, fmt.Errorf("midi.message.create ControlChange value must be a string") + return nil, errors.New("midi.message.create ControlChange value must be a string") } valueTemplate, err := template.New("value").Parse(valueString) @@ -282,13 +283,13 @@ func newMidiProgramChangeCreate(config config.ProcessorConfig) (Processor, error channel, ok := params["channel"] if !ok { - return nil, fmt.Errorf("midi.message.create ProgramChange requires a channel parameter") + return nil, errors.New("midi.message.create ProgramChange requires a channel parameter") } channelString, ok := channel.(string) if !ok { - return nil, fmt.Errorf("midi.message.create ProgramChange channel must be a string") + return nil, errors.New("midi.message.create ProgramChange channel must be a string") } channelTemplate, err := template.New("channel").Parse(channelString) @@ -300,13 +301,13 @@ func newMidiProgramChangeCreate(config config.ProcessorConfig) (Processor, error program, ok := params["program"] if !ok { - return nil, fmt.Errorf("midi.message.create ProgramChange requires a program parameter") + return nil, errors.New("midi.message.create ProgramChange requires a program parameter") } programString, ok := program.(string) if !ok { - return nil, fmt.Errorf("midi.message.create ProgramChange program must be a string") + return nil, errors.New("midi.message.create ProgramChange program must be a string") } programTemplate, err := template.New("program").Parse(programString) @@ -349,13 +350,13 @@ func init() { msgType, ok := params["type"] if !ok { - return nil, fmt.Errorf("midi.message.create requires a type parameter") + return nil, errors.New("midi.message.create requires a type parameter") } msgTypeString, ok := msgType.(string) if !ok { - return nil, fmt.Errorf("midi.message.create type parameter must be a string") + return nil, errors.New("midi.message.create type parameter must be a string") } switch msgTypeString { diff --git a/internal/processor/midi-message-decode.go b/internal/processor/midi-message-decode.go index a6fccec..a2601dd 100644 --- a/internal/processor/midi-message-decode.go +++ b/internal/processor/midi-message-decode.go @@ -4,7 +4,7 @@ package processor import ( "context" - "fmt" + "errors" "github.com/jwetzell/showbridge-go/internal/config" "gitlab.com/gomidi/midi/v2" @@ -18,7 +18,7 @@ func (mmd *MIDIMessageDecode) Process(ctx context.Context, payload any) (any, er payloadBytes, ok := payload.([]byte) if !ok { - return nil, fmt.Errorf("midi.message.decode processor only accepts a []byte") + return nil, errors.New("midi.message.decode processor only accepts a []byte") } payloadMessage := midi.Message(payloadBytes) diff --git a/internal/processor/midi-message-encode.go b/internal/processor/midi-message-encode.go index 4c0f2d4..968e5b3 100644 --- a/internal/processor/midi-message-encode.go +++ b/internal/processor/midi-message-encode.go @@ -4,7 +4,7 @@ package processor import ( "context" - "fmt" + "errors" "github.com/jwetzell/showbridge-go/internal/config" "gitlab.com/gomidi/midi/v2" @@ -18,7 +18,7 @@ func (mme *MIDIMessageEncode) Process(ctx context.Context, payload any) (any, er payloadMessage, ok := payload.(midi.Message) if !ok { - return nil, fmt.Errorf("midi.message.encode processor only accepts an midi.Message") + return nil, errors.New("midi.message.encode processor only accepts an midi.Message") } return payloadMessage.Bytes(), nil diff --git a/internal/processor/midi-message-filter.go b/internal/processor/midi-message-filter.go index 9c76764..75954a6 100644 --- a/internal/processor/midi-message-filter.go +++ b/internal/processor/midi-message-filter.go @@ -4,7 +4,7 @@ package processor import ( "context" - "fmt" + "errors" "github.com/jwetzell/showbridge-go/internal/config" "gitlab.com/gomidi/midi/v2" @@ -19,7 +19,7 @@ func (mmf *MIDIMessageFilter) Process(ctx context.Context, payload any) (any, er payloadMessage, ok := payload.(midi.Message) if !ok { - return nil, fmt.Errorf("midi.message.filter processor only accepts an midi.Message") + return nil, errors.New("midi.message.filter processor only accepts an midi.Message") } if payloadMessage.Type().String() != mmf.MIDIType { @@ -41,12 +41,12 @@ func init() { midiType, ok := params["type"] if !ok { - return nil, fmt.Errorf("midi.message.filter requires a type parameter") + return nil, errors.New("midi.message.filter requires a type parameter") } midiTypeString, ok := midiType.(string) if !ok { - return nil, fmt.Errorf("midi.message.filter type must be a string") + return nil, errors.New("midi.message.filter type must be a string") } return &MIDIMessageFilter{config: config, MIDIType: midiTypeString}, nil diff --git a/internal/processor/midi-message-unpack.go b/internal/processor/midi-message-unpack.go index 5933f9e..d863dd2 100644 --- a/internal/processor/midi-message-unpack.go +++ b/internal/processor/midi-message-unpack.go @@ -4,6 +4,7 @@ package processor import ( "context" + "errors" "fmt" "github.com/jwetzell/showbridge-go/internal/config" @@ -47,7 +48,7 @@ func (mmu *MIDIMessageUnpack) Process(ctx context.Context, payload any) (any, er payloadMidi, ok := payload.(midi.Message) if !ok { - return nil, fmt.Errorf("midi.message.unpack processor only accepts a midi.Message") + return nil, errors.New("midi.message.unpack processor only accepts a midi.Message") } switch payloadMidi.Type() { diff --git a/internal/processor/mqtt-message-create.go b/internal/processor/mqtt-message-create.go index 21fe551..60aaaad 100644 --- a/internal/processor/mqtt-message-create.go +++ b/internal/processor/mqtt-message-create.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" "github.com/jwetzell/showbridge-go/internal/config" ) @@ -74,44 +74,44 @@ func init() { topic, ok := params["topic"] if !ok { - return nil, fmt.Errorf("mqtt.message.create requires a topic parameter") + return nil, errors.New("mqtt.message.create requires a topic parameter") } topicString, ok := topic.(string) if !ok { - return nil, fmt.Errorf("mqtt.message.create topic must be a string") + return nil, errors.New("mqtt.message.create topic must be a string") } qos, ok := params["qos"] if !ok { - return nil, fmt.Errorf("mqtt.message.create requires a qos parameter") + return nil, errors.New("mqtt.message.create requires a qos parameter") } qosByte, ok := qos.(float64) if !ok { - return nil, fmt.Errorf("mqtt.message.create qos must be a number") + return nil, errors.New("mqtt.message.create qos must be a number") } retained, ok := params["retained"] if !ok { - return nil, fmt.Errorf("mqtt.message.create requires a retained parameter") + return nil, errors.New("mqtt.message.create requires a retained parameter") } retainedBool, ok := retained.(bool) if !ok { - return nil, fmt.Errorf("mqtt.message.create retained must be a boolean") + return nil, errors.New("mqtt.message.create retained must be a boolean") } //TODO(jwetzell): convert payload into []byte or string for sending payload, ok := params["payload"] if !ok { - return nil, fmt.Errorf("mqtt.message.create requires a payload parameter") + return nil, errors.New("mqtt.message.create requires a payload parameter") } if payloadBytes, ok := payload.([]byte); ok { @@ -121,7 +121,7 @@ func init() { payloadString, ok := payload.(string) if !ok { - return nil, fmt.Errorf("mqtt.message.create payload must be a string or byte array") + return nil, errors.New("mqtt.message.create payload must be a string or byte array") } payloadBytes := []byte(payloadString) diff --git a/internal/processor/mqtt-message-encode.go b/internal/processor/mqtt-message-encode.go index 7ec7b4b..eb6236f 100644 --- a/internal/processor/mqtt-message-encode.go +++ b/internal/processor/mqtt-message-encode.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" mqtt "github.com/eclipse/paho.mqtt.golang" "github.com/jwetzell/showbridge-go/internal/config" @@ -16,7 +16,7 @@ func (mme *MQTTMessageEncode) Process(ctx context.Context, payload any) (any, er payloadMessage, ok := payload.(mqtt.Message) if !ok { - return nil, fmt.Errorf("mqtt.message.encode processor only accepts an mqtt.Message") + return nil, errors.New("mqtt.message.encode processor only accepts an mqtt.Message") } return payloadMessage.Payload(), nil diff --git a/internal/processor/nats-message-create.go b/internal/processor/nats-message-create.go index 58deec3..7f153c9 100644 --- a/internal/processor/nats-message-create.go +++ b/internal/processor/nats-message-create.go @@ -3,7 +3,7 @@ package processor import ( "bytes" "context" - "fmt" + "errors" "text/template" "github.com/jwetzell/showbridge-go/internal/config" @@ -52,25 +52,25 @@ func init() { subject, ok := params["subject"] if !ok { - return nil, fmt.Errorf("nats.message.create requires a subject parameter") + return nil, errors.New("nats.message.create requires a subject parameter") } subjectString, ok := subject.(string) if !ok { - return nil, fmt.Errorf("nats.message.create subject must be a string") + return nil, errors.New("nats.message.create subject must be a string") } payload, ok := params["payload"] if !ok { - return nil, fmt.Errorf("osc.message.create requires a payload parameter") + return nil, errors.New("nats.message.create requires a payload parameter") } payloadString, ok := payload.(string) if !ok { - return nil, fmt.Errorf("osc.message.create payload must be a string") + return nil, errors.New("nats.message.create payload must be a string") } payloadTemplate, err := template.New("payload").Parse(payloadString) diff --git a/internal/processor/nats-message-encode.go b/internal/processor/nats-message-encode.go index f1357a0..efaa6c3 100644 --- a/internal/processor/nats-message-encode.go +++ b/internal/processor/nats-message-encode.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" "github.com/jwetzell/showbridge-go/internal/config" "github.com/nats-io/nats.go" @@ -16,7 +16,7 @@ func (nme *NATSMessageEncode) Process(ctx context.Context, payload any) (any, er payloadMessage, ok := payload.(*nats.Msg) if !ok { - return nil, fmt.Errorf("nats.message.encode processor only accepts an nats.Msg") + return nil, errors.New("nats.message.encode processor only accepts an nats.Msg") } return payloadMessage.Data, nil diff --git a/internal/processor/osc-message-create.go b/internal/processor/osc-message-create.go index 6dbf1d2..8289e86 100644 --- a/internal/processor/osc-message-create.go +++ b/internal/processor/osc-message-create.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "encoding/hex" + "errors" "fmt" "strconv" "text/template" @@ -31,11 +32,11 @@ func (o *OSCMessageCreate) Process(ctx context.Context, payload any) (any, error addressString := addressBuffer.String() if len(addressString) == 0 { - return nil, fmt.Errorf("osc.message.create address must not be empty") + return nil, errors.New("osc.message.create address must not be empty") } if addressString[0] != '/' { - return nil, fmt.Errorf("osc.message.create address must start with '/'") + return nil, errors.New("osc.message.create address must start with '/'") } payloadMessage := osc.OSCMessage{ @@ -82,13 +83,13 @@ func init() { address, ok := params["address"] if !ok { - return nil, fmt.Errorf("osc.message.create requires an address parameter") + return nil, errors.New("osc.message.create requires an address parameter") } addressString, ok := address.(string) if !ok { - return nil, fmt.Errorf("osc.message.create address must be a string") + return nil, errors.New("osc.message.create address must be a string") } addressTemplate, err := template.New("address").Parse(addressString) @@ -109,17 +110,17 @@ func init() { types, ok := params["types"] if !ok { - return nil, fmt.Errorf("osc.message.create requires a types parameter with args") + return nil, errors.New("osc.message.create requires a types parameter with args") } typesString, ok := types.(string) if !ok { - return nil, fmt.Errorf("osc.message.create types must be a string") + return nil, errors.New("osc.message.create types must be a string") } if len(rawArgs) != len(typesString) { - return nil, fmt.Errorf("osc.message.create args and types must be the same length") + return nil, errors.New("osc.message.create args and types must be the same length") } argTemplates := []*template.Template{} @@ -128,7 +129,7 @@ func init() { argString, ok := rawArg.(string) if !ok { - return nil, fmt.Errorf("osc.message.create arg must be a string") + return nil, errors.New("osc.message.create arg must be a string") } argTemplate, err := template.New("arg").Parse(argString) diff --git a/internal/processor/osc-message-decode.go b/internal/processor/osc-message-decode.go index cd08e6b..c6c01de 100644 --- a/internal/processor/osc-message-decode.go +++ b/internal/processor/osc-message-decode.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" osc "github.com/jwetzell/osc-go" "github.com/jwetzell/showbridge-go/internal/config" @@ -16,15 +16,15 @@ func (o *OSCMessageDecode) Process(ctx context.Context, payload any) (any, error payloadBytes, ok := payload.([]byte) if !ok { - return nil, fmt.Errorf("osc.message.decode processor only accepts a []byte payload") + return nil, errors.New("osc.message.decode processor only accepts a []byte payload") } if len(payloadBytes) == 0 { - return nil, fmt.Errorf("osc.message.decode processor can't work on empty []byte") + return nil, errors.New("osc.message.decode processor can't work on empty []byte") } if payloadBytes[0] != '/' { - return nil, fmt.Errorf("osc.message.decode processor needs an OSC looking []byte") + return nil, errors.New("osc.message.decode processor needs an OSC looking []byte") } message, err := osc.MessageFromBytes(payloadBytes) diff --git a/internal/processor/osc-message-encode.go b/internal/processor/osc-message-encode.go index 6b16526..78191a5 100644 --- a/internal/processor/osc-message-encode.go +++ b/internal/processor/osc-message-encode.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" osc "github.com/jwetzell/osc-go" "github.com/jwetzell/showbridge-go/internal/config" @@ -16,7 +16,7 @@ func (o *OSCMessageEncode) Process(ctx context.Context, payload any) (any, error payloadMessage, ok := payload.(osc.OSCMessage) if !ok { - return nil, fmt.Errorf("osc.message.encode processor only accepts an OSCMessage") + return nil, errors.New("osc.message.encode processor only accepts an OSCMessage") } bytes := payloadMessage.ToBytes() diff --git a/internal/processor/osc-message-filter.go b/internal/processor/osc-message-filter.go index 8ddd6ef..d3c951c 100644 --- a/internal/processor/osc-message-filter.go +++ b/internal/processor/osc-message-filter.go @@ -2,6 +2,7 @@ package processor import ( "context" + "errors" "fmt" "regexp" "strings" @@ -20,7 +21,7 @@ func (o *OSCMessageFilter) Process(ctx context.Context, payload any) (any, error payloadMessage, ok := payload.(osc.OSCMessage) if !ok { - return nil, fmt.Errorf("osc.message.filter can only operate on OSCMessage payloads") + return nil, errors.New("osc.message.filter can only operate on OSCMessage payloads") } if !o.Address.MatchString(payloadMessage.Address) { @@ -42,13 +43,13 @@ func init() { address, ok := params["address"] if !ok { - return nil, fmt.Errorf("osc.message.filter requires an address parameter") + return nil, errors.New("osc.message.filter requires an address parameter") } addressString, ok := address.(string) if !ok { - return nil, fmt.Errorf("osc.message.filter address must be a string") + return nil, errors.New("osc.message.filter address must be a string") } addressPattern := strings.ReplaceAll(addressString, "?", ".") diff --git a/internal/processor/osc-message-transform.go b/internal/processor/osc-message-transform.go index 03fd242..2bb3c01 100644 --- a/internal/processor/osc-message-transform.go +++ b/internal/processor/osc-message-transform.go @@ -3,7 +3,7 @@ package processor import ( "bytes" "context" - "fmt" + "errors" "text/template" osc "github.com/jwetzell/osc-go" @@ -19,7 +19,7 @@ func (o *OSCMessageTransform) Process(ctx context.Context, payload any) (any, er payloadMessage, ok := payload.(osc.OSCMessage) if !ok { - return nil, fmt.Errorf("osc.message.transform processor only accepts an OSCMessage") + return nil, errors.New("osc.message.transform processor only accepts an OSCMessage") } var addressBuffer bytes.Buffer @@ -33,11 +33,11 @@ func (o *OSCMessageTransform) Process(ctx context.Context, payload any) (any, er addressString := addressBuffer.String() if len(addressString) == 0 { - return nil, fmt.Errorf("osc.message.transform address must not be empty") + return nil, errors.New("osc.message.transform address must not be empty") } if addressString[0] != '/' { - return nil, fmt.Errorf("osc.message.transform address must start with '/'") + return nil, errors.New("osc.message.transform address must start with '/'") } payloadMessage.Address = addressString @@ -57,13 +57,13 @@ func init() { address, ok := params["address"] if !ok { - return nil, fmt.Errorf("osc.message.transform requires an address parameter") + return nil, errors.New("osc.message.transform requires an address parameter") } addressString, ok := address.(string) if !ok { - return nil, fmt.Errorf("osc.message.transform address must be a string") + return nil, errors.New("osc.message.transform address must be a string") } addressTemplate, err := template.New("address").Parse(addressString) diff --git a/internal/processor/script-expr.go b/internal/processor/script-expr.go index 380a0d5..3cb2e2c 100644 --- a/internal/processor/script-expr.go +++ b/internal/processor/script-expr.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" "github.com/expr-lang/expr" "github.com/expr-lang/expr/vm" @@ -38,13 +38,13 @@ func init() { expression, ok := params["expression"] if !ok { - return nil, fmt.Errorf("script.expr requires an expression parameter") + return nil, errors.New("script.expr requires an expression parameter") } expressionString, ok := expression.(string) if !ok { - return nil, fmt.Errorf("script.expr expression must be a string") + return nil, errors.New("script.expr expression must be a string") } program, err := expr.Compile(expressionString) diff --git a/internal/processor/script-js.go b/internal/processor/script-js.go index 36da56c..da0fc26 100644 --- a/internal/processor/script-js.go +++ b/internal/processor/script-js.go @@ -3,7 +3,7 @@ package processor import ( "context" "encoding/json" - "fmt" + "errors" "github.com/jwetzell/showbridge-go/internal/config" "modernc.org/quickjs" @@ -74,13 +74,13 @@ func init() { program, ok := params["program"] if !ok { - return nil, fmt.Errorf("script.js requires a program parameter") + return nil, errors.New("script.js requires a program parameter") } programString, ok := program.(string) if !ok { - return nil, fmt.Errorf("script.js program must be a string") + return nil, errors.New("script.js program must be a string") } return &ScriptJS{config: config, Program: programString}, nil diff --git a/internal/processor/string-create.go b/internal/processor/string-create.go index 089d917..b9abf11 100644 --- a/internal/processor/string-create.go +++ b/internal/processor/string-create.go @@ -3,7 +3,7 @@ package processor import ( "bytes" "context" - "fmt" + "errors" "text/template" "github.com/jwetzell/showbridge-go/internal/config" @@ -39,13 +39,13 @@ func init() { tmpl, ok := params["template"] if !ok { - return nil, fmt.Errorf("string.create requires a template parameter") + return nil, errors.New("string.create requires a template parameter") } templateString, ok := tmpl.(string) if !ok { - return nil, fmt.Errorf("string.create template must be a string") + return nil, errors.New("string.create template must be a string") } templateTemplate, err := template.New("template").Parse(templateString) diff --git a/internal/processor/string-decode.go b/internal/processor/string-decode.go index 1750cfe..b69038a 100644 --- a/internal/processor/string-decode.go +++ b/internal/processor/string-decode.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" "github.com/jwetzell/showbridge-go/internal/config" ) @@ -15,7 +15,7 @@ func (sd *StringDecode) Process(ctx context.Context, payload any) (any, error) { payloadBytes, ok := payload.([]byte) if !ok { - return nil, fmt.Errorf("string.decode processor only accepts a []byte") + return nil, errors.New("string.decode processor only accepts a []byte") } payloadMessage := string(payloadBytes) diff --git a/internal/processor/string-encode.go b/internal/processor/string-encode.go index cac2b70..98e82ae 100644 --- a/internal/processor/string-encode.go +++ b/internal/processor/string-encode.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" "github.com/jwetzell/showbridge-go/internal/config" ) @@ -15,7 +15,7 @@ func (se *StringEncode) Process(ctx context.Context, payload any) (any, error) { payloadString, ok := payload.(string) if !ok { - return nil, fmt.Errorf("string.encode processor only accepts a string") + return nil, errors.New("string.encode processor only accepts a string") } payloadBytes := []byte(payloadString) diff --git a/internal/processor/string-filter.go b/internal/processor/string-filter.go index e8993d0..a1561dd 100644 --- a/internal/processor/string-filter.go +++ b/internal/processor/string-filter.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" "regexp" "github.com/jwetzell/showbridge-go/internal/config" @@ -17,7 +17,7 @@ func (se *StringFilter) Process(ctx context.Context, payload any) (any, error) { payloadString, ok := payload.(string) if !ok { - return nil, fmt.Errorf("string.filter processor only accepts a string") + return nil, errors.New("string.filter processor only accepts a string") } if !se.Pattern.MatchString(payloadString) { @@ -40,13 +40,13 @@ func init() { pattern, ok := params["pattern"] if !ok { - return nil, fmt.Errorf("http.request.filter requires a pattern parameter") + return nil, errors.New("string.filter requires a pattern parameter") } patternString, ok := pattern.(string) if !ok { - return nil, fmt.Errorf("http.request.filter pattern must be a string") + return nil, errors.New("string.filter pattern must be a string") } patternRegexp, err := regexp.Compile(patternString) diff --git a/internal/processor/string-split.go b/internal/processor/string-split.go index 3dbd0c9..10a51db 100644 --- a/internal/processor/string-split.go +++ b/internal/processor/string-split.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" "strings" "github.com/jwetzell/showbridge-go/internal/config" @@ -17,7 +17,7 @@ func (se *StringSplit) Process(ctx context.Context, payload any) (any, error) { payloadString, ok := payload.(string) if !ok { - return nil, fmt.Errorf("string.split only accepts a string") + return nil, errors.New("string.split only accepts a string") } payloadParts := strings.Split(payloadString, se.Separator) @@ -38,13 +38,13 @@ func init() { separator, ok := params["separator"] if !ok { - return nil, fmt.Errorf("string.split requires a separator") + return nil, errors.New("string.split requires a separator") } separatorString, ok := separator.(string) if !ok { - return nil, fmt.Errorf("string.split separator must be a string") + return nil, errors.New("string.split separator must be a string") } return &StringSplit{config: config, Separator: separatorString}, nil diff --git a/internal/processor/uint-parse.go b/internal/processor/uint-parse.go index b145647..2348a47 100644 --- a/internal/processor/uint-parse.go +++ b/internal/processor/uint-parse.go @@ -2,7 +2,7 @@ package processor import ( "context" - "fmt" + "errors" "strconv" "github.com/jwetzell/showbridge-go/internal/config" @@ -16,7 +16,7 @@ func (up *UintParse) Process(ctx context.Context, payload any) (any, error) { payloadString, ok := payload.(string) if !ok { - return nil, fmt.Errorf("uint.parse processor only accepts a string") + return nil, errors.New("uint.parse processor only accepts a string") } // TODO(jwetzell): make base and bitSize configurable diff --git a/router.go b/router.go index 9811ca2..ca4f348 100644 --- a/router.go +++ b/router.go @@ -2,6 +2,7 @@ package showbridge import ( "context" + "errors" "fmt" "log/slog" "sync" @@ -45,7 +46,7 @@ func NewRouter(ctx context.Context, config config.Config) (*Router, []module.Mod moduleErrors = append(moduleErrors, module.ModuleError{ Index: moduleIndex, Config: moduleDecl, - Error: fmt.Errorf("module type not defined"), + Error: errors.New("module type not defined"), }) continue } @@ -60,7 +61,7 @@ func NewRouter(ctx context.Context, config config.Config) (*Router, []module.Mod moduleErrors = append(moduleErrors, module.ModuleError{ Index: moduleIndex, Config: moduleDecl, - Error: fmt.Errorf("duplicate module id"), + Error: errors.New("duplicate module id"), }) break }