onyx_online/xair-cli
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/xair-cli.git synced 2026-02-26 08:19:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

timeout now a flag on the root command.

Browse Source 
It applies to all messages sent

new option function WithTimeout added
This commit is contained in:
onyx-and-iris 2026-02-06 11:28:40 +00:00
parent 1ad214ba4a
commit 3f8861ded2
13 changed files with 223 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
internal/xair/bus.go
View File

@ -26,8 +26,11 @@ func (b *Bus) Mute(bus int) (bool, error) {
return false, err
}
resp := <-b.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := b.client.ReceiveMessage()
if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return false, fmt.Errorf("unexpected argument type for bus mute value")
}
@ -52,8 +55,11 @@ func (b *Bus) Fader(bus int) (float64, error) {
return 0, err
}
resp := <-b.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := b.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for bus fader value")
}
@ -75,8 +81,11 @@ func (b *Bus) Name(bus int) (string, error) {
return "", fmt.Errorf("failed to send bus name request: %v", err)
}
resp := <-b.client.respChan
val, ok := resp.Arguments[0].(string)
msg, err := b.client.ReceiveMessage()
if err != nil {
return "", err
}
val, ok := msg.Arguments[0].(string)
if !ok {
return "", fmt.Errorf("unexpected argument type for bus name value")
}

30
internal/xair/client.go
View File

@ -41,6 +41,7 @@ func NewClient(mixerIP string, mixerPort int, opts ...Option) (*Client, error) {
e := &engine{
Kind: KindXAir,
timeout: 100 * time.Millisecond,
conn: conn,
mixerAddr: mixerAddr,
parser: newParser(),
@ -85,32 +86,35 @@ func (c *Client) SendMessage(address string, args ...any) error {
}
// ReceiveMessage receives an OSC message from the mixer
func (c *Client) ReceiveMessage(timeout time.Duration) (*osc.Message, error) {
t := time.Tick(timeout)
func (c *Client) ReceiveMessage() (*osc.Message, error) {
t := time.Tick(c.engine.timeout)
select {
case <-t:
return nil, nil
case val := <-c.respChan:
if val == nil {
return nil, fmt.Errorf("timeout waiting for response")
case msg := <-c.respChan:
if msg == nil {
return nil, fmt.Errorf("no message received")
}
return val, nil
return msg, nil
}
}
// RequestInfo requests mixer information
func (c *Client) RequestInfo() (InfoResponse, error) {
var info InfoResponse
err := c.SendMessage("/xinfo")
if err != nil {
return InfoResponse{}, err
return info, err
}
val := <-c.respChan
var info InfoResponse
if len(val.Arguments) >= 3 {
info.Host = val.Arguments[0].(string)
info.Name = val.Arguments[1].(string)
info.Model = val.Arguments[2].(string)
msg, err := c.ReceiveMessage()
if err != nil {
return info, err
}
if len(msg.Arguments) >= 3 {
info.Host = msg.Arguments[0].(string)
info.Name = msg.Arguments[1].(string)
info.Model = msg.Arguments[2].(string)
}
return info, nil
}

63
internal/xair/comp.go
View File

@ -31,8 +31,11 @@ func (c *Comp) On(index int) (bool, error) {
return false, err
}
resp := <-c.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := c.client.ReceiveMessage()
if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return false, fmt.Errorf("unexpected argument type for Compressor on value")
}
@ -59,8 +62,11 @@ func (c *Comp) Mode(index int) (string, error) {
possibleModes := []string{"comp", "exp"}
resp := <-c.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := c.client.ReceiveMessage()
if err != nil {
return "", err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return "", fmt.Errorf("unexpected argument type for Compressor mode value")
}
@ -82,8 +88,11 @@ func (c *Comp) Threshold(index int) (float64, error) {
return 0, err
}
resp := <-c.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := c.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor threshold value")
}
@ -106,8 +115,11 @@ func (c *Comp) Ratio(index int) (float32, error) {
possibleValues := []float32{1.1, 1.3, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 7.0, 10, 20, 100}
resp := <-c.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := c.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor ratio value")
}
@ -131,8 +143,11 @@ func (c *Comp) Attack(index int) (float64, error) {
return 0, err
}
resp := <-c.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := c.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor attack value")
}
@ -153,8 +168,11 @@ func (c *Comp) Hold(index int) (float64, error) {
return 0, err
}
resp := <-c.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := c.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor hold value")
}
@ -175,8 +193,11 @@ func (c *Comp) Release(index int) (float64, error) {
return 0, err
}
resp := <-c.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := c.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor release value")
}
@ -197,8 +218,11 @@ func (c *Comp) Makeup(index int) (float64, error) {
return 0, err
}
resp := <-c.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := c.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor makeup gain value")
}
@ -219,8 +243,11 @@ func (c *Comp) Mix(index int) (float64, error) {
return 0, err
}
resp := <-c.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := c.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor mix value")
}

3
internal/xair/engine.go
View File

@ -15,6 +15,7 @@ type parser interface {
type engine struct {
Kind MixerKind
timeout time.Duration
conn *net.UDPConn
mixerAddr *net.UDPAddr
@ -34,7 +35,7 @@ func (e *engine) receiveLoop() {
case <-e.done:
return
default:
// Set read timeout to avoid blocking forever
// Set a short read deadline to prevent blocking indefinitely
e.conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
n, _, err := e.conn.ReadFromUDP(buffer)
if err != nil {

42
internal/xair/eq.go
View File

@ -31,8 +31,11 @@ func (e *Eq) On(index int) (bool, error) {
return false, err
}
resp := <-e.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := e.client.ReceiveMessage()
if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return false, fmt.Errorf("unexpected argument type for EQ on value")
}
@ -58,8 +61,11 @@ func (e *Eq) Mode(index int) (string, error) {
possibleModes := []string{"peq", "geq", "teq"}
resp := <-e.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := e.client.ReceiveMessage()
if err != nil {
return "", err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return "", fmt.Errorf("unexpected argument type for EQ mode value")
}
@ -80,8 +86,11 @@ func (e *Eq) Gain(index int, band int) (float64, error) {
return 0, err
}
resp := <-e.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := e.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for EQ gain value")
}
@ -102,8 +111,11 @@ func (e *Eq) Frequency(index int, band int) (float64, error) {
return 0, err
}
resp := <-e.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := e.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for EQ frequency value")
}
@ -124,8 +136,11 @@ func (e *Eq) Q(index int, band int) (float64, error) {
return 0, err
}
resp := <-e.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := e.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for EQ Q value")
}
@ -148,8 +163,11 @@ func (e *Eq) Type(index int, band int) (string, error) {
possibleTypes := []string{"lcut", "lshv", "peq", "veq", "hshv", "hcut"}
resp := <-e.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := e.client.ReceiveMessage()
if err != nil {
return "", err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return "", fmt.Errorf("unexpected argument type for EQ type value")
}

49
internal/xair/gate.go
View File

@ -19,8 +19,11 @@ func (g *Gate) On(index int) (bool, error) {
return false, err
}
resp := <-g.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := g.client.ReceiveMessage()
if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return false, fmt.Errorf("unexpected argument type for Gate on value")
}
@ -47,8 +50,11 @@ func (g *Gate) Mode(index int) (string, error) {
possibleModes := []string{"exp2", "exp3", "exp4", "gate", "duck"}
resp := <-g.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := g.client.ReceiveMessage()
if err != nil {
return "", err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return "", fmt.Errorf("unexpected argument type for Gate mode value")
}
@ -71,8 +77,11 @@ func (g *Gate) Threshold(index int) (float64, error) {
return 0, err
}
resp := <-g.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := g.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for Gate threshold value")
}
@ -93,8 +102,11 @@ func (g *Gate) Range(index int) (float64, error) {
return 0, err
}
resp := <-g.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := g.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for Gate range value")
}
@ -115,8 +127,11 @@ func (g *Gate) Attack(index int) (float64, error) {
return 0, err
}
resp := <-g.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := g.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for Gate attack value")
}
@ -137,8 +152,11 @@ func (g *Gate) Hold(index int) (float64, error) {
return 0, err
}
resp := <-g.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := g.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for Gate hold value")
}
@ -159,8 +177,11 @@ func (g *Gate) Release(index int) (float64, error) {
return 0, err
}
resp := <-g.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := g.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for Gate release value")
}

14
internal/xair/headamp.go
View File

@ -22,8 +22,11 @@ func (h *HeadAmp) Gain(index int) (float64, error) {
return 0, err
}
resp := <-h.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := h.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for headamp gain value")
}
@ -45,8 +48,11 @@ func (h *HeadAmp) PhantomPower(index int) (bool, error) {
return false, err
}
resp := <-h.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := h.client.ReceiveMessage()
if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return false, fmt.Errorf("unexpected argument type for phantom power value")
}

14
internal/xair/main.go
View File

@ -31,8 +31,11 @@ func (m *Main) Fader() (float64, error) {
return 0, err
}
resp := <-m.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := m.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for main LR fader value")
}
@ -53,8 +56,11 @@ func (m *Main) Mute() (bool, error) {
return false, err
}
resp := <-m.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := m.client.ReceiveMessage()
if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return false, fmt.Errorf("unexpected argument type for main LR mute value")
}

8
internal/xair/option.go
View File

@ -1,5 +1,7 @@
package xair
import "time"
type Option func(*engine)
func WithKind(kind string) Option {
@ -8,3 +10,9 @@ func WithKind(kind string) Option {
e.addressMap = addressMapForMixerKind(e.Kind)
}
}
func WithTimeout(timeout time.Duration) Option {
return func(e *engine) {
e.timeout = timeout
}
}

7
internal/xair/snapshot.go
View File

@ -22,8 +22,11 @@ func (s *Snapshot) Name(index int) (string, error) {
return "", err
}
resp := <-s.client.respChan
name, ok := resp.Arguments[0].(string)
msg, err := s.client.ReceiveMessage()
if err != nil {
return "", err
}
name, ok := msg.Arguments[0].(string)
if !ok {
return "", fmt.Errorf("unexpected argument type for snapshot name")
}

35
internal/xair/strip.go
View File

@ -28,8 +28,11 @@ func (s *Strip) Mute(index int) (bool, error) {
return false, err
}
resp := <-s.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := s.client.ReceiveMessage()
if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return false, fmt.Errorf("unexpected argument type for strip mute value")
}
@ -54,8 +57,11 @@ func (s *Strip) Fader(strip int) (float64, error) {
return 0, err
}
resp := <-s.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := s.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for fader value")
}
@ -77,8 +83,11 @@ func (s *Strip) Name(strip int) (string, error) {
return "", fmt.Errorf("failed to send strip name request: %v", err)
}
resp := <-s.client.respChan
val, ok := resp.Arguments[0].(string)
msg, err := s.client.ReceiveMessage()
if err != nil {
return "", err
}
val, ok := msg.Arguments[0].(string)
if !ok {
return "", fmt.Errorf("unexpected argument type for strip name value")
}
@ -99,8 +108,11 @@ func (s *Strip) Color(strip int) (int32, error) {
return 0, fmt.Errorf("failed to send strip color request: %v", err)
}
resp := <-s.client.respChan
val, ok := resp.Arguments[0].(int32)
msg, err := s.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(int32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for strip color value")
}
@ -121,8 +133,11 @@ func (s *Strip) SendLevel(strip int, bus int) (float64, error) {
return 0, fmt.Errorf("failed to send strip send level request: %v", err)
}
resp := <-s.client.respChan
val, ok := resp.Arguments[0].(float32)
msg, err := s.client.ReceiveMessage()
if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok {
return 0, fmt.Errorf("unexpected argument type for strip send level value")
}

9
main.go
View File

@ -6,6 +6,7 @@ import (
"os"
"runtime/debug"
"strings"
"time"
"github.com/alecthomas/kong"
"github.com/charmbracelet/log"
@ -35,6 +36,7 @@ type Config struct {
Host string `default:"mixer.local" help:"The host of the X-Air device." env:"XAIR_CLI_HOST" short:"H"`
Port int `default:"10024" help:"The port of the X-Air device." env:"XAIR_CLI_PORT" short:"P"`
Kind string `default:"xair" help:"The kind of the X-Air device." env:"XAIR_CLI_KIND" short:"K" enum:"xair,x32"`
Timeout time.Duration `default:"100ms" help:"Timeout for OSC operations." env:"XAIR_CLI_TIMEOUT" short:"T"`
}
// CLI is the main struct for the command-line interface.
@ -107,7 +109,12 @@ func run(ctx *kong.Context, config Config) error {
// connect creates a new X-Air client based on the provided configuration.
func connect(config Config) (*xair.Client, error) {
client, err := xair.NewClient(config.Host, config.Port, xair.WithKind(config.Kind))
client, err := xair.NewClient(
config.Host,
config.Port,
xair.WithKind(config.Kind),
xair.WithTimeout(config.Timeout),
)
if err != nil {
return nil, err
}

11
raw.go
View File

@ -2,12 +2,12 @@ package main
import (
"fmt"
"time"
"github.com/charmbracelet/log"
)
// RawCmd represents the command to send raw OSC messages to the mixer.
type RawCmd struct {
Timeout time.Duration `help:"Timeout for the OSC message send operation." default:"100ms" short:"t" env:"XAIR_CLI_RAW_TIMEOUT"`
Address string `help:"The OSC address to send the message to." arg:""`
Args []string `help:"The arguments to include in the OSC message." arg:"" optional:""`
}
@ -22,7 +22,12 @@ func (cmd *RawCmd) Run(ctx *context) error {
return fmt.Errorf("failed to send raw OSC message: %w", err)
}
msg, err := ctx.Client.ReceiveMessage(cmd.Timeout)
if len(params) > 0 {
log.Debugf("Sent OSC message: %s with args: %v\n", cmd.Address, cmd.Args)
return nil
}
msg, err := ctx.Client.ReceiveMessage()
if err != nil {
return fmt.Errorf("failed to receive response for raw OSC message: %w", err)
}