Implement connection, authentication, and heartbeat

Author: christopher-dG

.travis.yml

@@ -2,3 +2,5 @@ language: go
 go:
   - 1.10.x
   - master
+notifications:
+  email: false

README.md

@@ -1,6 +1,7 @@
-
 # go-obs-websocket
 
+[![Build Status](https://travis-ci.com/christopher-dG/go-obs-websocket.svg?branch=master)](https://travis-ci.com/christopher-dG/go-obs-websocket)
+
 `go-obs-websocket` is a package for interacting with [`obs-websocket`](https://github.com/Palakis/obs-websocket).
 
 ## Installation
@@ -12,9 +13,19 @@ go get github.com/christopher-dG/go-obs-websocket
 ## Usage
 
 ```go
-import obs "github.com/christopher-dG/go-obs-websocket"
+package main
+
+import (
+    "log"
+
+    obs "github.com/christopher-dG/go-obs-websocket"
+)
 
-client := obs.NewClientClient("localhost", 4444, "")
+client := obs.NewClient("localhost", 4444, "")
+if err := client.Connect(); err != nil {
+    log.Fatal(err)
+}
+defer client.Close()
 
 // TODO
 ```

client.go

@@ -1,31 +1,19 @@
 package obsws
 
-// Client is the interface to OBS's websockets.
-type Client struct {
-	host     string
-	port     int
-	password string
+import "github.com/gorilla/websocket"
+
+// client is the interface to obs-websocket.
+type client struct {
+	Host     string // Host (probably "localhost").
+	Port     int    // Port (OBS default is 4444).
+	Password string // Password (OBS default is "").
+	conn     *websocket.Conn
+	id       int
 }
 
-// NewClient creates a new Client. If you haven't configured obs-websocket at
+// NewClient creates a new client. If you haven't configured obs-websocket at
 // all, then host should be "localhost", port should be 4444, and password
 // should be "".
-func NewClient(host string, port int, password string) *Client {
-	return &Client{host: host, port: port, password: password}
-}
-
-// Host returns the Client's host.
-func (c *Client) Host() string {
-	return c.host
-}
-
-// Port returns the Client's port.
-func (c *Client) Port() int {
-	return c.port
-
-}
-
-// Password returns the Client's password.
-func (c *Client) Password() string {
-	return c.password
+func NewClient(host string, port int, password string) *client {
+	return &client{Host: host, Port: port, Password: password}
 }

client_test.go

@@ -4,13 +4,13 @@ import "testing"
 
 func TestNewClient(t *testing.T) {
 	c := NewClient("localhost", 4444, "")
-	if c.Host() != "localhost" {
-		t.Errorf("expected c.Host() == 'localhost', got '%s'", c.Host())
+	if c.Host != "localhost" {
+		t.Errorf("expected c.Host == 'localhost', got '%s'", c.Host)
 	}
-	if c.Port() != 4444 {
-		t.Errorf("expected c.Port() == 4444, got '%d'", c.Port())
+	if c.Port != 4444 {
+		t.Errorf("expected c.Port == 4444, got '%d'", c.Port)
 	}
-	if c.Password() != "" {
-		t.Errorf("expected c.Password() == '', got '%s'", c.Password())
+	if c.Password != "" {
+		t.Errorf("expected c.Password == '', got '%s'", c.Password)
 	}
 }

connection.go

@@ -0,0 +1,114 @@
+package obsws
+
+import (
+	"crypto/sha256"
+	"encoding/base64"
+	"fmt"
+
+	"github.com/gorilla/websocket"
+	"github.com/pkg/errors"
+)
+
+// https://github.com/Palakis/obs-websocket/blob/master/docs/generated/protocol.md#authentication
+// https://github.com/Palakis/obs-websocket/blob/master/docs/generated/protocol.md#getauthrequired
+// https://github.com/Palakis/obs-websocket/blob/master/docs/generated/protocol.md#authenticate
+
+type getAuthRequiredRequest struct {
+	MessageID   string `json:"message-id"`
+	RequestType string `json:"request-type"`
+}
+
+func (r *getAuthRequiredRequest) ID() string {
+	return r.MessageID
+}
+
+type getAuthRequiredResponse struct {
+	MessageID    string `json:"message-id"`
+	Status       string `json:"status"`
+	Error        string `json:"error"`
+	AuthRequired bool   `json:"authRequired"`
+	Challenge    string `json:"challenge"`
+	Salt         string `json:"salt"`
+}
+
+func (r *getAuthRequiredResponse) ID() string {
+	return r.MessageID
+}
+
+type authenticateRequest struct {
+	MessageID   string `json:"message-id"`
+	RequestType string `json:"request-type"`
+	Auth        string `json:"auth"`
+}
+
+func (r *authenticateRequest) ID() string {
+	return r.MessageID
+}
+
+// Connect makes a WebSocket connection and authenticates if necessary.
+func (c *client) Connect() error {
+	conn, err := connect(c.Host, c.Port)
+	if err != nil {
+		return err
+	}
+	c.conn = conn
+
+	reqGAR := getAuthRequiredRequest{
+		MessageID:   c.getMessageID(),
+		RequestType: "GetAuthRequired",
+	}
+
+	if err = c.conn.WriteJSON(reqGAR); err != nil {
+		return errors.Wrap(err, "write Authenticate")
+	}
+
+	respGAR := &getAuthRequiredResponse{}
+	if err = c.conn.ReadJSON(respGAR); err != nil {
+		return errors.Wrap(err, "read GetAuthRequired")
+	}
+
+	if !respGAR.AuthRequired {
+		logger.Info("no authentication required")
+		return nil
+	}
+
+	auth := getAuth(c.Password, respGAR.Salt, respGAR.Challenge)
+	logger.Debugf("auth: %s", auth)
+
+	reqA := authenticateRequest{
+		MessageID:   c.getMessageID(),
+		RequestType: "Authenticate",
+		Auth:        auth,
+	}
+	if err = c.conn.WriteJSON(reqA); err != nil {
+		return errors.Wrap(err, "write Authenticate")
+	}
+
+	logger.Info("logged in")
+	return nil
+}
+
+// Close closes the WebSocket connection.
+func (c *client) Close() error {
+	return c.conn.Close()
+}
+
+func connect(host string, port int) (*websocket.Conn, error) {
+	url := fmt.Sprintf("ws://%s:%d", host, port)
+	logger.Infof("connecting to %s", url)
+	conn, _, err := websocket.DefaultDialer.Dial(url, nil)
+	if err != nil {
+		return nil, err
+	}
+	return conn, nil
+}
+
+func getAuth(password, salt, challenge string) string {
+	sha := sha256.Sum256([]byte(password + salt))
+	b64 := base64.StdEncoding.EncodeToString([]byte(sha[:]))
+
+	sha = sha256.Sum256([]byte(b64 + challenge))
+	b64 = base64.StdEncoding.EncodeToString([]byte(sha[:]))
+
+	return b64
+}

connection_test.go

@@ -0,0 +1,11 @@
+package obsws
+
+import "testing"
+
+func TestGetAuth(t *testing.T) {
+	expected := "zTM5ki6L2vVvBQiTG9ckH1Lh64AbnCf6XZ226UmnkIA="
+	observed := getAuth("password", "salt", "challenge")
+	if observed != expected {
+		t.Errorf("expected auth == '%s', got '%s'", expected, observed)
+	}
+}

heartbeat.go

@@ -0,0 +1,54 @@
+package obsws
+
+import (
+	"github.com/pkg/errors"
+)
+
+// https://github.com/Palakis/obs-websocket/blob/master/docs/generated/protocol.md#setheartbeat
+// https://github.com/Palakis/obs-websocket/blob/master/docs/generated/protocol.md#heartbeat
+
+type setHeartbeatRequest struct {
+	MessageID   string `json:"message-id"`
+	RequestType string `json:"request-type"`
+	Enable      bool   `json:"enable"`
+}
+
+func (r *setHeartbeatRequest) ID() string {
+	return r.MessageID
+}
+
+type heartbeatResponse struct {
+	MessageID         string `json:"message-id"`
+	Status            string `json:"status"`
+	Error             string `json:"error"`
+	Pulse             bool   `json:"pulse"`
+	CurrentProfile    string `json:"current-profile"`
+	CurrentScene      string `json:"current-scene"`
+	Streaming         bool   `json:"streaming"`
+	TotalStreamTime   int    `json:"total-stream-time"`
+	TotalStreamBytes  int    `json:"total-stream-bytes"`
+	TotalStreamFrames int    `json:"total-stream-frames"`
+	Recording         int    `json:"recording"`
+	TotalRecordTime   int    `json:"total-record-time"`
+	TotalRecordBytes  int    `json:"total-record-bytes"`
+	TotalRecordFrames int    `json:"total-record-frames"`
+}
+
+func (r *heartbeatResponse) ID() string {
+	return r.MessageID
+}
+
+// SetHeartbeat enables or disables sending of the Heartbeat event.
+func (c *client) SetHeartbeat(enable bool) error {
+	reqH := setHeartbeatRequest{
+		MessageID:   c.getMessageID(),
+		RequestType: "SetHeartbeat",
+		Enable:      enable,
+	}
+	if err := c.conn.WriteJSON(reqH); err != nil {
+		return errors.Wrap(err, "write SetHeartbeat")
+	}
+
+	logger.Infof("set heartbeat to %t", enable)
+	return nil
+}

logger.go

@@ -0,0 +1,5 @@
+package obsws
+
+import "github.com/op/go-logging"
+
+var logger = logging.MustGetLogger("obsws")

message_id.go

@@ -0,0 +1,12 @@
+package obsws
+
+import "strconv"
+
+func (c *client) getMessageID() string {
+	c.id++
+	return strconv.Itoa(c.id)
+}
+
+func (c *client) validateMessageID(req, resp reqOrResp) bool {
+	return req.ID() == resp.ID()
+}

request_response.go

@@ -0,0 +1,33 @@
+package obsws
+
+type reqOrResp interface {
+	ID() string
+}
+
+type genericRequest struct {
+	MessageID   string `json:"message-id"`
+	RequestType string `json:"request-type"`
+}
+
+func (r *genericRequest) ID() string {
+	return r.MessageID
+}
+
+type genericResponse struct {
+	MessageID string `json:"message-id"`
+	Status    string `json:"status"`
+	Error     string `json:"error"`
+}
+
+func (r *genericResponse) ID() string {
+	return r.MessageID
+}
+
+// ReceiveGeneric receives a minimal response with only the required fields.
+func (c *client) ReceiveGeneric() (*genericResponse, error) {
+	resp := &genericResponse{}
+	if err := c.conn.ReadJSON(resp); err != nil {
+		return nil, err
+	}
+	return resp, nil
+}