Skip to content

Commit d62addf

Browse files
author
Brian Sorahan
committed
Revert "use indices in argument methods"
This reverts commit caeff8e.
1 parent 5c1dadf commit d62addf

13 files changed

+546
-717
lines changed

‎Makefile

-2
This file was deleted.

‎bundle.go

+34-29
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ import (
55
"encoding/binary"
66
"errors"
77
"fmt"
8-
"io"
8+
"net"
99
"time"
1010
)
1111

@@ -26,6 +26,7 @@ var (
2626
type Bundle struct {
2727
Timetag Timetag
2828
Packets []Packet
29+
Sender net.Addr
2930
}
3031

3132
// NewBundle returns an OSC Bundle.
@@ -36,50 +37,54 @@ func NewBundle(t time.Time, packets ...Packet) *Bundle {
3637
}
3738
}
3839

39-
// WriteTo writes the bundle to w.
40-
func (b *Bundle) WriteTo(w io.Writer) (n int64, err error) {
40+
// Contents returns the contents of the bundle as a
41+
// slice of bytes.
42+
func (b *Bundle) Contents() ([]byte, error) {
43+
var (
44+
buf = &bytes.Buffer{}
45+
bytesWritten int64
46+
)
47+
4148
// Add the '#bundle' string
42-
nw, err := w.Write(bundlePrefix)
49+
bw, err := buf.Write(bundlePrefix)
4350
if err != nil {
44-
return 0, err
51+
return nil, err
4552
}
46-
n += int64(nw)
53+
bytesWritten += int64(bw)
4754

48-
for i := n; i%4 != 0; i++ {
49-
if _, err := w.Write([]byte{0}); err != nil {
50-
return 0, err
55+
for i := bytesWritten; i%4 != 0; i++ {
56+
if err := buf.WriteByte(0); err != nil {
57+
return nil, err
5158
}
52-
n++
59+
bytesWritten++
5360
}
5461

5562
// Add the timetag
56-
if err := binary.Write(w, byteOrder, b.Timetag); err != nil {
57-
return 0, err
63+
if err := binary.Write(buf, byteOrder, b.Timetag); err != nil {
64+
return nil, err
5865
}
59-
n += 8
66+
bytesWritten += 8
6067

6168
// Process all OSC Messages
6269
for _, p := range b.Packets {
63-
// TODO: would be nice to be able to get the length
64-
buf := &bytes.Buffer{}
65-
nw64, err := p.WriteTo(buf)
70+
contents, err := p.Contents()
6671
if err != nil {
67-
return 0, err
72+
return nil, err
6873
}
6974

70-
size := int32(nw64)
71-
if err := binary.Write(w, byteOrder, size); err != nil {
72-
return 0, err
75+
size := int32(len(contents))
76+
if err := binary.Write(buf, byteOrder, size); err != nil {
77+
return nil, err
7378
}
7479

75-
nw, err := w.Write(buf.Bytes())
80+
bw, err := buf.Write(contents)
7681
if err != nil {
77-
return 0, err
82+
return nil, err
7883
}
79-
n += int64(nw)
84+
bytesWritten += int64(bw)
8085
}
8186

82-
return n, nil
87+
return buf.Bytes(), nil
8388
}
8489

8590
// Invoke invokes an OSC method for each element of a
@@ -94,7 +99,7 @@ func (b *Bundle) Invoke(address string, method Method) error {
9499
}
95100

96101
for _, p := range b.Packets {
97-
if msg, ok := p.(*Message); !ok {
102+
if msg, ok := p.(*Message); ok {
98103
matched, err := msg.Match(address)
99104
if err != nil {
100105
return err
@@ -119,10 +124,10 @@ func (b *Bundle) Invoke(address string, method Method) error {
119124
}
120125

121126
// parseBundle parses an OSC bundle from a slice of bytes.
122-
func parseBundle(data []byte) (*Bundle, error) {
127+
func parseBundle(data []byte, sender net.Addr) (*Bundle, error) {
123128
var (
124129
i = 0
125-
b = &Bundle{}
130+
b = &Bundle{Sender: sender}
126131
)
127132
if len(data) < len(bundlePrefix) {
128133
return nil, fmt.Errorf("invalid bundle: %q", data)
@@ -150,13 +155,13 @@ ReadPackets:
150155
i += 4
151156
switch data[i] {
152157
case messageChar:
153-
pkt, err := parseMessage(data[i:])
158+
pkt, err := parseMessage(data[i:], sender)
154159
if err != nil {
155160
return nil, err
156161
}
157162
b.Packets = append(b.Packets, pkt)
158163
case bundleChar:
159-
pkt, err := parseBundle(data[i:])
164+
pkt, err := parseBundle(data[i:], sender)
160165
if err != nil {
161166
return nil, err
162167
}

‎bundle_test.go

+41-56
Original file line numberDiff line numberDiff line change
@@ -1,108 +1,93 @@
11
package osc
22

33
import (
4+
"bytes"
45
"net"
56
"testing"
67
"time"
78
)
89

9-
type TestClientUDP struct {
10-
Conn *UDPConn
11-
}
10+
func TestBundle(t *testing.T) {
11+
var (
12+
doneChan = make(chan *Message)
13+
errChan = make(chan error, 1)
14+
)
1215

13-
func newTestClientUDP(t *testing.T, addr net.Addr) *TestClientUDP {
14-
raddr, err := net.ResolveUDPAddr(addr.Network(), addr.String())
15-
if err != nil {
16-
t.Fatal(err)
17-
}
18-
client, err := DialUDP("udp", nil, raddr)
19-
if err != nil {
20-
t.Fatal(err)
16+
dispatcher := map[string]Method{
17+
"/osc/address": func(msg *Message) error {
18+
doneChan <- msg
19+
return nil
20+
},
2121
}
22-
return &TestClientUDP{Conn: client}
23-
}
24-
25-
type TestServerUDP struct {
26-
MsgChan chan *Message
27-
ErrChan chan error
28-
Conn *UDPConn
29-
}
30-
31-
func (ts *TestServerUDP) Close() error {
32-
// TODO: handle Serve errors after closing
33-
// close(ts.MsgChan)
34-
// close(ts.ErrChan)
35-
return ts.Conn.Close()
36-
}
3722

38-
func newTestServerUDP(t *testing.T) *TestServerUDP {
3923
laddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
4024
if err != nil {
4125
t.Fatal(err)
4226
}
27+
4328
server, err := ListenUDP("udp", laddr)
4429
if err != nil {
4530
t.Fatal(err)
4631
}
47-
ts := &TestServerUDP{
48-
MsgChan: make(chan *Message),
49-
ErrChan: make(chan error),
50-
Conn: server,
51-
}
52-
return ts
53-
}
54-
55-
func TestBundle(t *testing.T) {
56-
// TODO: fix
57-
t.SkipNow()
58-
59-
ts := newTestServerUDP(t)
60-
dispatcher := map[string]Method{
61-
"/osc/address": func(msg *Message) error {
62-
ts.MsgChan <- msg
63-
return nil
64-
},
65-
}
66-
defer func() { _ = ts.Close() }() // Best effort.
32+
defer func() { _ = server.Close() }() // Best effort.
6733

6834
go func() {
69-
ts.ErrChan <- ts.Conn.Serve(dispatcher) // Best effort.
35+
errChan <- server.Serve(dispatcher) // Best effort.
7036
}()
7137

72-
client := newTestClientUDP(t, ts.Conn.LocalAddr())
38+
serverAddr := server.LocalAddr()
39+
raddr, err := net.ResolveUDPAddr(serverAddr.Network(), serverAddr.String())
40+
if err != nil {
41+
t.Fatal(err)
42+
}
43+
44+
client, err := DialUDP("udp", nil, raddr)
45+
if err != nil {
46+
t.Fatal(err)
47+
}
7348

7449
msg, err := NewMessage("/osc/address")
7550
if err != nil {
7651
t.Fatal(err)
7752
}
78-
if err := msg.WriteInt32(0, 111); err != nil {
53+
if err := msg.WriteInt32(111); err != nil {
7954
t.Fatal(err)
8055
}
81-
if err := msg.WriteBool(1, true); err != nil {
56+
if err := msg.WriteBool(true); err != nil {
8257
t.Fatal(err)
8358
}
84-
if err := msg.WriteString(2, "hello"); err != nil {
59+
if err := msg.WriteString("hello"); err != nil {
8560
t.Fatal(err)
8661
}
8762

8863
bundle := NewBundle(time.Now(), msg)
8964

9065
// Send a message.
91-
if _, err := client.Conn.Send(bundle); err != nil {
66+
if err := client.Send(bundle); err != nil {
9267
t.Fatal(err)
9368
}
9469

9570
select {
9671
default:
97-
case err := <-ts.ErrChan:
72+
case err := <-errChan:
9873
if err != nil {
9974
t.Fatal(err)
10075
}
10176
}
10277

103-
recvMsg := <-ts.MsgChan
78+
recvMsg := <-doneChan
79+
80+
recvData, err := recvMsg.Contents()
81+
if err != nil {
82+
t.Fatal(err)
83+
}
10484

105-
if err := msg.Compare(recvMsg); err != nil {
85+
data, err := msg.Contents()
86+
if err != nil {
10687
t.Fatal(err)
10788
}
89+
90+
if 0 != bytes.Compare(data, recvData[0:len(data)]) {
91+
t.Fatalf("Expected %s got %s", data, recvData)
92+
}
10893
}

‎conn.go

+7
Original file line numberDiff line numberDiff line change
@@ -6,10 +6,17 @@ import (
66
"strings"
77
)
88

9+
const (
10+
readBufSize = 4096
11+
)
12+
913
// Common errors.
1014
var (
15+
errBundle = errors.New("message is a bundle")
1116
ErrNilDispatcher = errors.New("nil dispatcher")
1217
ErrPrematureClose = errors.New("server cannot be closed before calling Listen")
18+
networkTCP = "tcp"
19+
networkUDP = "udp"
1320
)
1421

1522
// Conn defines the methods

0 commit comments

Comments
 (0)