Broadcast discovery with InfoAll, interface broadcast detection, clean output

lib/client/client.go

@@ -16,6 +16,7 @@ type transport interface {
 	Send(data []byte) error
 	SetReadTimeout(timeout time.Duration)
 	Reader() io.Reader
+	Broadcast() bool
 	Close() error
 }
 
@@ -44,59 +45,71 @@ func (c *Client) send(msg any) (uint32, error) {
 	return id, c.transport.Send(data)
 }
 
-func (c *Client) receive(expectedID uint32) (any, error) {
-	c.transport.SetReadTimeout(c.timeout)
-	dec := msgpack.NewDecoder(c.transport.Reader())
-	var env Envelope
-	if err := dec.Decode(&env); err != nil {
-		return nil, fmt.Errorf("decode envelope: %w", err)
-	}
-	if env.MessageID != expectedID {
-		return nil, fmt.Errorf("message id mismatch: got %d, want %d", env.MessageID, expectedID)
-	}
-	expected := halfsiphash.Sum32(env.Payload, HashKey)
-	if env.Checksum != expected {
-		return nil, fmt.Errorf("checksum mismatch: got %08x, want %08x", env.Checksum, expected)
-	}
-	var inner any
-	if err := msgpack.Unmarshal(env.Payload, &inner); err != nil {
-		return nil, fmt.Errorf("decode inner: %w", err)
-	}
-	if devErr, ok := inner.(*DeviceError); ok {
-		return nil, devErr
-	}
-	return inner, nil
-}
-
-func roundTrip[T any](c *Client, req any) (*T, error) {
+func roundTrip[T any](c *Client, req any) ([]*T, error) {
 	id, err := c.send(req)
 	if err != nil {
 		return nil, err
 	}
-	resp, err := c.receive(id)
+	c.transport.SetReadTimeout(c.timeout)
+	dec := msgpack.NewDecoder(c.transport.Reader())
+	broadcast := c.transport.Broadcast()
+	var results []*T
+	for {
+		var env Envelope
+		if err := dec.Decode(&env); err != nil {
+			break
+		}
+		if env.MessageID != id {
+			continue
+		}
+		expected := halfsiphash.Sum32(env.Payload, HashKey)
+		if env.Checksum != expected {
+			continue
+		}
+		var inner any
+		if err := msgpack.Unmarshal(env.Payload, &inner); err != nil {
+			continue
+		}
+		if devErr, ok := inner.(*DeviceError); ok {
+			return nil, devErr
+		}
+		if typed, ok := inner.(*T); ok {
+			results = append(results, typed)
+			if !broadcast {
+				break
+			}
+		}
+	}
+	return results, nil
+}
+
+func first[T any](results []*T, err error) (*T, error) {
 	if err != nil {
 		return nil, err
 	}
-	typed, ok := resp.(*T)
-	if !ok {
-		return nil, fmt.Errorf("unexpected response: %T", resp)
+	if len(results) == 0 {
+		return nil, fmt.Errorf("no response")
 	}
-	return typed, nil
+	return results[0], nil
 }
 
 func (c *Client) PICOBOOT() error {
-	_, err := roundTrip[ResponsePICOBOOT](c, &RequestPICOBOOT{})
+	_, err := first(roundTrip[ResponsePICOBOOT](c, &RequestPICOBOOT{}))
 	return err
 }
 
 func (c *Client) Info() (*ResponseInfo, error) {
+	return first(roundTrip[ResponseInfo](c, &RequestInfo{}))
+}
+
+func (c *Client) InfoAll() ([]*ResponseInfo, error) {
 	return roundTrip[ResponseInfo](c, &RequestInfo{})
 }
 
 func (c *Client) Log() (*ResponseLog, error) {
-	return roundTrip[ResponseLog](c, &RequestLog{})
+	return first(roundTrip[ResponseLog](c, &RequestLog{}))
 }
 
 func (c *Client) Test(name string) (*ResponseTest, error) {
-	return roundTrip[ResponseTest](c, &RequestTest{Name: name})
+	return first(roundTrip[ResponseTest](c, &RequestTest{Name: name}))
 }