provide the ability to create OSC servers that only dispatch to methods that match a message's address exactly

Author: briansorahan

dispatcher.go

@@ -29,23 +29,23 @@ type MessageHandler interface {
 type Dispatcher map[string]MessageHandler
 
 // Dispatch invokes an OSC bundle's messages.
-func (d Dispatcher) Dispatch(b Bundle) error {
+func (d Dispatcher) Dispatch(b Bundle, exactMatch bool) error {
 	var (
 		now = time.Now()
 		tt  = b.Timetag.Time()
 	)
 	if tt.Before(now) {
-		return d.immediately(b)
+		return d.immediately(b, exactMatch)
 	}
 	<-time.After(tt.Sub(now))
-	return d.immediately(b)
+	return d.immediately(b, exactMatch)
 }
 
 // immediately invokes an OSC bundle immediately.
-func (d Dispatcher) immediately(b Bundle) error {
+func (d Dispatcher) immediately(b Bundle, exactMatch bool) error {
 	for _, p := range b.Packets {
 		errs := []string{}
-		if err := d.invoke(p); err != nil {
+		if err := d.invoke(p, exactMatch); err != nil {
 			errs = append(errs, err.Error())
 		}
 		if len(errs) > 0 {
@@ -57,21 +57,21 @@ func (d Dispatcher) immediately(b Bundle) error {
 }
 
 // invoke invokes an OSC packet, which could be a message or a bundle of messages.
-func (d Dispatcher) invoke(p Packet) error {
+func (d Dispatcher) invoke(p Packet, exactMatch bool) error {
 	switch x := p.(type) {
 	case Message:
-		return d.Invoke(x)
+		return d.Invoke(x, exactMatch)
 	case Bundle:
-		return d.immediately(x)
+		return d.immediately(x, exactMatch)
 	default:
 		return errors.Errorf("unsupported type for dispatcher: %T", p)
 	}
 }
 
 // Invoke invokes an OSC message.
-func (d Dispatcher) Invoke(msg Message) error {
+func (d Dispatcher) Invoke(msg Message, exactMatch bool) error {
 	for address, handler := range d {
-		matched, err := msg.Match(address)
+		matched, err := msg.Match(address, exactMatch)
 		if err != nil {
 			return err
 		}

dispatcher_test.go

@@ -23,7 +23,7 @@ func TestDispatcherDispatchOK(t *testing.T) {
 			Message{Address: "/bar"},
 		},
 	}
-	if err := d.Dispatch(b); err != nil {
+	if err := d.Dispatch(b, false); err != nil {
 		t.Fatal(err)
 	}
 	<-c
@@ -43,7 +43,7 @@ func TestDispatcherDispatchError(t *testing.T) {
 			Message{Address: "/foo"},
 		},
 	}
-	if err := d.Dispatch(b); err == nil {
+	if err := d.Dispatch(b, false); err == nil {
 		t.Fatal("expected error, got nil")
 	}
 }
@@ -68,7 +68,7 @@ func TestDispatcherDispatchNestedBundle(t *testing.T) {
 			},
 		},
 	}
-	if err := d.Dispatch(b); err != nil {
+	if err := d.Dispatch(b, false); err != nil {
 		t.Fatal(err)
 	}
 	<-c
@@ -83,7 +83,7 @@ func TestDispatcherMiss(t *testing.T) {
 	b := Bundle{
 		Timetag: FromTime(time.Now()),
 	}
-	if err := d.Dispatch(b); err != nil {
+	if err := d.Dispatch(b, false); err != nil {
 		t.Fatal(err)
 	}
 }
@@ -98,20 +98,20 @@ func TestDispatcherInvoke(t *testing.T) {
 		}),
 	}
 	msg := Message{Address: "/foo"}
-	if err := d.Invoke(msg); err == nil {
+	if err := d.Invoke(msg, false); err == nil {
 		t.Fatal("expected error, got nil")
 	}
 	badMsg := Message{Address: "/["}
-	if err := d.Invoke(badMsg); err == nil {
+	if err := d.Invoke(badMsg, false); err == nil {
 		t.Fatal("expected error, got nil")
 	}
-	if err := d.Invoke(Message{Address: "/bar"}); err != nil {
+	if err := d.Invoke(Message{Address: "/bar"}, false); err != nil {
 		t.Fatal(err)
 	}
-	if err := d.Invoke(Message{Address: "/baz"}); err != nil {
+	if err := d.Invoke(Message{Address: "/baz"}, false); err != nil {
 		t.Fatal(err)
 	}
-	if err := d.invoke(badPacket{}); err == nil {
+	if err := d.invoke(badPacket{}, false); err == nil {
 		t.Fatal("expected error, got nil")
 	}
 }

message.go

@@ -81,7 +81,10 @@ func (msg Message) Equal(other Packet) bool {
 }
 
 // Match returns true if the address of the OSC Message matches the given address.
-func (msg Message) Match(address string) (bool, error) {
+func (msg Message) Match(address string, exactMatch bool) (bool, error) {
+	if exactMatch {
+		return address == msg.Address, nil
+	}
 	// Verify same number of parts.
 	if !VerifyParts(address, msg.Address) {
 		return false, nil

message_test.go

@@ -85,7 +85,7 @@ func TestMatch(t *testing.T) {
 		{"/path/to/m[aei]thod", "/path/to/method"},
 	} {
 		msg := Message{Address: pair[0]}
-		match, err := msg.Match(pair[1])
+		match, err := msg.Match(pair[1], false)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -103,7 +103,7 @@ func TestMatch(t *testing.T) {
 		{"/path/to/[domet]", "/path/to/method"},
 	} {
 		msg := Message{Address: pair[0]}
-		match, err := msg.Match(pair[1])
+		match, err := msg.Match(pair[1], false)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -113,7 +113,7 @@ func TestMatch(t *testing.T) {
 	}
 
 	msg := Message{Address: `/[`}
-	if _, err := msg.Match(`/a`); err == nil {
+	if _, err := msg.Match(`/a`, false); err == nil {
 		t.Fatalf("expected error, got nil")
 	}
 }

osc.go

@@ -128,7 +128,7 @@ type readSender interface {
 	read([]byte) (int, net.Addr, error)
 }
 
-func serve(r readSender, numWorkers int, dispatcher Dispatcher) error {
+func serve(r readSender, numWorkers int, exactMatch bool, dispatcher Dispatcher) error {
 	if err := checkDispatcher(dispatcher); err != nil {
 		return err
 	}
@@ -142,6 +142,7 @@ func serve(r readSender, numWorkers int, dispatcher Dispatcher) error {
 			Dispatcher: dispatcher,
 			ErrChan:    errChan,
 			Ready:      ready,
+			ExactMatch: exactMatch,
 		}.Run()
 	}
 	go workerLoop(r, ready, errChan)

udp.go

@@ -19,9 +19,10 @@ type udpConn interface {
 type UDPConn struct {
 	udpConn
 
-	closeChan chan struct{}
-	ctx       context.Context
-	errChan   chan error
+	closeChan  chan struct{}
+	ctx        context.Context
+	errChan    chan error
+	exactMatch bool
 }
 
 // DialUDP creates a new OSC connection over UDP.
@@ -111,10 +112,18 @@ func (conn *UDPConn) SendTo(addr net.Addr, p Packet) error {
 // Note that this means that errors returned from a dispatcher method will kill your server.
 // If context.Canceled or context.DeadlineExceeded are encountered they will be returned directly.
 func (conn *UDPConn) Serve(numWorkers int, dispatcher Dispatcher) error {
-	return serve(conn, numWorkers, dispatcher)
+	return serve(conn, numWorkers, conn.exactMatch, dispatcher)
 }
 
 // SetContext sets the context associated with the conn.
 func (conn *UDPConn) SetContext(ctx context.Context) {
 	conn.ctx = ctx
 }
+
+// SetExactMatch changes the behavior of the Serve method so that
+// messages will only be dispatched to methods whose addresses
+// match the message's address exactly.
+// This should provide some performance improvement.
+func (conn *UDPConn) SetExactMatch(value bool) {
+	conn.exactMatch = value
+}

unix.go

@@ -21,9 +21,10 @@ type unixConn interface {
 type UnixConn struct {
 	unixConn
 
-	closeChan chan struct{}
-	ctx       context.Context
-	errChan   chan error
+	closeChan  chan struct{}
+	ctx        context.Context
+	errChan    chan error
+	exactMatch bool
 }
 
 // DialUnix opens a unix socket for OSC communication.
@@ -111,10 +112,18 @@ func (conn *UnixConn) SendTo(addr net.Addr, p Packet) error {
 // Note that this means that errors returned from a dispatcher method will kill your server.
 // If context.Canceled or context.DeadlineExceeded are encountered they will be returned directly.
 func (conn *UnixConn) Serve(numWorkers int, dispatcher Dispatcher) error {
-	return serve(conn, numWorkers, dispatcher)
+	return serve(conn, numWorkers, conn.exactMatch, dispatcher)
 }
 
 // TempSocket creates an absolute path to a temporary socket file.
 func TempSocket() string {
 	return filepath.Join(os.TempDir(), ulid.New().String()) + ".sock"
 }
+
+// SetExactMatch changes the behavior of the Serve method so that
+// messages will only be dispatched to methods whose addresses
+// match the message's address exactly.
+// This should provide some performance improvement.
+func (conn *UnixConn) SetExactMatch(value bool) {
+	conn.exactMatch = value
+}

worker.go

@@ -10,6 +10,7 @@ type Worker struct {
 	Dispatcher Dispatcher
 	ErrChan    chan error
 	Ready      chan<- Worker
+	ExactMatch bool
 }
 
 // Run runs the worker.
@@ -25,15 +26,15 @@ func (w Worker) Run() {
 			if err != nil {
 				w.ErrChan <- err
 			}
-			if err := w.Dispatcher.Dispatch(bundle); err != nil {
+			if err := w.Dispatcher.Dispatch(bundle, w.ExactMatch); err != nil {
 				w.ErrChan <- errors.Wrap(err, "dispatch bundle")
 			}
 		case MessageChar:
 			msg, err := ParseMessage(data, incoming.Sender)
 			if err != nil {
 				w.ErrChan <- err
 			}
-			if err := w.Dispatcher.Invoke(msg); err != nil {
+			if err := w.Dispatcher.Invoke(msg, w.ExactMatch); err != nil {
 				w.ErrChan <- errors.Wrap(err, "dispatch message")
 			}
 		default: