merge main

Author: kamciokodzi

.env.example

@@ -1,12 +1,12 @@
-#JELLYFISH
+#FISHJAM
 # TURN default configuration
 # note: loopback address as EXTERNAL_IP cannot be used inside a Docker container
 # EXTERNAL_IP=<your_public_ip_address>
 JF_SERVER_API_TOKEN="development"
 
 # SSL
 DOMAIN=localhost
-# BE_JF_ADDRESSES=<jellyfish_domain_address1> <jellyfish_domain_address2>
+# BE_JF_ADDRESS=<fishjam_domain_address>
 # BE_HOST=<backend_domain_address>
 # BE_JF_SECURE_CONNECTION=false
 # JF_CHECK_ORIGIN=false

.github/workflows/debug_build_and_deploy.yml

@@ -0,0 +1,26 @@
+name: Staging Build and Deploy
+on:
+  push:
+    branches:
+      - "debug-staging"
+    paths:
+      - "**"
+
+env:
+  DOMAIN: room.fishjam.work
+  BE_HOST: server.room.fishjam.work
+  PROJECT: staging
+  COMPOSE_FILE_NAME: docker-compose-deploy.yaml
+
+jobs:
+  deploy1:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Debug staging
+        uses: JimCronqvist/action-ssh@master
+        with:
+          hosts: ${{ secrets.STAGING_HOST }}
+          privateKey: ${{ secrets.SSH_PRIV_KEY }}
+          command: |
+            cat test.txt
+

.github/workflows/production_build_and_deploy.yml

@@ -5,8 +5,8 @@ on:
       - 'v*.*.*'
 
 env:
-  DOMAIN: jellyroom.membrane.stream
-  BE_HOST: server.jellyroom.membrane.stream
+  DOMAIN: room.fishjam.stream
+  BE_HOST: server.room.fishjam.stream
   PROJECT: production
   COMPOSE_FILE_NAME: docker-compose-deploy.yaml
 
@@ -20,20 +20,20 @@ jobs:
         id: versions
         run: |
           cat << EOF >> $GITHUB_OUTPUT
-          jellyroom=${GITHUB_REF#refs/*/}
-          jellyfish=$(cat .jellyfish-version)
+          fishjam_room=${GITHUB_REF#refs/*/}
+          fishjam=$(cat .fishjam-version)
           EOF
 
       - name: Prepare .env file for the deployment
         id: variables_population
         run: |
           echo "DOMAIN=${{env.DOMAIN}} 
-          JELLYROOM_VERSION=${{ steps.versions.outputs.jellyroom }}
-          JELLYFISH_VERSION=${{ steps.versions.outputs.jellyfish }}
+          FISHJAM_ROOM_VERSION=${{ steps.versions.outputs.fishjam_room }}
+          FISHJAM_VERSION=${{ steps.versions.outputs.fishjam }}
           JF_SERVER_API_TOKEN=${{secrets.SERVER_API_TOKEN_CLOUD_PRODUCTION}}
           BE_HOST=${{env.BE_HOST}}
           BE_JF_SECURE_CONNECTION=true
-          BE_JF_ADDRESSES=${{vars.JF1_HOST_CLOUD_PRODUCTION}}" > .env
+          BE_JF_ADDRESS=${{vars.JF_HOST_CLOUD_PRODUCTION}}" > .env
 
       - name: Remove old containers on first host
         uses: JimCronqvist/action-ssh@master

.github/workflows/sandbox_build_and_deploy.yml

@@ -7,8 +7,8 @@ on:
       - "**"
 
 env:
-  DOMAIN: jellyroom.membrane.ovh
-  BE_HOST: server.jellyroom.membrane.ovh
+  DOMAIN: room.fishjam.ovh
+  BE_HOST: server.room.fishjam.ovh
   PROJECT: sandbox
   COMPOSE_FILE_NAME: docker-compose-deploy.yaml
 
@@ -22,33 +22,33 @@ jobs:
         id: versions
         run: |
           cat << EOF >> $GITHUB_OUTPUT
-          jellyroom=${GITHUB_SHA:0:7}
-          jellyfish=$(cat .jellyfish-version)
+          fishjam_room=${GITHUB_SHA:0:7}
+          fishjam=$(cat .fishjam-version)
           EOF
 
       - name: Prepare .env file for the deployment
         id: variables_population
         run: |
           echo "DOMAIN=${{env.DOMAIN}} 
-          JELLYROOM_VERSION=${{ steps.versions.outputs.jellyroom }}
-          JELLYFISH_VERSION=${{ steps.versions.outputs.jellyfish }}
+          FISHJAM_ROOM_VERSION=${{ steps.versions.outputs.fishjam_room }}
+          FISHJAM_VERSION=${{ steps.versions.outputs.fishjam }}
           JF_SERVER_API_TOKEN=${{secrets.SERVER_API_TOKEN_CLOUD_SANDBOX}}
           BE_HOST=${{env.BE_HOST}}
           BE_JF_SECURE_CONNECTION=true
-          BE_JF_ADDRESSES=${{vars.JF_HOST_CLOUD_SANDBOX}}" > .env
+          BE_JF_ADDRESS=${{vars.JF_HOST_CLOUD_SANDBOX}}" > .env
 
       - name: Remove old containers on first host
         uses: JimCronqvist/action-ssh@master
         with:
-          hosts: ${{ secrets.SANDBOX_IP }}
+          hosts: ${{ secrets.SANDBOX_HOST }}
           privateKey: ${{ secrets.SSH_PRIV_KEY }}
           command: |
             docker ps -aq | xargs -r docker stop | xargs -r docker rm 
 
       - name: Deploy docker compose to a pre-configured server on first host
         uses: TapTap21/docker-remote-deployment-action@v1.1
         with:
-          remote_docker_host: ${{ secrets.SANDBOX_IP }}
+          remote_docker_host: ${{ secrets.SANDBOX_HOST }}
           ssh_private_key: ${{ secrets.SSH_PRIV_KEY }}
           ssh_public_key: ${{ secrets.SSH_PUB_KEY }}
           stack_file_name: ${{ env.COMPOSE_FILE_NAME }}

.github/workflows/staging_build_and_deploy.yml

@@ -1,53 +1,53 @@
 name: Staging Build and Deploy
 on:
   push:
-    branches: 
+    branches:
       - "main"
 
-env: 
-  DOMAIN: jellyroom.membrane.work
-  BE_HOST: server.jellyroom.membrane.work
+env:
+  DOMAIN: room.fishjam.work
+  BE_HOST: server.room.fishjam.work
   PROJECT: staging
   COMPOSE_FILE_NAME: docker-compose-deploy.yaml
 
 jobs:
   deploy1:
     runs-on: ubuntu-latest
-    steps:  
+    steps:
       - uses: actions/checkout@v2
 
       - name: Set versions
         id: versions
         run: |
           cat << EOF >> $GITHUB_OUTPUT
-          jellyroom=${GITHUB_SHA:0:7}
-          jellyfish=$(cat .jellyfish-version)
+          fishjam_room=${GITHUB_SHA:0:7}
+          fishjam=$(cat .fishjam-version)
           EOF
 
       - name: Prepare .env file for the deployment
         id: variables_population
         run: |
-          echo "DOMAIN=${{env.DOMAIN}} 
-          JELLYROOM_VERSION=${{ steps.versions.outputs.jellyroom }}
-          JELLYFISH_VERSION=${{ steps.versions.outputs.jellyfish }}
+          echo "DOMAIN=${{env.DOMAIN}}
+          FISHJAM_ROOM_VERSION=${{ steps.versions.outputs.fishjam_room }}
+          FISHJAM_VERSION=${{ steps.versions.outputs.fishjam }}
           JF_SERVER_API_TOKEN=${{secrets.SERVER_API_TOKEN_CLOUD_STAGING}}
           BE_HOST=${{env.BE_HOST}}
           BE_JF_SECURE_CONNECTION=true
-          BE_JF_ADDRESSES=${{vars.JF1_HOST_CLOUD_STAGING}}" > .env
+          BE_JF_ADDRESS=${{vars.JF_HOST_CLOUD_STAGING}}" > .env
 
       - name: Remove old containers on first host
         uses: JimCronqvist/action-ssh@master
         with:
-          hosts: ${{ secrets.STAGING_IP }}
+          hosts: ${{ secrets.STAGING_HOST }}
           privateKey: ${{ secrets.SSH_PRIV_KEY }}
           command: |
-            docker ps -aq | xargs -r docker stop | xargs -r docker rm 
+            docker ps -aq | xargs -r docker stop | xargs -r docker rm
 
       - name: Deploy docker compose to a pre-configured server on first host
         uses: TapTap21/docker-remote-deployment-action@v1.1
         with:
-          remote_docker_host: ${{ secrets.STAGING_IP }}
+          remote_docker_host: ${{ secrets.STAGING_HOST }}
           ssh_private_key: ${{ secrets.SSH_PRIV_KEY }}
           ssh_public_key: ${{ secrets.SSH_PUB_KEY }}
           stack_file_name: ${{ env.COMPOSE_FILE_NAME }}
-          args: -p ${{ env.PROJECT }} --env-file .env up -d --remove-orphans --build frontend backend
+          args: -p ${{ env.PROJECT }} --env-file .env up -d --remove-orphans --build frontend backend

.gitignore

@@ -35,3 +35,5 @@ videoroom-*.tar
 .env
 
 certbot/
+
+.vscode

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "protos"]
 	path = protos
-	url = https://github.com/jellyfish-dev/protos.git
+	url = https://github.com/fishjam-dev/protos.git

README.md

@@ -1,8 +1,8 @@
 # Videoroom
 
 Videoroom is an open-source, basic video conferencing platform using WebRTC.
-It is based on [jellyfish](https://github.com/jellyfish-dev/jellyfish), a general-purpose media server.
-Videoroom may be a good starting point for building your own real-time communication solution using Elixir and Jellyfish.
+It is based on [fishjam](https://github.com/fishjam-dev/fishjam), a general-purpose media server.
+Videoroom may be a good starting point for building your own real-time communication solution using Elixir and Fishjam.
 
 ## Running with Docker
 The simplest way to run videoroom is with use of Docker.
@@ -15,9 +15,9 @@ docker compose --env-file .env.example up
 
 Make sure to have installed [Elixir](https://elixir-lang.org/install.html) and [npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) first.
 
-Running the Videoroom requires connecting to an instance of [Jellyfish Server](https://github.com/jellyfish-dev/jellyfish).
+Running the Videoroom requires connecting to an instance of [Fishjam Server](https://github.com/fishjam-dev/fishjam).
 
-When running locally, you can start an instance of Jellyfish inside docker using docker compose.
+When running locally, you can start an instance of Fishjam inside docker using docker compose.
 
 ```sh
 EXTERNAL_IP=<your ip in local network> docker compose -f docker-compose-dev.yaml up
@@ -27,26 +27,26 @@ Now you can start the Videoroom backend:
 - Run `mix setup` to install and setup dependencies
 - Start Phoenix server with `mix phx.server`
 
-When running the build version of the Phoenix app, you must specify the addresses of the Jellyfish and backend service.
+When running the build version of the Phoenix app, you must specify the addresses of the Fishjam and backend service.
 As well as the authentication token via the environment variables:
 
 ```sh
-BE_JF_ADDRESSES=<IP_ADDRESS1>:<PORT1> OR <DOMAIN1> <IP_ADDRESS2>:<PORT2> OR <DOMAIN2> #Example of using two jellyfishes: `127.0.0.1:5002 jellyroom.membrane.ovh`, if not provided in dev environment `localhost:5002 localhost:5003` is used.
-BE_JF_SERVER_API_TOKEN=<TOKEN> #This must be the same token that was setup in jellyfish. In `docker-compose-dev.yaml` we setup `development` and this variable is used by default in `dev` environment
+BE_JF_ADDRESS=<IP_ADDRESS>:<PORT1> OR <DOMAIN1> #Example `127.0.0.1:5002 OR room.fishjam.ovh`, if not provided in dev environment `localhost:5002` is used.
+BE_JF_SERVER_API_TOKEN=<TOKEN> #This must be the same token that was setup in fishjam. In `docker-compose-dev.yaml` we setup `development` and this variable is used by default in `dev` environment
 ```
 
-Optionally, in production, these variables can be set: 
+Optionally, in production, these variables can be set:
 * `BE_PEER_JOIN_TIMEOUT` - can be used to limit the period in which a new peer must join the meeting,
-* `BE_JF_SECURE_CONNECTION` - enforces connecting the backend to jellyfish through `wss` protocol,
+* `BE_JF_SECURE_CONNECTION` - enforces connecting the backend to fishjam through `wss` protocol,
 * `BE_HOST` - address of backend
-* `JF_CHECK_ORIGIN` - define whether jellyfish should check origin of incoming requests
+* `JF_CHECK_ORIGIN` - define whether fishjam should check origin of incoming requests
 
 
 Next you have to start a Videoroom frontend:
 - Run `npm ci --prefix=assets` to install and setup dependencies
 - Start vite server with `npm run dev --prefix=assets`
 
-Now you have all needed components to use jellyfish videoroom.
+Now you have all needed components to use fishjam videoroom.
 
 ## Production
 
@@ -56,22 +56,18 @@ You can copy the `.env.example` file to `.env` and adjust it to your needs.
 
 ## Deployment with load-balancing
 
-`docker-compose.yaml` allows to run a jellyfish videoroom with multiple jellyfishes but all of that runs on the same machine.
-For properly using load-balancing two machines will be needed and `docker-compose-deploy.yaml` will be used. 
+`docker-compose.yaml` allows to run a fishjam videoroom with multiple fishjams but all of that runs on the same machine.
+For properly using load-balancing two machines will be needed and `docker-compose-deploy.yaml` will be used.
 You can see our deployment workflow  [here](.github/workflows/test_build_and_deploy.yml).
-This deployment is pretty simple. 
-All containers besides `jellyfish2` are started on node1 and `jellyfish2` is started on node2.
+This deployment is pretty simple.
+All containers besides `fishjam2` are started on node1 and `fishjam2` is started on node2.
 All environment variables used in our deployment are presented below:
 
 ```sh
 DOMAIN=<FRONTEND_DOMAIN>
-JF1_IP=<NODE1_IP> # IP address of first node on which jellyfish will be run
-JF2_IP=<NODE2_IP> # IP address of second node on which jellyfish will be run
-JF_SERVER_API_TOKEN=<API_TOKEN> #The same API token is used for all jellyfishes
-JF1_HOST=<DOMAIN_JELLYFISH1> OR <JF1_IP>:<JELLYFISH1_PORT> # Value passed to jellyfish and returns by it when creating a room on this speicific jellyfish
-JF2_HOST=<DOMAIN_JELLYFISH2> OR <JF2_IP>:<JELLYFISH2_PORT>
-BE_JF_ADDRESSES=<JF1_HOST> <JF2_HOST> #Used by backend to create a notifier to one of jellyfishes
-PROMETHEUS_TARGETS=<JF1_IP>:9568,<JF2_IP>:9568 #Addresses on which prometheus will query for data
+JF_SERVER_API_TOKEN=<API_TOKEN> #The same API token is used for all fishjams
+BE_JF_ADDRESS=<DOMAIN_FISHJAM1> OR <FISHJAM_IP>:<FISHJAM_PORT>  #Used by backend to create a notifier and to communicate with fishjam
+PROMETHEUS_TARGETS=<FISHJAM_IP>:9568 #Addresses on which prometheus will query for data
 BE_HOST=<BACKEND_DOMAIN>
 GF_SECURITY_ADMIN_PASSWORD=<GRAFANA_PASSWORD>
 GF_SECURITY_ADMIN_USER=<GRAFANA_LOGIN>
@@ -83,9 +79,9 @@ JF_CHECK_ORIGIN=false
 
 We use [Divo](https://hexdocs.pm/divo/readme.html) in tests, which is responsible for starting docker containers.
 
-When running locally run tests using `mix test`, which starts Jellyfish in a container.
+When running locally run tests using `mix test`, which starts Fishjam in a container.
 
-On CI both Jellyfish and the tests are run inside docker. If needed, e.g. when the tests are failing on the CI, but not locally you can simulate those conditions with `mix integration_test`.
+On CI both Fishjam and the tests are run inside docker. If needed, e.g. when the tests are failing on the CI, but not locally you can simulate those conditions with `mix integration_test`.
 
 ## Copyright and License
 

assets/.tool-versions

@@ -1 +1 @@
-nodejs 18.14.2
+nodejs v20.13.1

assets/Dockerfile

@@ -4,11 +4,11 @@ FROM alpine:3.18 as builder
 WORKDIR '/app'
 
 ARG FE_BE_HOST
-ARG JELLYROOM_VERSION
-ARG JELLYFISH_VERSION
+ARG FISHJAM_ROOM_VERSION
+ARG FISHJAM_VERSION
 ENV VITE_BE_HOST=$FE_BE_HOST
-ENV VITE_JELLYROOM_VERSION=$JELLYROOM_VERSION
-ENV VITE_JELLYFISH_VERSION=$JELLYFISH_VERSION
+ENV VITE_FISHJAM_ROOM_VERSION=$FISHJAM_ROOM_VERSION
+ENV VITE_FISHJAM_VERSION=$FISHJAM_VERSION
 
 # Install nodejs and npm
 RUN apk add --no-cache nodejs npm
@@ -19,7 +19,7 @@ RUN adduser --disabled-password --gecos "" node
 # Own the app directory
 RUN chown node:node ./
 
-# It's adviced to run the container as non-root user 
+# It's adviced to run the container as non-root user
 # for added security if the base image has the user
 USER node
 
@@ -29,7 +29,7 @@ COPY package*.json ./
 # Install dependencies
 RUN npm ci
 
-# Copy application files 
+# Copy application files
 COPY . .
 
 # Build the app