package main import ( "crypto/tls" "encoding/json" "fmt" "io" "log" "net/http" "net/url" "regexp" "strconv" "strings" mqtt "github.com/eclipse/paho.mqtt.golang" "gitlab.com/gomidi/midi/v2" "gitlab.com/gomidi/midi/v2/drivers" ) // LogLevel Definition type LogLevel int const ( // Logs only errors. ErrorLog LogLevel = iota // MQTT, HTTP, and MIDI receive logging. ReceiveLog // MQTT, HTTP, and MIDI send logging. SendLog // Debug messages. DebugLog ) // Provides a string value for a log level. func (l LogLevel) String() string { return [...]string{"Error", "Receive", "Send", "Debug"}[l] } // Configurations relating to MQTT connection. type MQTTConfig struct { // Hostname of the MQTT broker. Host string `fig:"host"` // Port of the MQTT broker. Port int `fig:"port"` // MQTT client ID of this relay. ClientId string `fig:"client_id"` // User name used for MQTT authentication. User string `fig:"user"` // Password used for MQTT authentication. Password string `fig:"password"` // Topic where MQTT messages are pushed and received. // Set topic to `midi/example` and the following topics will be setup. // midi/example/cmd - Any commands received on MIDI will publish here. // midi/example/send - Any commands pushed via MQTT will be forwarded to MIDI. // midi/example/status - Configuration is published on startup. // midi/example/status/check - Request status. Topic string `fig:"topic"` // Disable sending all midi notes. DisableMidiFirehose bool `fig:"disable_midi_firehose"` // Disables the config send. DisableConfigSend bool `fig:"disable_config_send"` } // Payload to decode/encode JSON message. type MQTTPayload struct { Channel uint8 `json:"channel"` Note uint8 `json:"note"` Velocity uint8 `json:"velocity"` } // Triggers that occur from MIDI messages received. type NoteTrigger struct { // If set, every note played will be matched. MatchAllNotes bool `fig:"match_all_notes"` // Channel to match. Channel uint8 `fig:"channel"` // Note to match. Note uint8 `fig:"note"` // Velocity to match. Velocity uint8 `fig:"velocity"` // If we should match all velocity values. MatchAllVelocities bool `fig:"match_all_velocities"` // Custom MQTT message. Do not set to ignore MQTT. MqttTopic string `fig:"mqtt_topic"` // Nil payload will generate a payload with midi info. MqttPayload []interface{} `fig:"mqtt_payload"` // If the HTTP request should includ midi info. MidiInfoInRequest bool `fig:"midi_info_in_request"` // Should SSL requests require a valid certificate. InsecureSkipVerify bool `fig:"insecure_skip_verify"` // The URL to call with the HTTP request. Do not set if you wish to not send HTTP request. URL string `fig:"url"` // HTTP method, defaults to GET. Method string `fig:"method"` // HTTP body. Body string `fig:"body"` // HTTP headers. Headers http.Header `fig:"headers"` } // Triggers that occur from HTTP or MQTT messsages received. type RequestTrigger struct { Channel uint8 `fig:"channel"` Note uint8 `fig:"note"` Velocity uint8 `fig:"velocity"` // Parse midi notes from HTTP request. MidiInfoInRequest bool `fig:"midi_info_in_request"` // Absolute MQTT topic to subscribe. MqttTopic string `fig:"mqtt_topic"` // Sub topic off relay MQTT topic to subscribe. // midi/example/$SUB_TOPIC MqttSubTopic string `fig:"mqtt_sub_topic"` // Rather or not to disallow payload to be relayed. DisallowPayload bool `fig:"disallow_payload"` // Request URL path to trigger with. URI string `fig:"uri"` } // A common router for both receiving and sending MIDI messages. type MidiRouter struct { // Used for human readable config. Name string `fig:"name"` // Midi device to connect. Device string `fig:"device"` // MQTT Connection if you are to integrate with MQTT. MQTT MQTTConfig `fig:"mqtt"` // Only connect for sending notes, not receiving. DisableListener bool `fig:"disable_listener"` // Listener triggers for notes to send HTTP and or MQTT messages. NoteTriggers []NoteTrigger `fig:"note_triggers"` // HTTP and or MQTT triggers to send MIDI notes. RequestTriggers []RequestTrigger `fig:"request_triggers"` // How much logging. // 0 - Errors // 1 - MQTT and OSC receive logging. // 2 - MQTT and OSC send logging. // 3 - Debug LogLevel LogLevel `yaml:"log_level" json:"log_level"` // Connection to MIDI device. MidiOut drivers.Out `fig:"-"` // Function to stop listening to MIDI device. ListenerStop func() `fig:"-"` // The client connection to MQTT. MqttClient mqtt.Client `yaml:"-" json:"-"` } // Logging function to allow log levels. func (r *MidiRouter) Log(level LogLevel, format string, args ...interface{}) { if level <= r.LogLevel { log.Println(fmt.Sprintf(format, args...)) } } // When a MIDI message occurs, send the HTTP request. func (r *MidiRouter) sendRequest(channel, note, velocity uint8) { // If MQTT firehose not disabled, send to general cmd topic. if r.MQTT.Host != "" && r.MQTT.Port != 0 && !r.MQTT.DisableMidiFirehose { payload := MQTTPayload{ Channel: channel, Note: note, Velocity: velocity, } data, err := json.Marshal(payload) if err != nil { r.Log(ErrorLog, "Json Encode: %s", err) } else { topic := r.MQTT.Topic + "/cmd" r.MqttClient.Publish(topic, 0, true, data) r.Log(SendLog, "-> [MQTT] %s", topic) } } // Check each trigger to find requests that match this message. for _, trig := range r.NoteTriggers { // If match all notes, process this request. // If not, check if channel, note, and velocity matches. // The velocity may be defined to accept all. if trig.MatchAllNotes || (trig.Channel == channel && trig.Note == note && (trig.Velocity == velocity || trig.MatchAllVelocities)) { // For all logging, we want to print the message so setup a common string to print. logInfo := fmt.Sprintf("note %s(%d) on channel %v with velocity %v", midi.Note(note), note, channel, velocity) if trig.MqttTopic != "" { if trig.MqttPayload != nil { r.MqttClient.Publish(trig.MqttTopic, 0, true, trig.MqttPayload) r.Log(SendLog, "-> [MQTT] %s", trig.MqttTopic) } else { payload := MQTTPayload{ Channel: channel, Note: note, Velocity: velocity, } data, err := json.Marshal(payload) if err != nil { r.Log(ErrorLog, "Json Encode: %s", err) } else { r.MqttClient.Publish(trig.MqttTopic, 0, true, data) r.Log(SendLog, "-> [MQTT] %s", trig.MqttTopic) } } } if trig.URL != "" { // Default method to GET if nothing is defined. if trig.Method == "" { trig.Method = "GET" } // Parse the URL to make sure its valid. url, err := url.Parse(trig.URL) // If not valid, we need to stop processing this request. if err != nil { r.Log(ErrorLog, "Trigger failed to parse url: %s\n %s", err, logInfo) continue } // If MIDI info needs to be added to the request, add it. if trig.MidiInfoInRequest { query := url.Query() query.Add("channel", strconv.Itoa(int(channel))) query.Add("note", strconv.Itoa(int(note))) query.Add("velocity", strconv.Itoa(int(velocity))) url.RawQuery = query.Encode() } // If body provided, setup a reader for it. var body io.Reader if trig.Body != "" { body = strings.NewReader(trig.Body) } // If debugging, log that we're starting a request. r.Log(DebugLog, "Starting request for trigger: %s %s\n%s", trig.Method, url.String(), logInfo) // Make the request. req, err := http.NewRequest(trig.Method, url.String(), body) if err != nil { r.Log(ErrorLog, "Trigger failed to parse url: %s\n %s", err, logInfo) continue } // Add headers to the request. req.Header = trig.Headers // Configure transport with trigger config. tr := &http.Transport{ TLSClientConfig: &tls.Config{InsecureSkipVerify: trig.InsecureSkipVerify}, } client := &http.Client{Transport: tr} // Perform the request. res, err := client.Do(req) if err != nil { r.Log(ErrorLog, "Trigger failed to request: %s\n %s", err, logInfo) continue } // Close the body at end of request. defer res.Body.Close() // If debug enabled, read the body and log it. if r.LogLevel >= DebugLog { body, err := io.ReadAll(res.Body) if err != nil { r.Log(ErrorLog, "Trigger failed to read body: %s\n %s", err, logInfo) continue } r.Log(DebugLog, "Trigger response: %s\n%s", logInfo, string(body)) } } } } } // Handler for HTTP requests. func (m *MidiRouter) Handler(w http.ResponseWriter, r *http.Request) { // Check each request trigger for ones that match the request URI. for _, t := range m.RequestTriggers { // If matches request, process MIDI message. if t.URI != "" && t.URI == r.URL.RawPath { // Set default values to those from this trigger. channel, note, velocity := t.Channel, t.Note, t.Velocity // If MIDI info is in the request query, update to request. if t.MidiInfoInRequest { query := r.URL.Query() // Regex to ensure only numbers are processed. numRx := regexp.MustCompile(`^[0-9]+$`) // Check for channel, and only configure if request has a valid value. ch := query.Get("channel") if numRx.MatchString(ch) { i, err := strconv.Atoi(ch) if err != nil && i <= 255 && i >= 0 { channel = uint8(i) } } // Check for note, and only configure if request has a valid value. key := query.Get("note") if numRx.MatchString(key) { i, err := strconv.Atoi(key) if err != nil && i < 255 && i >= 0 { note = uint8(i) } } // Check for velocity, and only configure if request has a valid value. vel := query.Get("velocity") if numRx.MatchString(vel) { i, err := strconv.Atoi(vel) if err != nil && i < 128 && i >= 0 { velocity = uint8(i) } } } // Get send function for output. send, err := midi.SendTo(m.MidiOut) if err != nil { m.Log(ErrorLog, "Failed to get midi sender for request: %s\n%s", t.URI, err) http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError) return } // Make the MIDI message based on information. msg := midi.NoteOn(channel, note, velocity) if velocity == 0 { msg = midi.NoteOff(channel, note) } // Send MIDI message. err = send(msg) if err != nil { m.Log(ErrorLog, "Failed to send midi message: %s\n%s", t.URI, err) http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError) return } // Update HTTP status to no content as an success message. http.Error(w, http.StatusText(http.StatusNoContent), http.StatusNoContent) } } } // Send config to MQTT status. func (r *MidiRouter) SendStatus() { // If disabled, ignore. if r.MQTT.DisableConfigSend { return } // Make JSON dump. config, err := json.Marshal(&r) if err != nil { r.Log(ErrorLog, "Json Error: %s", err) } // Send config. r.MqttClient.Publish(r.MQTT.Topic+"/status", 0, true, config) } // Handle MQTT events. func (r *MidiRouter) MqttOnEvent(client mqtt.Client, message mqtt.Message) { r.Log(ReceiveLog, "<- [MQTT] %s: %s\n", message.Topic(), message.Payload()) // Check commands to see if one matches this topic. for _, t := range r.RequestTriggers { if (t.MqttTopic != "" && message.Topic() == t.MqttTopic) || (t.MqttSubTopic != "" && message.Topic() == r.MQTT.Topic+"/"+t.MqttSubTopic) { // Set default values to those from this trigger. channel, note, velocity := t.Channel, t.Note, t.Velocity // If arguments allowed and provided, parse, otherwise use default payload. arguments := MQTTPayload{ Channel: channel, Note: note, Velocity: velocity, } if !t.DisallowPayload && len(message.Payload()) != 0 { err := json.Unmarshal(message.Payload(), &arguments) if err != nil { r.Log(ErrorLog, "Json Error: %s", err) return } channel = arguments.Channel note = arguments.Note velocity = arguments.Velocity } // Get send function for output. send, err := midi.SendTo(r.MidiOut) if err != nil { log.Printf("Failed to get midi sender for request: %s\n%s\n", message.Topic(), err) return } // Make the MIDI message based on information. msg := midi.NoteOn(channel, note, velocity) if velocity == 0 { msg = midi.NoteOff(channel, note) } // Send MIDI message. err = send(msg) if err != nil { log.Printf("Failed to send midi message: %s\n%s\n", message.Topic(), err) return } } } // If standard send topic. if strings.HasPrefix(message.Topic(), r.MQTT.Topic+"/send") { // If arguments allowed and provided, parse, otherwise use default payload. var arguments MQTTPayload if len(message.Payload()) != 0 { err := json.Unmarshal(message.Payload(), &arguments) if err != nil { r.Log(ErrorLog, "Json Error: %s", err) return } // Get send function for output. send, err := midi.SendTo(r.MidiOut) if err != nil { log.Printf("Failed to get midi sender for request: %s\n%s\n", message.Topic(), err) return } // Make the MIDI message based on information. msg := midi.NoteOn(arguments.Channel, arguments.Note, arguments.Velocity) if arguments.Velocity == 0 { msg = midi.NoteOff(arguments.Channel, arguments.Note) } // Send MIDI message. err = send(msg) if err != nil { log.Printf("Failed to send midi message: %s\n%s\n", message.Topic(), err) return } } } else if message.Topic() == r.MQTT.Topic+"/status/check" { r.SendStatus() } } // Subscribe to MQTT Topic. func (r *MidiRouter) MqttSubscribe(topic string) { r.Log(DebugLog, "Subscribing MQTT: %s", topic) if t := r.MqttClient.Subscribe(topic, 0, r.MqttOnEvent); t.Wait() && t.Error() != nil { r.Log(ErrorLog, "MQTT Subscribe Error: %s", t.Error()) } } // Connect to MIDI devices and start listening. func (r *MidiRouter) Connect() { // If request triggers defined, find the out port. if len(r.RequestTriggers) != 0 { out, err := midi.FindOutPort(r.Device) if err != nil { log.Println("Can't find output device:", r.Device) } else { r.MidiOut = out } } // If listener is disabled, stop here. if r.DisableListener { return } // Try finding input port. log.Println("Connecting to device:", r.Device) in, err := midi.FindInPort(r.Device) if err != nil { log.Println("Can't find device:", r.Device) return } // Start listening to MIDI messages. stop, err := midi.ListenTo(in, func(msg midi.Message, timestampms int32) { var channel, note, velocity uint8 switch { // Get notes with an velocity set. case msg.GetNoteStart(&channel, ¬e, &velocity): r.Log(ReceiveLog, "starting note %s(%d) on channel %v with velocity %v", midi.Note(note), note, channel, velocity) // Process request. r.sendRequest(channel, note, velocity) // If no velocity is set, an note end message is received. case msg.GetNoteEnd(&channel, ¬e): r.Log(ReceiveLog, "ending note %s(%d) on channel %v", midi.Note(note), note, channel) // Process request. r.sendRequest(channel, note, 0) default: // ignore } }) if err != nil { r.Log(ErrorLog, "Error listening to device: %s", err) return } // Update stop function for disconnects. r.ListenerStop = stop if r.MQTT.Host != "" && r.MQTT.Port != 0 { // Connect to MQTT. mqtt_opts := mqtt.NewClientOptions() mqtt_opts.AddBroker(fmt.Sprintf("tcp://%s:%d", r.MQTT.Host, r.MQTT.Port)) mqtt_opts.SetClientID(r.MQTT.ClientId) mqtt_opts.SetUsername(r.MQTT.User) mqtt_opts.SetPassword(r.MQTT.Password) r.MqttClient = mqtt.NewClient(mqtt_opts) // Connect and failures are fatal exiting service. r.Log(DebugLog, "Connecting to MQTT") if t := r.MqttClient.Connect(); t.Wait() && t.Error() != nil { log.Fatalf("MQTT error: %s", t.Error()) return } // Subscribe to MQTT topics. r.MqttSubscribe(r.MQTT.Topic + "/send") r.MqttSubscribe(r.MQTT.Topic + "/status/check") // Subscribe to command topics configured. for _, trig := range r.RequestTriggers { if trig.MqttTopic != "" { r.MqttSubscribe(trig.MqttTopic) } if trig.MqttSubTopic != "" { r.MqttSubscribe(r.MQTT.Topic + "/" + trig.MqttSubTopic) } } } } // On disconnect, stop and remove output device. func (r *MidiRouter) Disconnect() { r.MidiOut = nil if r.ListenerStop != nil { r.ListenerStop() } }