The Go SDK is currently in experimental status. If you would like to provide feedback, please reach out to us with your suggestions and comments on our Discord.

Go - Websocket.On()

Register a handler for connections, disconnections, or messages for the websocket.

import (
  "fmt"

  "github.com/nitrictech/go-sdk/nitric/websockets"
  "github.com/nitrictech/go-sdk/nitric"
)

func main() {
  ws, err := nitric.NewWebsocket("public")
  if err != nil {
    return
  }

  ws.On(websockets.EventType_Connect, func(ctx *websockets.Ctx) {
    // handle connections
  })

  ws.On(websockets.EventType_Disconnect, func(ctx *websockets.Ctx) {
    // handle disconnections
  })

  ws.On(websockets.EventType_Message, func(ctx *websockets.Ctx) {
    // handle messages
  })

  if err := nitric.Run(); err != nil {
    fmt.Println(err)
  }
}

Parameters

  • Name
    eventType
    Required
    Required
    Type
    WebsocketEventType
    Description

    The type of websocket event to listen for. Can be EventType_Connect, EventType_Disconnect, or EventType_Message.

  • Name
    middleware
    Required
    Required
    Type
    ...interface{}
    Description

    The middleware function to use as the handler for Websocket events. If you want to compose more than one middleware use nitric.Compose.

Examples

Register a handler for message events

ws.On(websockets.EventType_Message, func(ctx *websockets.Ctx) {
  fmt.Printf("New Message from %s: %s\n", ctx.Request.ConnectionID(), ctx.Request.Message())
})

Manage Websocket connections

To store Websocket connections you can use a Nitric collection.

import (
	"context"
	"fmt"

	"github.com/nitrictech/go-sdk/nitric/websockets"
	"github.com/nitrictech/go-sdk/nitric"
)

func main() {
	ws, err := nitric.NewWebsocket("public")
	if err != nil {
		return
	}

	connections, err := nitric.NewKv("connections").Allow(nitric.KvStoreGet, nitric.KvStoreSet, nitric.KvStoreDelete)
	if err != nil {
		return
	}

	// Register a new connection on connect
	ws.On(websockets.EventType_Connect, func(ctx *websockets.Ctx) error {
		return := connections.Set(context.TODO(), ctx.Request.ConnectionID(), map[string]interface{}{
			"connectionId": ctx.Request.ConnectionID(),
		})
	})

	// Remove a registered connection on disconnect
	ws.On(websockets.EventType_Disconnect, func(ctx *websockets.Ctx) error {
		return connections.Delete(context.TODO(), ctx.Request.ConnectionID())
	})

	// Broadcast message to all the registered websocket connections
	ws.On(websockets.EventType_Message, func(ctx *websockets.Ctx) error {
		connectionStream, err := connections.Keys(context.TODO())
		if err != nil {
			return ctx, err
		}

		for {
			connectionId, err := connectionStream.Recv()
			if err != nil {
				break // reached the end of the documents
			}

			err = ws.Send(context.TODO(), connectionId, []byte(ctx.Request.Message()))
			if err != nil {
				return err
			}
		}

		return nil
	})

	if err := nitric.Run(); err != nil {
		fmt.Println(err)
	}
}

Chain functions as a single method handler

import (
	"fmt"

	"github.com/nitrictech/go-sdk/nitric/websockets"
	"github.com/nitrictech/go-sdk/nitric"
)

func validateMessage(ctx *websockets.Ctx, next nitric.Handler[websockets.Ctx]) (*websockets.Ctx, error) {
	// validate that the message does not contain explicit content
	return next(ctx)
}

func handleMessage(ctx *websockets.Ctx, next nitric.Handler[websockets.Ctx]) (*websockets.Ctx, error) {
	fmt.Printf("New Message from %s: %s\n", ctx.Request.ConnectionID(), ctx.Request.Message())

	return next(ctx)
}

func main() {
	ws, err := nitric.NewWebsocket("public")
	if err != nil {
		return
	}

	ws.On(websockets.EventType_Message, validateMessage, handleMessage)

	if err := nitric.Run(); err != nil {
		fmt.Println(err)
	}
}