IsReachable and WaitUntilReachable implemented

check_reachable.go

@@ -0,0 +1,37 @@
+package hypr
+
+import (
+	"context"
+	"strings"
+	"time"
+)
+
+// IsReachable pings the unix socket to check
+// if Hyprland is ready to accept incoming requests
+func (c *Client) IsReachable() bool {
+	str, err := readSocketString(c.SocketPath(), strings.NewReader("dispatch exec echo"))
+	if err != nil {
+		return false
+	}
+
+	return str == "ok"
+}
+
+// WaitUntilReachable periodically calls IsReachable
+// and returns true as soon as IsReachable returns true.
+// When ctx is closed before Hyprland is reachable, false is returned
+func (c *Client) WaitUntilReachable(ctx context.Context) bool {
+	ticker := time.NewTicker(100 * time.Millisecond)
+	defer ticker.Stop()
+
+	select {
+	case <-ticker.C:
+		if c.IsReachable() {
+			return true
+		}
+	case <-ctx.Done():
+		return false
+	}
+
+	return false
+}

dispatch.go

@@ -6,12 +6,12 @@ import (
 	"strings"
 )
 
-func (i *Instance) Dispatch(cmd string) (io.ReadCloser, error) {
+func (c *Client) Dispatch(cmd string) (io.ReadCloser, error) {
-	return readSocketRaw(i.SocketPath(), strings.NewReader(fmt.Sprintf("dispatch %s", cmd)))
+	return readSocketRaw(c.SocketPath(), strings.NewReader(fmt.Sprintf("dispatch %s", cmd)))
 }
 
-func (i *Instance) DispatchExpectOK(cmd string) error {
+func (c *Client) DispatchExpectOK(cmd string) error {
-	str, err := readSocketString(i.SocketPath(), strings.NewReader(fmt.Sprintf("dispatch %s", cmd)))
+	str, err := readSocketString(c.SocketPath(), strings.NewReader(fmt.Sprintf("dispatch %s", cmd)))
 	if err != nil {
 		return err
 	}

get_clients.go

@@ -12,7 +12,7 @@ import (
 	"git.milar.in/milarin/slices"
 )
 
-func GetInstance(signature string) (*Instance, error) {
+func GetClient(signature string) (*Client, error) {
 	lockFilePath := fmt.Sprintf("/tmp/hypr/%s.lock", signature)
 
 	file, err := os.Open(lockFilePath)
@@ -33,38 +33,38 @@ func GetInstance(signature string) (*Instance, error) {
 		return nil, err
 	}
 
-	return &Instance{
+	return &Client{
 		Signature:     signature,
 		PID:           pid,
 		WaylandSocket: lines[1],
 	}, nil
 }
 
-func GetDefaultInstance() (*Instance, error) {
+func GetDefaultClient() (*Client, error) {
 	signature, ok := os.LookupEnv("HYPRLAND_INSTANCE_SIGNATURE")
 	if !ok {
 		return nil, errors.New("default instance not found because HYPRLAND_INSTANCE_SIGNATURE is not set")
 	}
 
-	return GetInstance(signature)
+	return GetClient(signature)
 }
 
-func GetInstances() ([]*Instance, error) {
+func GetClients() ([]*Client, error) {
 	entries, err := os.ReadDir("/tmp/hypr")
 	if err != nil {
 		return nil, err
 	}
 
 	entries = slices.Filter(entries, fs.DirEntry.IsDir)
-	instances := make([]*Instance, 0, len(entries))
+	clients := make([]*Client, 0, len(entries))
 	for _, entry := range entries {
-		instance, err := GetInstance(entry.Name())
+		client, err := GetClient(entry.Name())
 		if err != nil {
 			fmt.Println(err)
 			continue
 		}
-		instances = append(instances, instance)
+		clients = append(clients, client)
 	}
 
-	return instances, nil
+	return clients, nil
 }

getters.go

@@ -4,30 +4,30 @@ import (
 	"strings"
 )
 
-func (i *Instance) GetActiveWindow() (*Window, error) {
+func (i *Client) GetActiveWindow() (*Window, error) {
 	return readSocket[*Window](i.SocketPath(), strings.NewReader("j/activewindow"))
 }
 
-func (i *Instance) GetActiveWorkspace() (*Workspace, error) {
+func (i *Client) GetActiveWorkspace() (*Workspace, error) {
 	return readSocket[*Workspace](i.SocketPath(), strings.NewReader("j/activeworkspace"))
 }
 
-func (i *Instance) GetBinds() ([]*Bind, error) {
+func (i *Client) GetBinds() ([]*Bind, error) {
 	return readSocket[[]*Bind](i.SocketPath(), strings.NewReader("j/binds"))
 }
 
-func (i *Instance) GetWindows() ([]*Window, error) {
+func (i *Client) GetWindows() ([]*Window, error) {
 	return readSocket[[]*Window](i.SocketPath(), strings.NewReader("j/clients"))
 }
 
-func (i *Instance) GetCursorPos() (Point, error) {
+func (i *Client) GetCursorPos() (Point, error) {
 	return readSocket[Point](i.SocketPath(), strings.NewReader("j/cursorpos"))
 }
 
-func (i *Instance) GetMonitors() ([]*Monitor, error) {
+func (i *Client) GetMonitors() ([]*Monitor, error) {
 	return readSocket[[]*Monitor](i.SocketPath(), strings.NewReader("j/monitors"))
 }
 
-func (i *Instance) GetWorkspaces() ([]*Workspace, error) {
+func (i *Client) GetWorkspaces() ([]*Workspace, error) {
 	return readSocket[[]*Workspace](i.SocketPath(), strings.NewReader("j/workspaces"))
 }

model_instance.go

@@ -5,21 +5,21 @@ import (
 	"fmt"
 )
 
-type Instance struct {
+type Client struct {
 	Signature     string `json:"instance"`
 	PID           int    `json:"pid"`
 	WaylandSocket string `json:"wl_socket"`
 }
 
-func (i Instance) String() string {
+func (c Client) String() string {
-	data, _ := json.MarshalIndent(i, "", "\t")
+	data, _ := json.MarshalIndent(c, "", "\t")
 	return string(data)
 }
 
-func (i Instance) SocketPath() string {
+func (c Client) SocketPath() string {
-	return fmt.Sprintf("/tmp/hypr/%s/.socket.sock", i.Signature)
+	return fmt.Sprintf("/tmp/hypr/%s/.socket.sock", c.Signature)
 }
 
-func (i Instance) EventSocketPath() string {
+func (c Client) EventSocketPath() string {
-	return fmt.Sprintf("/tmp/hypr/%s/.socket2.sock", i.Signature)
+	return fmt.Sprintf("/tmp/hypr/%s/.socket2.sock", c.Signature)
 }

subscribe_event.go

@@ -8,7 +8,7 @@ import (
 	"git.milar.in/milarin/slices"
 )
 
-func (i *Instance) Subscribe(ctx context.Context, events ...EventType) (<-chan Event, error) {
+func (i *Client) Subscribe(ctx context.Context, events ...EventType) (<-chan Event, error) {
 	r, err := readSocketRaw(i.EventSocketPath(), strings.NewReader(""))
 	if err != nil {
 		return nil, err