Merge pull request #41 from matrix-org/containerization

Containerize the SFU and publish images to the registry

Author: daniel-abramov

.github/workflows/docker.yaml

@@ -0,0 +1,47 @@
+name: Build and publish Docker image
+
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request: {}
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v2
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=sha,format=short,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

Dockerfile

@@ -0,0 +1,36 @@
+##
+## Build
+##
+FROM golang:1.19 AS build
+
+WORKDIR /app
+
+COPY go.mod ./
+COPY go.sum ./
+
+# Cache dependencies before building and copying the source code, so that
+# we don't need to re-download when building and so that the change in the
+# source code do not invalidate our downloaded layer.
+RUN go mod download
+
+COPY ./src ./src
+
+RUN go build -o /waterfall ./src
+
+
+##
+## Deploy
+##
+FROM ubuntu:22.04
+
+RUN apt update \
+    && apt install -y --no-install-recommends \
+    dumb-init \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /
+
+COPY --from=build /waterfall /usr/bin/waterfall
+
+ENTRYPOINT ["dumb-init", "--"]
+CMD ["waterfall"]

README.md

@@ -44,3 +44,37 @@ from the MSC.
 * `./scripts/build.sh`
 * `./dist/bin`
 * Access at <http://localhost:8080>
+
+## Docker
+
+### Building
+
+In order to build a docker image, run the following in the root directory:
+
+`$ docker build . -t matrix/materwall`
+
+### Running
+
+#### Easy Way
+
+Just use `docker-compose up` and you're good to go.
+
+Or `docker-compose up -d` if you're running it on a server in a detached state.
+
+You can then find your container ID by checking `docker container ls`.
+
+Which could then be used to e.g. check the container logs with `docker container logs <ID>`.
+
+If you're developing locally, you can replace the path to the image with your own image tag, e.g. `matrix/waterfall`.
+
+#### Hard Way
+
+To run the image from the current directory assuming that there is a `config.yaml`:
+
+```
+$ docker run \
+    -v $(pwd)/config.yaml:/config.yaml \
+    --network host \
+    -it --rm matrix/waterfall \
+    sfu --config config.yaml
+```

docker-compose.yaml

@@ -0,0 +1,13 @@
+version: "3.3"
+services:
+  waterfall:
+    container_name: waterfall
+    image: ghcr.io/matrix-org/waterfall:main
+    network_mode: host
+    restart: always
+    environment:
+      CONFIG: |
+        homeserverurl: "http://localhost:8008"
+        userid: "@sfu:shadowfax"
+        accesstoken: "..."
+        timeout: 30

src/call.go

@@ -513,7 +513,7 @@ func (c *Call) SendDataChannelMessage(msg event.SFUMessage) {
 }
 
 func (c *Call) CheckKeepAliveTimestamp() {
-	timeout := time.Second * time.Duration(config.Timeout)
+	timeout := time.Second * time.Duration(config.KeepAliveTimeout)
 	for range time.Tick(timeout) {
 		if c.lastKeepAliveTimestamp.Add(timeout).Before(time.Now()) {
 			if c.PeerConnection.ConnectionState() != webrtc.PeerConnectionStateClosed {

src/config.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+
+	"github.com/sirupsen/logrus"
+	"gopkg.in/yaml.v3"
+	"maunium.net/go/mautrix/id"
+)
+
+// The mandatory SFU configuration.
+type Config struct {
+	// The Matrix ID (MXID) of the SFU.
+	UserID id.UserID
+	// The ULR of the homeserver that SFU talks to.
+	HomeserverURL string
+	// The access token for the Matrix SDK.
+	AccessToken string
+	// Keep-alive timeout for WebRTC connections. If no keep-alive has been received
+	// from the client for this duration, the connection is considered dead.
+	KeepAliveTimeout int
+}
+
+// Tries to load a config from the `CONFIG` environment variable.
+// If the environment variable is not set, tries to load a config from the
+// provided path to the config file (YAML). Returns an error if the config could
+// not be loaded.
+func loadConfig(path string) (*Config, error) {
+	config, err := loadConfigFromEnv()
+	if err != nil {
+		if !errors.Is(err, ErrNoConfigEnvVar) {
+			return nil, err
+		}
+
+		return loadConfigFromPath(path)
+	}
+
+	return config, nil
+}
+
+// ErrNoConfigEnvVar is returned when the CONFIG environment variable is not set.
+var ErrNoConfigEnvVar = errors.New("environment variable not set or invalid")
+
+// Tries to load the config from environment variable (`CONFIG`).
+// Returns an error if not all environment variables are set.
+func loadConfigFromEnv() (*Config, error) {
+	configEnv := os.Getenv("CONFIG")
+	if configEnv == "" {
+		return nil, ErrNoConfigEnvVar
+	}
+
+	return loadConfigFromString(configEnv)
+}
+
+// Tries to load a config from the provided path.
+func loadConfigFromPath(path string) (*Config, error) {
+	logrus.WithField("path", path).Info("loading config")
+
+	file, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read file: %w", err)
+	}
+
+	return loadConfigFromString(string(file))
+}
+
+// Load config from the provided string.
+// Returns an error if the string is not a valid YAML.
+func loadConfigFromString(configString string) (*Config, error) {
+	logrus.Info("loading config from string")
+
+	var config Config
+	if err := yaml.Unmarshal([]byte(configString), &config); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal YAML file: %w", err)
+	}
+
+	return &config, nil
+}

src/main.go

@@ -18,26 +18,15 @@ package main
 
 import (
 	"flag"
-	"fmt"
-	"io/ioutil"
 	"os"
 	"os/signal"
 	"runtime"
 	"runtime/pprof"
 	"syscall"
 
 	"github.com/sirupsen/logrus"
-	yaml "gopkg.in/yaml.v3"
-	"maunium.net/go/mautrix/id"
 )
 
-type Config struct {
-	UserID        id.UserID
-	HomeserverURL string
-	AccessToken   string
-	Timeout       int
-}
-
 var config *Config
 
 var logTime = flag.Bool("logTime", false, "whether or not to print time and date in logs")
@@ -95,22 +84,6 @@ func initLogging(logTime *bool) {
 	logrus.SetFormatter(formatter)
 }
 
-func loadConfig(configFilePath string) (*Config, error) {
-	logrus.WithField("path", configFilePath).Info("loading config")
-
-	file, err := ioutil.ReadFile(configFilePath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read file: %w", err)
-	}
-	var config Config
-
-	if err := yaml.Unmarshal(file, &config); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal YAML file: %w", err)
-	}
-
-	return &config, nil
-}
-
 func killListener(c chan os.Signal, beforeExit []func()) {
 	<-c
 
@@ -143,8 +116,10 @@ func main() {
 	go killListener(c, beforeExit)
 
 	var err error
-	if config, err = loadConfig(*configFilePath); err != nil {
-		logrus.WithError(err).Fatal("failed to load config file")
+	config, err = loadConfig(*configFilePath)
+
+	if err != nil {
+		logrus.WithError(err).Fatal("could not load config")
 	}
 
 	InitMatrix()