massive breaking changes

Author: Brian Sorahan

bundle.go

@@ -1,9 +1,7 @@
 package osc
 
 import (
-	"bytes"
 	"encoding/binary"
-	"fmt"
 	"io"
 	"net"
 	"time"
@@ -62,27 +60,27 @@ func NewBundle() *Bundle {
 // parseBundle parses an OSC bundle from a slice of bytes.
 func parseBundle(data []byte, senderAddress net.Addr) (*Bundle, error) {
 	// Read the '#bundle' OSC string
-	startTag, _ := readPaddedString(data)
-	// *start += n
-
-	if startTag != BundleTag {
-		return nil, fmt.Errorf("Invalid bundle start tag: %s", startTag)
-	}
-
-	// Read the timetag
-	var (
-		timeTag uint64
-		r       = bytes.NewReader(data)
-	)
-	if err := binary.Read(r, binary.BigEndian, &timeTag); err != nil {
-		return nil, err
-	}
-	// *start += 8
-
-	// Create a new bundle
-	bundle := &Bundle{Timetag: Timetag(timeTag), SenderAddress: senderAddress}
-
-	return bundle, nil
+	// startTag, _ := readPaddedString(data)
+	// // *start += n
+
+	// if startTag != BundleTag {
+	// 	return nil, fmt.Errorf("Invalid bundle start tag: %s", startTag)
+	// }
+
+	// // Read the timetag
+	// var (
+	// 	timeTag uint64
+	// 	r       = bytes.NewReader(data)
+	// )
+	// if err := binary.Read(r, binary.BigEndian, &timeTag); err != nil {
+	// 	return nil, err
+	// }
+	// // *start += 8
+
+	// // Create a new bundle
+	// bundle := &Bundle{Timetag: Timetag(timeTag), SenderAddress: senderAddress}
+
+	return nil, nil
 }
 
 // Element is an implementation of the Elementer interface.

client.go

@@ -2,8 +2,7 @@ package osc
 
 import (
 	"bytes"
-	"log"
-	"os"
+	"net"
 	"testing"
 )
 
@@ -13,29 +12,39 @@ func TestClientSend(t *testing.T) {
 		errChan  = make(chan error, 1)
 	)
 
-	handlers := map[string]Method{
-		"/osc/address": func(msg *Message) {
+	dispatcher := map[string]Method{
+		"/osc/address": func(msg *Message) error {
 			doneChan <- msg
+			return nil
 		},
 	}
 
-	server, err := NewServer("127.0.0.1:0", handlers)
+	laddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer func() { _ = server.Close() }() // Best effort.
 
-	go func() {
-		errChan <- server.Listen()
-	}()
+	server, err := ListenUDP("udp", laddr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = server.Close() }() // Best effort.
 
-	_ = <-server.Listening
+	serverAddr := server.LocalAddr()
+	raddr, err := net.ResolveUDPAddr(serverAddr.Network(), serverAddr.String())
+	if err != nil {
+		t.Fatal(err)
+	}
 
-	client, err := NewClient(server.LocalAddr())
+	client, err := DialUDP("udp", nil, raddr)
 	if err != nil {
 		t.Fatal(err)
 	}
 
+	go func() {
+		errChan <- server.Serve(dispatcher) // Best effort.
+	}()
+
 	msg := NewMessage("/osc/address")
 	if err := msg.WriteInt32(111); err != nil {
 		t.Fatal(err)
@@ -48,11 +57,7 @@ func TestClientSend(t *testing.T) {
 	}
 
 	// Send a message.
-	data, err := msg.Bytes()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := client.Send(data); err != nil {
+	if err := client.Send(msg); err != nil {
 		t.Fatal(err)
 	}
 
@@ -66,76 +71,17 @@ func TestClientSend(t *testing.T) {
 
 	recvMsg := <-doneChan
 
-	recvData, err := recvMsg.Bytes()
+	recvData, err := recvMsg.bytes()
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if 0 != bytes.Compare(data, recvData[0:len(data)]) {
-		t.Fatalf("Expected %s got %s", data, recvData)
-	}
-}
-
-func ExampleClient() {
-	var (
-		doneChan = make(chan struct{})
-		errChan  = make(chan error, 1)
-	)
-
-	handlers := map[string]Method{
-		"/osc/address": func(msg *Message) {
-			errChan <- msg.Print(os.Stdout)
-			doneChan <- struct{}{}
-		},
-	}
-
-	server, err := NewServer("127.0.0.1:0", handlers)
+	data, err := msg.bytes()
 	if err != nil {
-		log.Fatal(err)
-	}
-	defer func() { _ = server.Close() }() // Best effort.
-
-	go func() {
-		errChan <- server.Listen()
-	}()
-
-	_ = <-server.Listening
-
-	client, err := NewClient(server.LocalAddr())
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	msg := NewMessage("/osc/address")
-	if err := msg.WriteInt32(111); err != nil {
-		log.Fatal(err)
-	}
-	if err := msg.WriteBool(true); err != nil {
-		log.Fatal(err)
-	}
-	if err := msg.WriteString("hello"); err != nil {
-		log.Fatal(err)
-	}
-
-	// Send a message.
-	data, err := msg.Bytes()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	if err := client.Send(data); err != nil {
-		log.Fatal(err)
+		t.Fatal(err)
 	}
 
-	select {
-	default:
-	case err := <-errChan:
-		if err != nil {
-			log.Fatal(err)
-		}
+	if 0 != bytes.Compare(data, recvData[0:len(data)]) {
+		t.Fatalf("Expected %s got %s", data, recvData)
 	}
-
-	_ = <-doneChan
-	// Output:
-	// /osc/address,iTs 111 true hello
 }

client_test.go

@@ -0,0 +1,38 @@
+package osc
+
+import (
+	"errors"
+	"net"
+	"strings"
+)
+
+const (
+	readBufSize = 4096
+)
+
+// Common errors.
+var (
+	errBundle         = errors.New("message is a bundle")
+	ErrNilDispatcher  = errors.New("nil dispatcher")
+	ErrPrematureClose = errors.New("server cannot be closed before calling Listen")
+	networkTCP        = "tcp"
+	networkUDP        = "udp"
+)
+
+// Conn defines the methods
+type Conn interface {
+	net.Conn
+	Serve(Dispatcher) error
+	Send(*Message) error
+}
+
+var invalidAddressRunes = []rune{'*', '?', ',', '[', ']', '{', '}', '#', ' '}
+
+func validateAddress(addr string) error {
+	for _, chr := range invalidAddressRunes {
+		if strings.ContainsRune(addr, chr) {
+			return ErrInvalidAddress
+		}
+	}
+	return nil
+}

conn.go

@@ -0,0 +1,56 @@
+package osc
+
+import (
+	"net"
+	"testing"
+)
+
+func TestInvalidAddress(t *testing.T) {
+	dispatcher := map[string]Method{
+		"/address*/test": func(msg *Message) error {
+			return nil
+		},
+	}
+	laddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	server, err := ListenUDP("udp", laddr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = server.Close() }() // Best effort.
+
+	if err := server.Serve(dispatcher); err != ErrInvalidAddress {
+		t.Fatal("expected invalid address error")
+	}
+	if server != nil {
+		_ = server.Close()
+	}
+}
+
+func TestMessageDispatching(t *testing.T) {
+	// dispatcher := map[string]Method{
+	// 	"/address/test": func(msg *Message) error {
+	// 		val, err := msg.ReadInt32()
+	// 		if err != nil {
+	// 			return err
+	// 		}
+	// 		if expected, got := int32(1122), val; expected != got {
+	// 			return fmt.Errorf("Expected %d got %d", expected, got)
+	// 		}
+	// 		return nil
+	// 	},
+	// }
+
+	laddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	server, err := ListenUDP("udp", laddr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = server.Close() }() // Best effort.
+}

conn_test.go

@@ -6,25 +6,28 @@ var (
 	ErrInvalidAddress = errors.New("invalid OSC address")
 )
 
-// oscDispatcher dispatches OSC packets.
-type oscDispatcher map[string]Method
+// Method is an OSC method
+type Method func(msg *Message) error
 
-// dispatchMessage dispatches OSC message.
-func (disp oscDispatcher) dispatchMessage(msg *Message) error {
+// Dispatcher dispatches OSC packets.
+type Dispatcher map[string]Method
+
+// DispatchMessage dispatches OSC message.
+func (disp Dispatcher) DispatchMessage(msg *Message) error {
 	for address, method := range disp {
 		matched, err := msg.Match(address)
 		if err != nil {
 			return err
 		}
 		if matched {
-			method(msg)
+			return method(msg)
 		}
 	}
 	return nil
 }
 
-// dispatchBundle dispatches an OSC bundle.
-func (disp oscDispatcher) dispatchBundle(bun *Bundle) error {
+// DispatchBundle dispatches an OSC bundle.
+func (disp Dispatcher) DispatchBundle(bun *Bundle) error {
 	for address, method := range disp {
 		bun.Invoke(address, method)
 	}