From c419d72da6897aad207b56fbf2d913d1fb75b9f2 Mon Sep 17 00:00:00 2001 From: Balazs Kreith Date: Mon, 27 Jun 2022 11:03:56 +0300 Subject: [PATCH 1/6] change docker base imaged --- README.md | 14 +++++++++++++- mediasoup-sfu/Dockerfile | 3 ++- mediasoup-sfu/package.json | 10 +++++----- my-webrtc-app/Dockerfile | 3 ++- 4 files changed, 22 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 1b85991..4cc7d14 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ In terminal, run: ``` **MY_LOCAL_IP_ADDRESS** is the IP address of your local network interface connect to the internet. -You can obtain it by typing `ifconfig` in macOs or Linux, or `ipconfig` in Windows. +You can obtain it by typing `ifconfig` in MacOs or Linux, or `ipconfig` in Windows. When containers are running, in your browser go to http://localhost:9000 (open it in two, or three tabs). @@ -21,6 +21,18 @@ To see the collected [reports](https://observertc.org/docs/overview/schemas/#rep To see some SFU metrics calculated by the sfu-montior go to http://localhost:5959/metrics +## Using Multiple SFUs + +Examples of monitoring cascaded SFU environment requires to run multiple, at least two SFUs. + +```bash + SFU_ANNOUNCED_IP={MY_LOCAL_IP_ADDRESS} docker-compose -f docker-compose-cascaded-sfus.yaml up +``` + +In your browser tabs you go to http://localhost:9000/?sfuPort=5959, and http://localhost:9000/?sfuPort=7171. + + + ## Dev mode if you want to modify the [mediasoup-sfu](mediasoup-sfu/) or the [webrtc-app](my-webrtc-app/) locally, diff --git a/mediasoup-sfu/Dockerfile b/mediasoup-sfu/Dockerfile index ac84ced..d84ae11 100644 --- a/mediasoup-sfu/Dockerfile +++ b/mediasoup-sfu/Dockerfile @@ -1,4 +1,5 @@ -FROM ubuntu:20.04 +# FROM ubuntu:20.04 +FROM ubuntu:jammy-20220531 # FROM sitespeedio/node:ubuntu-20.04-nodejs-16.13.2 USER root diff --git a/mediasoup-sfu/package.json b/mediasoup-sfu/package.json index 52e051c..0469b22 100644 --- a/mediasoup-sfu/package.json +++ b/mediasoup-sfu/package.json @@ -1,7 +1,7 @@ { "name": "sfu", "version": "1.0.0", - "description": "Simple Mediasoup SFU for transcribing", + "description": "Simple Mediasoup SFU", "main": "main.js", "scripts": { "dev": "ts-node-dev --respawn --pretty --transpile-only src/main.ts", @@ -26,15 +26,15 @@ "@observertc/sfu-monitor-js": "^1.0.0-beta.34", "@types/ws": "^8.2.2", "events": "^3.3.0", - "log4js": "^6.4.6", - "mediasoup": "^3.9.12", + "log4js": "^6.5.2", + "mediasoup": "^3.10.0", "uuid": "^8.3.2", - "ws": "^8.6.0", + "ws": "^8.8.0", "yargs-parser": "^21.0.0" }, "devDependencies": { "@types/uuid": "^8.3.3", "ts-node-dev": "^1.1.8", - "typescript": "^4.6.4" + "typescript": "^4.7.4" } } diff --git a/my-webrtc-app/Dockerfile b/my-webrtc-app/Dockerfile index 273270a..8769da8 100644 --- a/my-webrtc-app/Dockerfile +++ b/my-webrtc-app/Dockerfile @@ -1,4 +1,5 @@ -FROM node:alpine +# FROM node:alpine +FROM ubuntu:jammy-20220531 USER root ENV TZ=Europe/Helsinki From 67e410be0326cababc8b3fd696ae2a76778d1e9e Mon Sep 17 00:00:00 2001 From: Balazs Kreith Date: Tue, 28 Jun 2022 15:52:07 +0300 Subject: [PATCH 2/6] change base image --- docker-compose-alpine.yaml | 67 +++++++++++++++++++++++++++++++++ mediasoup-sfu/Dockerfile | 50 ++++-------------------- mediasoup-sfu/Dockerfile.alpine | 22 +++++++++++ mediasoup-sfu/src/main.ts | 2 +- my-webrtc-app/Dockerfile | 4 +- my-webrtc-app/Dockerfile.alpine | 19 ++++++++++ 6 files changed, 118 insertions(+), 46 deletions(-) create mode 100644 docker-compose-alpine.yaml create mode 100644 mediasoup-sfu/Dockerfile.alpine create mode 100644 my-webrtc-app/Dockerfile.alpine diff --git a/docker-compose-alpine.yaml b/docker-compose-alpine.yaml new file mode 100644 index 0000000..86f259d --- /dev/null +++ b/docker-compose-alpine.yaml @@ -0,0 +1,67 @@ +services: + observer: + restart: always + image: observertc/observer:1.0.0-beta + ports: + - 7080:7080 + environment: + - MICRONAUT_CONFIG_FILES=/my-config.yaml + volumes: + - ./observer-config/config.yaml:/my-config.yaml + + mongodb: + image: mongo:4.2 + hostname: mongodb + environment: + MONGO_INITDB_ROOT_USERNAME: root + MONGO_INITDB_ROOT_PASSWORD: password + ports: + - 27017:27017 + restart: always + + mongo-express: + image: mongo-express + ports: + - 8081:8081 + environment: + ME_CONFIG_MONGODB_SERVER: mongodb + ME_CONFIG_MONGODB_ADMINUSERNAME: root + ME_CONFIG_MONGODB_ADMINPASSWORD: password + ME_CONFIG_BASICAUTH_USERNAME: admin + ME_CONFIG_BASICAUTH_PASSWORD: password + restart: always + depends_on: + - mongodb + + mediasoup_sfu: + build: + context: ./mediasoup-sfu + dockerfile: Dockerfile.alpine + network_mode: bridge + cap_add: + - NET_ADMIN + ports: + - 15000-15100:15000-15100/udp + - 5959:5959 + environment: + - HOSTNAME=localhost + - RTCMIN_PORT=15000 + - RTCMAX_PORT=15100 + - WEBPAGE_PORT=5959 + - SERVER_IP=0.0.0.0 + - OUTBOUND_LATENCY_IN_MS=400 + - ANNOUNCED_IP=${SFU_ANNOUNCED_IP} + - OBSERVER_INTERNAL_ADDRESS=host.docker.internal:7080 + depends_on: + - observer + webrtc-app: + build: + context: ./my-webrtc-app + dockerfile: Dockerfile.alpine + environment: + - SAMPLING_PERIOD_IN_MS=10000 + ports: + - 9000:9000 + depends_on: + - observer +version: '3.3' \ No newline at end of file diff --git a/mediasoup-sfu/Dockerfile b/mediasoup-sfu/Dockerfile index d84ae11..5d28c17 100644 --- a/mediasoup-sfu/Dockerfile +++ b/mediasoup-sfu/Dockerfile @@ -1,59 +1,23 @@ -# FROM ubuntu:20.04 -FROM ubuntu:jammy-20220531 -# FROM sitespeedio/node:ubuntu-20.04-nodejs-16.13.2 +FROM node:latest USER root ENV TZ=Europe/Helsinki -RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone -RUN apt-get update && apt-get -y --no-install-recommends install \ - sudo \ - vim \ - wget \ - build-essential \ - pkg-config \ - gdb - -RUN echo "deb http://archive.ubuntu.com/ubuntu/ focal main restricted universe multiverse" >> /etc/apt/sources.list && \ - echo "deb-src http://archive.ubuntu.com/ubuntu/ focal main restricted universe multiverse" >> /etc/apt/sources.list && \ - echo "deb http://archive.ubuntu.com/ubuntu/ focal-updates main restricted universe multiverse" >> /etc/apt/sources.list && \ - echo "deb-src http://archive.ubuntu.com/ubuntu/ focal-updates main restricted universe multiverse" >> /etc/apt/sources.list && \ - echo "deb http://archive.ubuntu.com/ubuntu/ focal-security main restricted universe multiverse" >> /etc/apt/sources.list && \ - echo "deb-src http://archive.ubuntu.com/ubuntu/ focal-security main restricted universe multiverse" >> /etc/apt/sources.list && \ - echo "deb http://archive.ubuntu.com/ubuntu/ focal-backports main restricted universe multiverse" >> /etc/apt/sources.list && \ - echo "deb-src http://archive.ubuntu.com/ubuntu/ focal-backports main restricted universe multiverse" >> /etc/apt/sources.list && \ - echo "deb http://archive.canonical.com/ubuntu focal partner" >> /etc/apt/sources.list && \ - echo "deb-src http://archive.canonical.com/ubuntu focal partner" >> /etc/apt/sources.list - - -RUN apt-get install -y curl && \ - curl -fsSL https://deb.nodesource.com/setup_16.x | sudo -E bash - && \ - sudo dpkg --configure -a && \ - printf 'y\n1\n\1n' | apt upgrade - - -RUN apt-get install -y aptitude && \ - aptitude install -y nodejs && \ - aptitude install -y npm && \ - apt install -y python3-pip - WORKDIR /app -COPY [ \ - "package.json", \ - "tsconfig.json", \ - "src/*", \ - "*.js", \ - "./" \ - ] +COPY package.json ./ + +COPY ./ ./ +# RUN apk add --no-cache git make bash python3 py3-pip net-tools gcc alpine-sdk iproute2 linux-headers +RUN apt-get update && apt-get install -y build-essential python3 python3-pip iproute2 net-tools make RUN npm install RUN npm install typescript -g RUN tsc # for throttling traffic -RUN apt-get install -y net-tools iproute2 +# RUN apt-get install -y net-tools iproute2 # ENV DEBUG="mediasoup*" CMD [ "node", "dist/main.js" ] diff --git a/mediasoup-sfu/Dockerfile.alpine b/mediasoup-sfu/Dockerfile.alpine new file mode 100644 index 0000000..efc843b --- /dev/null +++ b/mediasoup-sfu/Dockerfile.alpine @@ -0,0 +1,22 @@ +FROM node:alpine + +USER root + +ENV TZ=Europe/Helsinki + +WORKDIR /app + +COPY package.json ./ + +COPY ./ ./ + +RUN apk add --no-cache git make bash python3 py3-pip net-tools gcc alpine-sdk iproute2 linux-headers +RUN npm install +RUN npm install typescript -g +RUN tsc + +# for throttling traffic +# RUN apt-get install -y net-tools iproute2 + +# ENV DEBUG="mediasoup*" +CMD [ "node", "dist/main.js" ] diff --git a/mediasoup-sfu/src/main.ts b/mediasoup-sfu/src/main.ts index 4fc6153..5a60376 100644 --- a/mediasoup-sfu/src/main.ts +++ b/mediasoup-sfu/src/main.ts @@ -77,7 +77,7 @@ async function main(): Promise { if (outboundLatencyInMs) { await new Promise((resolve, reject) => { const command = `tc qdisc add dev eth0 root handle 1 netem delay ${outboundLatencyInMs}ms`; - logger.debug(`Executing ${command}`); + logger.info(`Executing ${command}`); exec(command, (error: any, stdout: any, stderr: any) => { if (error) reject(error); else if (stderr) reject(stderr) diff --git a/my-webrtc-app/Dockerfile b/my-webrtc-app/Dockerfile index 8769da8..4d23d01 100644 --- a/my-webrtc-app/Dockerfile +++ b/my-webrtc-app/Dockerfile @@ -1,5 +1,5 @@ -# FROM node:alpine -FROM ubuntu:jammy-20220531 +FROM node:latest +# FROM ubuntu:jammy-20220531 USER root ENV TZ=Europe/Helsinki diff --git a/my-webrtc-app/Dockerfile.alpine b/my-webrtc-app/Dockerfile.alpine new file mode 100644 index 0000000..fae3a58 --- /dev/null +++ b/my-webrtc-app/Dockerfile.alpine @@ -0,0 +1,19 @@ +FROM node:alpine +# FROM ubuntu:jammy-20220531 +USER root + +ENV TZ=Europe/Helsinki + +WORKDIR /app + +COPY package.json ./ + +COPY ./ ./ + +RUN npm install + +RUN npm install typescript -g +RUN npm install webpack webpack-cli --save-dev +RUN npm run prod-compile + +CMD ["npm", "run", "start"] \ No newline at end of file From 5a6334e26914dd4f6ccded5f87ceb004601f10dc Mon Sep 17 00:00:00 2001 From: Balazs Kreith Date: Wed, 29 Jun 2022 10:14:40 +0300 Subject: [PATCH 3/6] tsc fix --- my-webrtc-app/package.json | 10 +++++----- my-webrtc-app/src/mediasoup/MediasoupClient.ts | 6 +++--- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/my-webrtc-app/package.json b/my-webrtc-app/package.json index d0792e5..bae7bf0 100644 --- a/my-webrtc-app/package.json +++ b/my-webrtc-app/package.json @@ -6,7 +6,7 @@ "scripts": { "test": "echo \"Error: no test specified\" && exit 1", "compile": "webpack --mode development", - "prod-compile": "webpack", + "prod-compile": "webpack --mode production", "start": "node server.js" }, "author": "", @@ -22,11 +22,11 @@ "react": "^18.1.0", "react-dom": "^18.1.0", "ts-loader": "^9.3.0", - "uuid": "^8.3.2", - "webpack": "^5.72.0", - "webpack-cli": "^4.9.2" + "uuid": "^8.3.2" }, "devDependencies": { - "@types/sdp-transform": "^2.4.5" + "@types/sdp-transform": "^2.4.5", + "webpack": "^5.73.0", + "webpack-cli": "^4.10.0" } } diff --git a/my-webrtc-app/src/mediasoup/MediasoupClient.ts b/my-webrtc-app/src/mediasoup/MediasoupClient.ts index 6070f4a..b005b76 100644 --- a/my-webrtc-app/src/mediasoup/MediasoupClient.ts +++ b/my-webrtc-app/src/mediasoup/MediasoupClient.ts @@ -75,15 +75,15 @@ export async function create(config: MediasoupConfig) { .onConsumerRemoved(({ consumerId }) => { console.log(`Consumer is closed ${consumerId}`); const consumer = consumers.get(consumerId); - const { clientId, userId } = consumer.appData; + const { clientId, userId }: { clientId?: string, userId?: string} = consumer.appData; if (!consumer.closed) { consumer.close(); } const track = consumer.track; appEvents.emitRemoteMediaTrackRemoved({ track, - userId, - clientId, + userId: userId ?? "userId", + clientId: clientId ?? "clientId", }); }) .build(); From c8e9f4626f5dc0d0ff5502dccc3a7f0b1239c2e9 Mon Sep 17 00:00:00 2001 From: Balazs Kreith Date: Mon, 4 Jul 2022 14:42:50 +0300 Subject: [PATCH 4/6] rtt --- my-webrtc-app/src/components/Canvas.tsx | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/my-webrtc-app/src/components/Canvas.tsx b/my-webrtc-app/src/components/Canvas.tsx index 87285a7..7eb7d03 100644 --- a/my-webrtc-app/src/components/Canvas.tsx +++ b/my-webrtc-app/src/components/Canvas.tsx @@ -10,6 +10,7 @@ export type CanvasConfig = { }; type State = { + callId?: string, peerConnections: string[], localClient: ClientConfig, remoteClients: Map, @@ -100,9 +101,13 @@ export class Canvas extends React.Component { stats.push(``); }); const peerConnections: string[] = []; - Array.from(metrics.peerConnections.values()).forEach(pcMetrics => { - Object.entries(pcMetrics).filter(kv => kv[0] !== "label").map(kv => `${pcMetrics.label}.${kv[0]}: ${kv[1]}`).forEach(line => peerConnections.push(line)); - }); + const sndTransportMetricsArray = Array.from(metrics.peerConnections.values()).filter(pc => pc.label === "sndTransport"); + if (sndTransportMetricsArray) { + peerConnections.push(`RTT: ${sndTransportMetricsArray[0].rtt}`); + } + // Array.from(metrics.peerConnections.values()).forEach(pcMetrics => { + // Object.entries(pcMetrics).filter(kv => kv[0] !== "label").map(kv => `${pcMetrics.label}.${kv[0]}: ${kv[1]}`).forEach(line => peerConnections.push(line)); + // }); this.setState({ ...this.state, statsCollectingTimeInMs: metrics.statsCollectedInMs, @@ -133,6 +138,7 @@ export class Canvas extends React.Component { render() { return (
+ {/* callId: {(this.state?.callId)} */} { (this.state?.peerConnections) ? this.state.peerConnections.map(statLine => { From b0549ff4c9a75816e078b947697f0c5c0d604046 Mon Sep 17 00:00:00 2001 From: Balazs Kreith Date: Mon, 4 Jul 2022 15:47:17 +0300 Subject: [PATCH 5/6] turn --- my-webrtc-app/src/mediasoup/MediasoupClient.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/my-webrtc-app/src/mediasoup/MediasoupClient.ts b/my-webrtc-app/src/mediasoup/MediasoupClient.ts index b005b76..037d5b2 100644 --- a/my-webrtc-app/src/mediasoup/MediasoupClient.ts +++ b/my-webrtc-app/src/mediasoup/MediasoupClient.ts @@ -14,6 +14,7 @@ let rcvTransport: mediasoup.types.Transport | undefined; let sndTransport: mediasoup.types.Transport | undefined; const iceServers = [{ urls : ['turn:turn.example.com:443?transport=tcp'], + // urls: ['stun:stun.l.google.com:19302'], username : 'example', credential : 'example' }]; From 6da887499b0690fac910c057e7a4a2173eb98a03 Mon Sep 17 00:00:00 2001 From: Balazs Kreith Date: Thu, 7 Jul 2022 17:53:20 +0300 Subject: [PATCH 6/6] save --- docker-compose-alpine.yaml | 67 ------ docker-compose-cascaded-sfus.yaml | 10 + docker-compose.yaml | 12 + mediasoup-sfu/Dockerfile.alpine | 22 -- my-notebooks/Dockerfile | 20 ++ my-notebooks/basic-questions.ipynb | 79 ++----- .../end-to-end-rtts-cascaded-sfus.ipynb | 210 +++++++++++------- my-notebooks/end-to-end-rtts-single-sfu.ipynb | 192 ++++++++++------ my-webrtc-app/Dockerfile.alpine | 19 -- 9 files changed, 319 insertions(+), 312 deletions(-) delete mode 100644 docker-compose-alpine.yaml delete mode 100644 mediasoup-sfu/Dockerfile.alpine create mode 100644 my-notebooks/Dockerfile delete mode 100644 my-webrtc-app/Dockerfile.alpine diff --git a/docker-compose-alpine.yaml b/docker-compose-alpine.yaml deleted file mode 100644 index 86f259d..0000000 --- a/docker-compose-alpine.yaml +++ /dev/null @@ -1,67 +0,0 @@ -services: - observer: - restart: always - image: observertc/observer:1.0.0-beta - ports: - - 7080:7080 - environment: - - MICRONAUT_CONFIG_FILES=/my-config.yaml - volumes: - - ./observer-config/config.yaml:/my-config.yaml - - mongodb: - image: mongo:4.2 - hostname: mongodb - environment: - MONGO_INITDB_ROOT_USERNAME: root - MONGO_INITDB_ROOT_PASSWORD: password - ports: - - 27017:27017 - restart: always - - mongo-express: - image: mongo-express - ports: - - 8081:8081 - environment: - ME_CONFIG_MONGODB_SERVER: mongodb - ME_CONFIG_MONGODB_ADMINUSERNAME: root - ME_CONFIG_MONGODB_ADMINPASSWORD: password - ME_CONFIG_BASICAUTH_USERNAME: admin - ME_CONFIG_BASICAUTH_PASSWORD: password - restart: always - depends_on: - - mongodb - - mediasoup_sfu: - build: - context: ./mediasoup-sfu - dockerfile: Dockerfile.alpine - network_mode: bridge - cap_add: - - NET_ADMIN - ports: - - 15000-15100:15000-15100/udp - - 5959:5959 - environment: - - HOSTNAME=localhost - - RTCMIN_PORT=15000 - - RTCMAX_PORT=15100 - - WEBPAGE_PORT=5959 - - SERVER_IP=0.0.0.0 - - OUTBOUND_LATENCY_IN_MS=400 - - ANNOUNCED_IP=${SFU_ANNOUNCED_IP} - - OBSERVER_INTERNAL_ADDRESS=host.docker.internal:7080 - depends_on: - - observer - webrtc-app: - build: - context: ./my-webrtc-app - dockerfile: Dockerfile.alpine - environment: - - SAMPLING_PERIOD_IN_MS=10000 - ports: - - 9000:9000 - depends_on: - - observer -version: '3.3' \ No newline at end of file diff --git a/docker-compose-cascaded-sfus.yaml b/docker-compose-cascaded-sfus.yaml index 406fa97..59e4016 100644 --- a/docker-compose-cascaded-sfus.yaml +++ b/docker-compose-cascaded-sfus.yaml @@ -1,4 +1,14 @@ services: + notebooks: + restart: always + build: + context: ./my-notebooks + dockerfile: Dockerfile + ports: + - 8888:8888 + volumes: + - ./my-notebooks:/home/jovyan/work + observer: restart: always image: observertc/observer:1.0.0-beta diff --git a/docker-compose.yaml b/docker-compose.yaml index c5dd443..6dcd196 100644 --- a/docker-compose.yaml +++ b/docker-compose.yaml @@ -1,4 +1,14 @@ services: + notebooks: + restart: always + build: + context: ./my-notebooks + dockerfile: Dockerfile + ports: + - 8888:8888 + volumes: + - ./my-notebooks:/home/jovyan/work + observer: restart: always image: observertc/observer:1.0.0-beta @@ -34,6 +44,7 @@ services: - mongodb mediasoup_sfu: + restart: always build: context: ./mediasoup-sfu dockerfile: Dockerfile @@ -54,6 +65,7 @@ services: - OBSERVER_INTERNAL_ADDRESS=host.docker.internal:7080 depends_on: - observer + webrtc-app: build: context: ./my-webrtc-app diff --git a/mediasoup-sfu/Dockerfile.alpine b/mediasoup-sfu/Dockerfile.alpine deleted file mode 100644 index efc843b..0000000 --- a/mediasoup-sfu/Dockerfile.alpine +++ /dev/null @@ -1,22 +0,0 @@ -FROM node:alpine - -USER root - -ENV TZ=Europe/Helsinki - -WORKDIR /app - -COPY package.json ./ - -COPY ./ ./ - -RUN apk add --no-cache git make bash python3 py3-pip net-tools gcc alpine-sdk iproute2 linux-headers -RUN npm install -RUN npm install typescript -g -RUN tsc - -# for throttling traffic -# RUN apt-get install -y net-tools iproute2 - -# ENV DEBUG="mediasoup*" -CMD [ "node", "dist/main.js" ] diff --git a/my-notebooks/Dockerfile b/my-notebooks/Dockerfile new file mode 100644 index 0000000..6e7f821 --- /dev/null +++ b/my-notebooks/Dockerfile @@ -0,0 +1,20 @@ +FROM jupyter/base-notebook + +USER root + +# Add requirements file +ADD requirements.txt /app/ + +# Installs, clean, and update +RUN apt-get update \ + && apt-get clean \ + && apt-get update -qqq \ + && apt-get install -y -q g++ \ + && pip install --upgrade pip \ + && pip install -r /app/requirements.txt + +ENV JUPYTER_ENABLE_LAB=yes + +CMD jupyter notebook --port=8888 --no-browser --ip=0.0.0.0 --allow-root --NotebookApp.token='' --NotebookApp.password='' + +EXPOSE 8888 \ No newline at end of file diff --git a/my-notebooks/basic-questions.ipynb b/my-notebooks/basic-questions.ipynb index 0c9297d..e6b08fd 100644 --- a/my-notebooks/basic-questions.ipynb +++ b/my-notebooks/basic-questions.ipynb @@ -5,12 +5,14 @@ "id": "69fbed7d", "metadata": {}, "source": [ - "# Calls" + "# Calls\n", + "\n", + "List the calls" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 5, "id": "5a51b9ce", "metadata": {}, "outputs": [ @@ -19,59 +21,22 @@ "output_type": "stream", "text": [ "\n", - "Room: Santo Domingo\n", + "Room: Pyongyang\n", "--------\n", "\n", - "Call ae2b890e-4c67-4947-9448-9b074ee947a7\n", - "\n", - "\tUserId: Peeves \n", - "\tClientId: 64aeee1c-b6b6-43d4-a076-80cc1377d174\n", - "\tJoined: 1654800562698\n", - "\tLeft: 1654801764402\n", - "\tDuration: 20 min\n", - "\n", - "\tUserId: Bellatrix Lestrange \n", - "\tClientId: e6c57372-08c8-4853-9cb3-912daadd3e20\n", - "\tJoined: 1654801711505\n", - "\tLeft: 1654801784404\n", - "\tDuration: 1 min\n", - "\n", - "Call 3f7c39a9-1ae5-4d9f-a6e5-5f467d367ce3\n", - "\n", - "\tUserId: Hedwig \n", - "\tClientId: bf7b9ea1-d2c5-4762-93d8-33a3a9729bcd\n", - "\tJoined: 1654803322051\n", - "\tLeft: 1654803966491\n", - "\tDuration: 10 min\n", + "Call 9236312f-2697-41e4-82d4-3ff43fd404e8\n", "\n", "\tUserId: Dumbledore \n", - "\tClientId: 89c82d9d-d9a9-4d82-bcb7-82fe9eec4811\n", - "\tJoined: 1654803326351\n", - "\tLeft: 1654803966491\n", - "\tDuration: 10 min\n", - "\n", - "\tUserId: Bellatrix Lestrange \n", - "\tClientId: dff1e8a7-9633-49ca-9e9b-19f6e52a9931\n", - "\tJoined: 1654803329499\n", - "\tLeft: 1654803966491\n", - "\tDuration: 10 min\n", + "\tClientId: 8b2a6420-b596-4005-aabf-e849a992502d\n", + "\tJoined: 1657197987140\n", + "\tLeft: 1657197999786\n", + "\tDuration: 0 min\n", "\n", - "Room: Washington, D.C.\n", - "--------\n", - "\n", - "Call 84f0aacc-b135-42ad-932f-b7b010a5754c\n", - "\n", - "\tUserId: Seamus Finnigan \n", - "\tClientId: d0b47c12-969f-4681-836a-143f4fd27d66\n", - "\tJoined: 1654803655203\n", - "\tLeft: 1654803966491\n", - "\tDuration: 5 min\n", - "\n", - "\tUserId: Hedwig \n", - "\tClientId: a7ed9d5d-d6e4-49dc-8637-ba836fc04165\n", - "\tJoined: 1654803662356\n", - "\tLeft: 1654803966491\n", - "\tDuration: 5 min\n" + "\tUserId: Fleur Delacour \n", + "\tClientId: 806b77ce-a81c-4e05-9b50-956ec618d442\n", + "\tJoined: 1657197994033\n", + "\tLeft: 1657197999786\n", + "\tDuration: 0 min\n" ] } ], @@ -80,7 +45,11 @@ "\n", "import time\n", "\n", - "MONGO_HOST=\"localhost\"\n", + "# If jupyter runs on localhost:\n", + "# MONGO_HOST=\"localhost\"\n", + "\n", + "# If jupyter runs in docker\n", + "MONGO_HOST=\"host.docker.internal\"\n", "MONGO_USER=\"root\"\n", "MONGO_PASSWORD=\"password\"\n", "MONGO_PORT=27017\n", @@ -152,7 +121,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 6, "id": "40f84b55", "metadata": {}, "outputs": [ @@ -160,7 +129,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "number of concurrent sfu streams 34\n" + "number of concurrent sfu streams 8\n" ] } ], @@ -475,7 +444,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -489,7 +458,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.10" + "version": "3.10.5" } }, "nbformat": 4, diff --git a/my-notebooks/end-to-end-rtts-cascaded-sfus.ipynb b/my-notebooks/end-to-end-rtts-cascaded-sfus.ipynb index 1f489de..0c7701f 100644 --- a/my-notebooks/end-to-end-rtts-cascaded-sfus.ipynb +++ b/my-notebooks/end-to-end-rtts-cascaded-sfus.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 110, + "execution_count": 1, "id": "500e9ea2", "metadata": { "tags": [] @@ -21,76 +21,73 @@ "output_type": "stream", "text": [ "\n", - "Room: Santo Domingo\n", + "Room: Pyongyang\n", "--------\n", "\n", - "Call ae2b890e-4c67-4947-9448-9b074ee947a7\n", + "Call 9236312f-2697-41e4-82d4-3ff43fd404e8\n", "\n", - "\tUserId: Peeves \n", - "\tClientId: 64aeee1c-b6b6-43d4-a076-80cc1377d174\n", - "\tJoined: 1654800562698\n", - "\tLeft: 1654801764402\n", - "\tDuration: 20 min\n", + "\tUserId: Dumbledore \n", + "\tClientId: 8b2a6420-b596-4005-aabf-e849a992502d\n", + "\tJoined: 1657197987140\n", + "\tLeft: 1657197993061\n", + "\tDuration: 0 min\n", "\n", - "\tUserId: Bellatrix Lestrange \n", - "\tClientId: e6c57372-08c8-4853-9cb3-912daadd3e20\n", - "\tJoined: 1654801711505\n", - "\tLeft: 1654801784404\n", - "\tDuration: 1 min\n", + "\tUserId: Fleur Delacour \n", + "\tClientId: 806b77ce-a81c-4e05-9b50-956ec618d442\n", + "\tJoined: 1657197994033\n", + "\tLeft: 1657197998063\n", + "\tDuration: 0 min\n", "\n", - "Call 3f7c39a9-1ae5-4d9f-a6e5-5f467d367ce3\n", + "Room: Kabul\n", + "--------\n", "\n", - "\tUserId: Hedwig \n", - "\tClientId: bf7b9ea1-d2c5-4762-93d8-33a3a9729bcd\n", - "\tJoined: 1654803322051\n", - "\tLeft: 1654858224864\n", - "\tDuration: 915 min\n", + "Call cf400eb5-d979-4441-a056-b7e98e64d9f3\n", "\n", - "\tUserId: Dumbledore \n", - "\tClientId: 89c82d9d-d9a9-4d82-bcb7-82fe9eec4811\n", - "\tJoined: 1654803326351\n", - "\tLeft: 1654858224864\n", - "\tDuration: 914 min\n", + "\tUserId: McGonagall \n", + "\tClientId: c2a49398-efb0-4ebe-b97f-b96b58aede93\n", + "\tJoined: 1657199265848\n", + "\tLeft: 1657204468216\n", + "\tDuration: 86 min\n", "\n", - "\tUserId: Bellatrix Lestrange \n", - "\tClientId: dff1e8a7-9633-49ca-9e9b-19f6e52a9931\n", - "\tJoined: 1654803329499\n", - "\tLeft: 1654858224864\n", - "\tDuration: 914 min\n", + "\tUserId: Snape \n", + "\tClientId: 3b26fb8c-80c6-4910-8f78-ddea858d6a59\n", + "\tJoined: 1657199277467\n", + "\tLeft: 1657204468216\n", + "\tDuration: 86 min\n", "\n", - "Room: Washington, D.C.\n", + "Room: Cairo\n", "--------\n", "\n", - "Call 84f0aacc-b135-42ad-932f-b7b010a5754c\n", + "Call 85987ce6-817d-4831-bb48-6e8f4762fed9\n", "\n", - "\tUserId: Seamus Finnigan \n", - "\tClientId: d0b47c12-969f-4681-836a-143f4fd27d66\n", - "\tJoined: 1654803655203\n", - "\tLeft: 1654803965004\n", - "\tDuration: 5 min\n", + "\tUserId: Ron Weasely \n", + "\tClientId: 1aece275-7992-4d0d-9537-3791f29d61b2\n", + "\tJoined: 1657204303021\n", + "\tLeft: 1657204468216\n", + "\tDuration: 2 min\n", "\n", - "\tUserId: Hedwig \n", - "\tClientId: a7ed9d5d-d6e4-49dc-8637-ba836fc04165\n", - "\tJoined: 1654803662356\n", - "\tLeft: 1654803960000\n", - "\tDuration: 4 min\n", + "\tUserId: Ginny \n", + "\tClientId: 468c9502-619f-48de-a89a-5043d6f6a08d\n", + "\tJoined: 1657204320108\n", + "\tLeft: 1657204468216\n", + "\tDuration: 2 min\n", "\n", - "Room: San José\n", + "Room: Caracas\n", "--------\n", "\n", - "Call c264c30d-ddbd-4112-87b6-ec99bfdb9f22\n", + "Call 635e0c58-b6da-4f9d-b3c2-ff6fe458df60\n", "\n", - "\tUserId: Nymphadora Tonks \n", - "\tClientId: c00acfd8-e6a5-4226-8938-052f5d3eb214\n", - "\tJoined: 1654845700631\n", - "\tLeft: 1654846507756\n", - "\tDuration: 13 min\n", + "\tUserId: Moaning Myrtle \n", + "\tClientId: 50c62bc3-7c52-4af2-b271-1352fac03f65\n", + "\tJoined: 1657204356211\n", + "\tLeft: 1657204468217\n", + "\tDuration: 1 min\n", "\n", - "\tUserId: Cornelius Fudge \n", - "\tClientId: f17cf111-932a-4757-b52c-ce4ca4ce53e3\n", - "\tJoined: 1654845714677\n", - "\tLeft: 1654846497758\n", - "\tDuration: 13 min\n" + "\tUserId: James Potter \n", + "\tClientId: b314af08-642c-4896-af4b-6bd9ce530038\n", + "\tJoined: 1657204361515\n", + "\tLeft: 1657204468217\n", + "\tDuration: 1 min\n" ] } ], @@ -99,7 +96,12 @@ "\n", "import time\n", "\n", - "MONGO_HOST=\"localhost\"\n", + "# if jupyter runs on localhost\n", + "# MONGO_HOST=\"localhost\"\n", + "\n", + "# if jupyter runs in docker\n", + "MONGO_HOST=\"host.docker.internal\"\n", + "\n", "MONGO_USER=\"root\"\n", "MONGO_PASSWORD=\"password\"\n", "MONGO_PORT=27017\n", @@ -173,14 +175,23 @@ }, { "cell_type": "code", - "execution_count": 119, + "execution_count": 2, "id": "d968cc3c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "selected call: 635e0c58-b6da-4f9d-b3c2-ff6fe458df60 sleected client: 50c62bc3-7c52-4af2-b271-1352fac03f65\n" + ] + } + ], "source": [ - "CALL_ID = \"c264c30d-ddbd-4112-87b6-ec99bfdb9f22\"\n", - "CLIENT_ID = \"c00acfd8-e6a5-4226-8938-052f5d3eb214\"\n", - "# print(\"selected call is \", CALL_ID, \"in room\", clients[CLIENT_ID][\"roomId\"], \"selected user is \", clients[CLIENT_ID][\"userId\"])\n", + "CALL_ID = \"635e0c58-b6da-4f9d-b3c2-ff6fe458df60\"\n", + "CLIENT_ID = \"50c62bc3-7c52-4af2-b271-1352fac03f65\"\n", + "\n", + "print(\"selected call:\", CALL_ID, \"sleected client:\", CLIENT_ID)\n", "\n" ] }, @@ -194,10 +205,19 @@ }, { "cell_type": "code", - "execution_count": 120, + "execution_count": 3, "id": "2cc2def7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of measurements to analyze on 2016e451-262d-4714-aea3-fe512d77aca7: 26\n", + "Number of measurements to analyze on c779e802-539d-4dfd-9176-127f354d9827: 26\n" + ] + } + ], "source": [ "peer_connection_rtts = {}\n", "\n", @@ -223,7 +243,11 @@ " measurement = (rtt_in_s, timestamp)\n", " measurements.append(measurement)\n", " peer_connection_rtts[peerconnection_id] = measurements\n", - " \n" + " \n", + "# data check\n", + "for peerconnection_id in peer_connection_rtts:\n", + " print(\"Number of measurements to analyze on %s: %s\" % (peerconnection_id, len(peer_connection_rtts[peerconnection_id])))\n", + " " ] }, { @@ -236,10 +260,19 @@ }, { "cell_type": "code", - "execution_count": 121, + "execution_count": 4, "id": "b6300cc0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "client_id:b314af08-642c-4896-af4b-6bd9ce530038 maps to the following remote_peer_ids: {'b314af08-642c-4896-af4b-6bd9ce530038': '2016e451-262d-4714-aea3-fe512d77aca7', '50c62bc3-7c52-4af2-b271-1352fac03f65': 'c779e802-539d-4dfd-9176-127f354d9827'}\n", + "client_id:50c62bc3-7c52-4af2-b271-1352fac03f65 maps to the following remote_peer_ids: {'b314af08-642c-4896-af4b-6bd9ce530038': '2016e451-262d-4714-aea3-fe512d77aca7', '50c62bc3-7c52-4af2-b271-1352fac03f65': 'c779e802-539d-4dfd-9176-127f354d9827'}\n" + ] + } + ], "source": [ "# map client ids to its peer connections subscribed to receive inbound tracks\n", "client_inb_pc_ids = {}\n", @@ -296,7 +329,10 @@ " client_remote_peers = client_outb_pc_pairs.get(remote_client_id, {})\n", " client_remote_peers[client_id] = remote_client_peerconnection_id\n", " client_outb_pc_pairs[client_id] = client_remote_peers\n", - "\n" + "\n", + "# data check\n", + "for client_id in client_outb_pc_pairs:\n", + " print(\"client_id:%s maps to the following remote_peer_ids: %s\" % (client_id, client_outb_pc_pairs[client_id]))\n" ] }, { @@ -309,7 +345,7 @@ }, { "cell_type": "code", - "execution_count": 122, + "execution_count": 5, "id": "0daf8f4f", "metadata": {}, "outputs": [], @@ -321,10 +357,19 @@ }, { "cell_type": "code", - "execution_count": 123, + "execution_count": 7, "id": "816ac058", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mapping transport ids to sfu ids: {'6254261b-2098-43b6-a5ec-573486cba05b': '1124de3b-fc2d-430f-87bd-5bfc8098fcab', '3d9ca887-1004-4537-8632-bd781de03a89': 'ab9a5927-e9b9-463e-b6f7-4ca2b8e5955b'}\n", + "mapping sfu sinks to sfus: {'03368097-9976-4ccc-9094-34191784b4a5': '9aa7bc11-cbc0-490d-aa70-e7bea8d83041', '63856c04-9c2f-4c90-9ee2-9f577dafffad': '9aa7bc11-cbc0-490d-aa70-e7bea8d83041', 'd7fd8e69-9e50-436a-89e4-37686652a17e': '9aa7bc11-cbc0-490d-aa70-e7bea8d83041', '424139ab-4783-4606-b484-58f9fd49b95b': '9aa7bc11-cbc0-490d-aa70-e7bea8d83041', '651dc19b-06ff-464f-a184-869a2c6c11f7': '1124de3b-fc2d-430f-87bd-5bfc8098fcab', '7dd79e91-dd38-486d-8971-fe48eb39a11d': '1124de3b-fc2d-430f-87bd-5bfc8098fcab', 'c7aece50-6c74-4e9f-a453-1b9c6c677c17': 'ab9a5927-e9b9-463e-b6f7-4ca2b8e5955b', '5009078b-6d5f-42e7-a1e1-8aec6bca170f': 'ab9a5927-e9b9-463e-b6f7-4ca2b8e5955b'}\n" + ] + } + ], "source": [ "sfu_sink_to_sfu = {}\n", "sfu_transport_rtts = {}\n", @@ -367,8 +412,8 @@ " measurements.append(measurement)\n", " sfu_transport_rtts[sfu_transport_id] = measurements\n", " \n", - "# print(transports_to_sfu)\n", - "# print(sfu_sink_to_sfu)" + "print(\"mapping transport ids to sfu ids:\", transports_to_sfu)\n", + "print(\"mapping sfu sinks to sfus:\", sfu_sink_to_sfu)\n" ] }, { @@ -381,10 +426,18 @@ }, { "cell_type": "code", - "execution_count": 124, + "execution_count": 9, "id": "728999a4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "internal transport mappings: {'6254261b-2098-43b6-a5ec-573486cba05b': '3d9ca887-1004-4537-8632-bd781de03a89', '3d9ca887-1004-4537-8632-bd781de03a89': '6254261b-2098-43b6-a5ec-573486cba05b'}\n" + ] + } + ], "source": [ "transport_pairs = {}\n", "\n", @@ -410,7 +463,8 @@ " \n", " if remote_sfu_transport_id is not None:\n", " transport_pairs[sfu_transport_id] = remote_sfu_transport_id\n", - " \n" + " \n", + "print(\"internal transport mappings:\", transport_pairs)" ] }, { @@ -431,7 +485,7 @@ }, { "cell_type": "code", - "execution_count": 117, + "execution_count": 10, "id": "d34bb316", "metadata": {}, "outputs": [], @@ -517,13 +571,13 @@ }, { "cell_type": "code", - "execution_count": 125, + "execution_count": 11, "id": "58a3fed1", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAArcAAAEWCAYAAAB8Nb+hAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA6eElEQVR4nO3debgdRZ3/8feHBIIQ9kQMJCGIEYiOiRgDDig4KJvjRBwYYRBBdHBDcVdcgB+ODLgrKssIxIVNERRHFBBBUBZJMGwBJECUxCCBEEgAgcD390fVya17crZ7c9fO5/U897mnq7qrq6u3b3dXn6OIwMzMzMysCtYZ7AqYmZmZmfUVB7dmZmZmVhkObs3MzMysMhzcmpmZmVllOLg1MzMzs8pwcGtmZmZmlTGgwa2kWZL+eyDnuSYkhaSXrO116E+S9pf0gKQVkl453OdjnZG0h6SFg10PG54kHS/pR4Ndj05I2lLSNZKWS/pqg3zvC9YrkraXNDdvWx/qxfQLJL2hD+ox5PbHIXXntq8aeiBIulrSP3Kw9LCkiySNk/SZnLYi5z9XDN9ffH5K0vPF8Ip+qONwCIy/AhwVEaMj4k+SjpI0W9LTkmaVI0o6pGwvSU/mZXxVH89nPUkX5u0xJO1Rl/96SVdJekzSgnYzlrSppO9Leij/HV+Xf5WkJZIel3SLpJlF3psk/V7SMkkPSvqepI06WN52dZqct88fFWnltltuo2Ny/ixJz9SNMyLnrcm6aVS/4yU9W1fmi3PeSyX9PLfZUkmXSdp+Tdukl/XcPNfj931c7rG5/frixFMeq1ZIurvIe72k2/L29YikiyVt3WG5vZ52sEgaJemsvK89KOmjdfl7Srorb79XSdqmD2Z7JPAwsHFEfKyDOk6SdKmkR3Mdvy1pZG9nLmmspHPz8epRSed0ON2kvA2W++DnO5z2LBXnn9zuZ0r6i1IgNlfSvsX4u0i6Iu/PSyT9RNK4ujJ3UrpIWCHp75KObjH/UZJOy+MtlfSLctuUtKOk3+Y2mS9p/yJvitK54dH89xtJUzotu0l9PpLX5eO5bUYVeQuUjrW1Nr68yDtM0pw83UJJX6rbFj4JXBURG0XEt1odN9uRdJCku3ObPKR0ztq4k2nblNtu3bc839aNd6c6vBAcUsHtMHRURIwGXgKMBr4SESfmAGo08F7g+tpwRGxb5O0L/K3IGz2IyzGYtgHuKIb/Bvw3cFb9iBFxTl17vR+4D7i5L+eT/R54O/Bgg7wn8nSf6GC+AF8HNgAmATOAQyW9s8g/GhgXERuTToQ/Kg7sm+R6bgXsCGwNfLnD+bbyHeCmMqHcdnP7ngxcHREPF6N9qRwnIp7L067Jumnmgrp53ZfTNwUuAbYHtgT+CPx8DeazJk4G7uzLAiVtBxwILO7DYo8q2rG8EJgH7B0Rm5K2sXuAUzssc02mHSzHA5NJx4PXA5+UtA+A0kXcRcDngc2B2cAFfTDPbYB50fkvJn0XeAgYB0wDdiftT711Eek4NhF4IelCvyc2LbadL7QbWdJuwHZ1ySOBB0jLsgnwOeDHkibl/M2AM0jHyG2A5cDZRZljgF8DpwNbkM65q4LABo4GXgO8grRtPgqckssaSTpe/B9pPdeOuS/N0/4NOCDnjSEda87vpOwm7bE38Glgz7xsLwb+X91oby7aeK8ifQPgw7keO+cyPl7k15/XoPlxs50/ALtGxCa5jiNJ55411W7dQ+vzbc0ngCUdzzUiWv6RVt5Pc6H3Ax8q8o4Hfgz8gLQx3gFML/JfSTq5LScdJM4H/rvJfH4IPA88BawAPpnT/y2Xuwy4GtixTX3/FZibx78OeEWRt4C0YdwKPJbrtH6R/wnSCeVvwBFAAC9pMp+rgXcXw+8H7qgb53Dg902m3wNY2EH7B/AhUqDwMCmwWafIP4J0cn0UuAzYJqdfk6d9Irfn24DfAf+e83fN+W/Kw3sCc9uVm/N2AK4AlgJ3A/9R5M0iBU6/zOv9RmC7Bss1KterVsd76/L/G5jVpm2uAo4rhl8AfBX4S16/vyftTL2eD7AQ2KNJ3huABR2sw4eBVxfDnwGubTLuDOAfwIwm+W8FbiuG35nX0/K8jbyng/ocRNpvjwd+1GQc5fIOq1u3Dfffduum2faf2+Jh0r55SJHftG4Nyto8r98t8vCIXO69uV3mABOaTNtom3lBztuFdAxZBtxSvx0A/wxcn9fB7+vyZpKOQ4/neuzT6foincT3y23yhrrlPJt0fHoU+FmR1+q4dzXFsapFO44C/ocUiNXSNgHOJB0XF5H2lxGdTNtgnE8X62QesH+Rd3hu+6/kZbsf2LfI35Z0/FpOOvZ8u9X20aL9/wbsVYz3BeD8/PlI4Loib0PS+WiHTtZdo3mS9plngWdIx6E3kLa5WXk555HOOwuLcu4E9iuGvwyc3mJZm64jYK+8Ha22ztotEynQDGBkJ/thnmYk8CdS4Nf0/JnHvZV8PmqQtxOwvBg+EfhhD+pxKulCvDb8JuDu/PnleV2oyL8c+EKT5fkA8GQnZTepy7nAicXwnsCDxfACiv28zXJ9FPhF/vxb4DnS+WIF8FLaHDeBQ0nHukeAzzabN+lm3Q+AS4u0drHghaSYajkp7pva03VPk/Mtaf+/k3RTsG3cFBGtg1vSnd05wLHAeqRo/j7S1Xptgf5BOhCPIB3cbsh56+VG/AiwLulK6FlanBzrGzqvrCeAN+YyPgnMB9ZrMv0rSVe8O+f6HJbLHFWU/8e8kjbPjfXenLcP8HfShr9h3iA7Cm5JV5K/AX5eN87h9E1we1Wu70Tgz8V8Z+b22JG0E36O7gfnbvUHTgBOyZ9rJ/+Ti7xvtis3t80DpIPiyNzmDwNTcv4s0o4zI+efQz55tFi+1dqY9kHnNqQde9si7Tt5vWyd1/8/F+u+t/Ppq+B2RjH8WeDRunH+j7QvBSm4WadJWd8o25N0YN2OFIzuDjwJ7NSiLhvnbWg8rYPb15EOmKOLtFmkC5qlpONCsxPTauumyfa/EvgaKTDanbSvb18cWx7L87oDeF+Lst4CLC6GPwHcRrqzK2AqOfBtMG3DbSYPP0I6tq1DOgY9AozN040gHcBfRd1+Ttr2H8vTrJPLqgVILdcX6Y7tz/PnBXQ/Hv6SdPLYjHQ83D2ntzvuXU06IT1MujuzR10bTCQFxc+TjtGHF3kXk+6WbUi66/dHugdATadt0NYHko6965Autp8gPbEgt+GzwH/lZXgfKRBVzr++2FZeRzqBNtt2G7Z/brcAtizGPYB8sQh8Ezi1rqzb6boh0HTdtVnnsyjOe8BJwLWkY/qEPI8yuH0PKbDYIJdzO8WFQIPlbbqOSOfuy4Afkbbfm2rbTQfLNCm31yLScfBsYEybY90n6DqPtDp/bkk63u3QJP/D5FgiD/82r5/rSNv6L4CJLeoxnbStb5Xb8VzgGzmvUXB7BXBxXRnLSMeo54HPdVJ2k7rcArytGB5D94vxBaTYYwkpyJ7aoqyfAScVw1fT/Sbb8TQ5bgJT8nK/jrQffS0vX3mM2S1PH6T9c6+c3kks+Cxpf1qXdBPxfmDdnqx7mge3/wfsT4dxU0T74HZn4K91accAZxcL9Ju6xnsqf34dxcEpp11Hz4LbzwM/LobXIe1oqy18zj+Vuqsv0p3F3Yvy317kfQk4LX8+q26jeSntg9sniw1hLnU7G30X3O5TDL8fuDJ//hXwrrr2eZKuu7f1we2ewK3586+Bd9N1MfI74K3tyiWdlK6tq+Pp5Lt0pAP594q8/YC72ixfb4LOz5MemZd1fIomB4Y1mE9fBLc/Ij0a3Ij0OO1e4OkG461LujL9aJNy3ki62/PSFvP6GXB0i/xvAp/Kn4+neYBwZn27kO6mbEG6aNmPFGDs2m7dtNj+VwIbFmk/Bj6fP08hnTxqAedi4OAG5YwnHRMOLtLuBmZ2sF6abjPAp6i7U0QKEg7Lnz9CDoRYPbg9Hfh6u/nXr6+8fdwDTMrDC8jHQ9Ij6ueBzRqU0e64t3MuexQp8F1O46cpm+fl3iUPbwk8Tb6TndMOJvXxazlth8s+t7aechvOL/I2IO2zLyIF0PXbyrkttt2G7U8KJIPuT+veSN6H8zZ/Ut00f6BJwF637pquc1YPbu+j+zH9SLoHtzuSAomVub6zKM6jdWW3XEekR/0BvIt0fDmIFLQ1DFLrlmk0KZAbmedzIXBZi/U5gXRTZJM83OyYuy7pZlDDu9Gku75LgdcWaX/O9X41sD7wLeAPLeqyCelJceR2/BOweTH/+0g3y9Yl3d1+ptGykS4Y3k9+wtmu7CZ1WfXkoJh/0LWf70q6m78BKb56kNQVpL6cI0jnozFF2tV0D26bHjdJgen5dcv2DI3v3G5NOj+8NLqOIe1iwfJiZJ0879fWTdNu3a92viUFtb/Kn/egw+C2XZ/bbYCtlF4YWCZpGemO35bFOGUfiSeB9XOflq2ARZFrlP2l9kHSr4oOz4c0mf9W5TQR8TzpruHWkiZq9ZextgE+VlffCbmcZvWt9XXdKpe9Wl1b+FCk/imvIN0VGN/BNL1RX6/a8mwDfLNY1qWkK/BmnduvB14qaUtSX64fABNyf6YZpK4M7crdBti5ro0PIZ2Eapq1cV96B/D9YngM6aB3bz/Mq2Pq/lLWaTn5Q6Qg6h5SX6/zSDtxNxHxbET8CthL0r/VlbsL6YR+QET8uUjfV9IN+cWGZaSgs/YCWLd9TNI0UkD+9TbLsAHpLlvZvkTEzRHxSESsjIhLSXfl39qgiG7rpsm+Cunu9RPF8KptOyLmRcTfIuK5iLiOFJQfUFfPsaQ7Hd+NiPOKrAk02A4arJtW28w2wIF12/luwDhJW5HW6WcbTNd0/rkOTdcX6QTxw4hY0KTMpRHxaJO6Nj3uRcSNEbE8Ip6OiO+TArb96guJiKWk9fbzfAzfhnQyWlyUezrp7mC7aRst+zvyyyS1sl5eLDsUx42IeDJ/HJ2Xo9G20kyz9q9te+VLMhuTgv1afv0LNKvy26y7puu8gabnGknrkG48XEQKPsaQzi0n5/zTim34M7RfR0+Rgvcz8/Hl/DzvXdstU0SsiIjZeX//O3AU6di0kaTXFvWo9fn8BnBCRDzWbMHz8v2QFFQd1SD/JaSbK0dHxLVF1lOkO6s3RcQ/SH1W/1nSJk2Oud8hXcxtkdvxolwuEfEs6WnPm0jb3MdIF9aNjslPAKcBP5BUa9OmZav7i7W/yuPXb1e1z8vzPP4QEU9FxJMR8T+kIP61de3yFtKT8X2j+zsQ9fVtddzstt3lZXukSTmLSNthra9xJ7FgWfbzpPZcFXu1W/eNSNqQdBOyx98E0e4NzAeA+yNick8LJkXtW0tSEeBOJB8AImLfBtNE3fDfgH+qDUgS6SCyKCL+yupB0wPAFyPii72s74RieGKnE0bEbUpfcfYdSTvVBfR9YQJdncYnktoFupa3o7dfI+JJSXNIHeJvj4hnJF1H6sdzb7HTNC1X6e3h30XEG3u/OGtG0q6knebCIvlh0qOO7UiPgQZFRJxI6h9Wpi0lXQAAIOlE0qPDZkZSvJCh9NVllwBHRMSVRfooUh+od5AeZT8r6WekC5HV9jFJHyY9avxr2pUYDYyQNCUidipG3Z90QXN1u8WtzauYx2rrpsm+CrCZpA2LoGUi6RFs23lJ2owU2F7SYH9/gNR+3cqqXzf5YNtsm3mAFGj+V31F8olmHDAvt+MLgBdIepB0AVibf/10LdcX6cnKeEm1l4fGkl68OJl0Ibq5pE0jYlmDuvbkuLfaeiuMJAVGG+dynybdKVrZQbnltEvLjHzc+F/SMl4fEc9JmtuiHqXFNN5Wmh1nG7Z/RDwqaTGpm8oVOXkqXcfWO0h3tmt13jCXc0cH667hPFssT/0xvabW/ezbEfE08LSks0lPmD4ZEe8lvahcq+M4Wq+jW4E316VFnrbdMtWrtfc6OfCs36f3BHaT9KUi7XpJR0fEufn8fSYpINovB5mr5G3kN6SnED9ssBzl+l71udExl3Tz5rP52IukU4ATJI2JiIcj4lZSN4zavK+j7mK+sA5dXUQealP2OaSL/tIdpO3sx3l4KvD3iGgYWLL6sW4f0r7zpoi4rck0zZRlLSY9FaiVuwEpQG+mPA91Eguuip/ysXU8OVZpt+5bmEw6Z12bj7XrAZvkY+0uTW4EJK1u69LVr+xTpAP4CNLV9quj61b0j4rxJ5E7oOdK/JUUSK1LusPTrs/tDcCRxfD2pH4fe9LVj+M+mve5nU5aCTuTVuiGpKuzjXL+Arp3e1hVf9Lj4AdJt/U3ID1KbvhYJRo/DliPtCJnFmmH0zfdEq4kXb1PAO6qtREpCLkdeFl0PS45sJj2QYqXJ3LaiaQXHmqPfz+Qh79TjNO0XNLjzb+QOqavm/9eTX7Rj9UfwbVczvo2ztvO+qSr1B/mzyPrpjkD+EGDsr6T26r2WOY1NOlz224+pCvz9UlXn3vlz7X+f+vk4X1zW6xPk20yj78d6SAyIk/zcNG2O+S0F+S2fDvpyrbW7+3lpP5Yb2tQ7kakvq27k7b3fUl3ypu9tLkB6Q577e8rpCB0bN14l5PuwNRPfwDphLZObpPlrP4IqeG6abL9r8x1WI90p+IJuvopziRt8yI9VVhEV5eAjUkXB99uUvYnSCfDyXn6V9C6z+1q2wxpX3sQ2Dunr5/rPD7nl+14NOnFyRflMmeQ7r7sSfc+ny3XV95GynIfIN1BH53zf0m6e1/rc/u6dsc90jdL7J3rP5J0kfUEXY8b30o6zq5DDqaBm4v2+Tnp7s/GeZzt6Oru0HLaunaeQrqQ2D635zvz+q+9P3A4q7+Ut2qfJZ0batvKbqRjVqs+t6u1f847idQFa7O8ThbT9bLZWFI3s3/P7XUyXd222q27VvOcRfdj4slFHcaTttWyW8J9pJfvRub1dzFwbot9qdU62pzUlemw3O4HkC48xnSwTDsX63cLUn/vq1rU44V0336D9FJm7QXN0/J6HN1g2q1JN74+3qTsf8nLMY207X+dJi/l5vHPJgXum+TxP0O6KVbLf0VexxvQ1T+0dq54I6kf+4jcpt8indvX76TsBnXZh67YYlNS/+GTct5E0l309XJ9at8IsEWx3I+Q9/UGZV9N9zik1XHzZaS7yLvl+X2Fos8t6dgwMX/ehrSNXpSHO4kFnyUdE0aSbpgtIPe5bbXuc37D820uq9ym3prXxYto8pLkqjI7OAltRXqM+mDeuG4oGuN4mgS3xUH3T3R9W8IFtA5uZ5IC4mXkjZwUaM0jHXR+Rw4K2mxIN+UyFgM/oYPgNg9/Oi9nj78tIad9CphdDB9O335bwiOkN7tHFPmHkl6eeZx0gjuryHtvboNl5G80IJ3ogq6D38vz8Nvq5tuq3O1JJ9oluU6/BablvFmsWXB7fE4r/44v8tfPy7Nng7JeQHo0tihvL9fQdWDt6XwWNMifVCxTfd7VLZbxP/I29SSpn+HeRd6OpMBoeV6um+j+FvnZpL6WK4q/O4r8D5CC32WkIL3pN5I0qNfx1AUIpJPMShr3lbs2t+vjpDudB9XlN103zbZ/0qP9h0n7/aFF/nl521pBuqAr38w9jO7fBFL7qx2YR5Begrw/t+tNwPgm9Wi1zexMOuYsJW3rv6TBSyw0Dsz2JwUty0n9EGsvXnS8vmj8bQnfz9M/Sj7x5LyGxz1SwHZTsX3dALyxmO6DuZ2eIB37zqf7N6NsQurTuzC3z59q673dtA2W54u5LR8mvczyOzoPbl9M2v5W0Nm3JTRr/1Gk9ysez+340brp3kDa3p4iHeMndbqvtZjnrLrxNiDdiV9G429LmJbn/Whuqx9TvATXYFmbrqOc/1rSsXwF6evNXtvJMpH67tbW7+Jc5xd1cmxpsP62ycO1N/trf4fk/ONyfpm3oq6895H200dJL5Q1/AaUPO4WpDuoD+Vl+z3dX+r9ci5nBalLQXluODBvAyvo2u9f0WnZTerz0dzOj5OO6bVA+mV5m6l1EbiS7t84dRXpeFy2y6+K/KvpHtw2PW4Wx86/0uDbEkj758Jcl4WkGxVbFNO2iwXLb0v4E103aFqu++JY1/B8W1f/Peiwz23tTpSZmZmZ2bDX7oUyMzMzM7Nhw8GtmZmZmVWGg1szMzMzqwwHt2ZmZmZWGe2+59ZsjUiaQHrLdkvSG5BnRMQ368bZg/R1NvfnpIsi4oSctw/pa25GkH757KRW8xszZkxMmjSpD5fAzKz65syZ83BEjB3sepj1BQe31t9WAh+LiJslbQTMkXRFRMyrG+/aiPjXMkHSCNL3kL6R9NUkN0m6pMG0q0yaNInZs2f38SKYmVWbpE5+ldNsWHC3BOtXEbE4Im7On5cDd9L854HrzSD93vx9EfEM6TsYZ/ZPTc3MzKwKHNzagJE0ifTLLzc2yH6NpFsk/UrSy3Ja7adMaxbSIDCWdKSk2ZJmL1mypK+rbWZmZsOIg1sbEJJGk36y8MMR8Xhd9s2kXzaaCpwC/KwnZUfEGRExPSKmjx3rLmNmZmZrMwe31u8krUsKbM+JiIvq8yPi8YhYkT9fCqwraQzppxYnFKOOz2lmZmZmDTm4tX4lScCZwJ0R8bUm47woj4ekGaTt8hHgJmCypG0lrQccBFwyMDU3MzOz4cjflmD9bVfgUOA2SXNz2meAiQARcRpwAPA+SSuBp4CDIiKAlZKOAi4jfRXYWRFxxwDX38zMzIYRpRjCrBqmT58e/iowM7OekTQnIqYPdj3M+oLv3JqZrSXmPrCMU668hxVPrwRg9KiRfHDPyUybsOngVszMrA85uDUzW0uccuU9XHnXQ6uln3n4qwehNmZm/cMvlJmZrSVqd2w3Wn8kG60/sluamVlVOLg1M1vLTBm3MVPGbTzY1TAz6xcObs3MzMysMhzcmpmZmVllOLg1MzMzs8pwcGtmZmZmleHg1szMzMwqw8GtmZmZmVWGg1szMzMzqwwHt2ZmZmZWGQ5uzczMzKwyHNyamZmZWWU4uDUzMzOzynBwa2ZmZmaV4eDWzMzMzCrDwa2ZmZmZVYaDWzMzMzOrDAe3ZmZmZlYZDm7NzMzMrDIc3Fq/kjRB0lWS5km6Q9LRDcY5RNKtkm6TdJ2kqUXegpw+V9Lsga29mZmZDTcjB7sCVnkrgY9FxM2SNgLmSLoiIuYV49wP7B4Rj0raFzgD2LnIf31EPDyAdTYzM7NhysGt9auIWAwszp+XS7oT2BqYV4xzXTHJDcD4Aa2kmZmZVYa7JdiAkTQJeCVwY4vR3gX8qhgO4HJJcyQd2aTcIyXNljR7yZIlfVZfMzMzG35859YGhKTRwE+BD0fE403GeT0puN2tSN4tIhZJeiFwhaS7IuKacrqIOIPUlYHp06dHvyyAmZmZDQu+c2v9TtK6pMD2nIi4qMk4rwC+B8yMiEdq6RGxKP9/CLgYmNH/NTYzM7PhysGt9StJAs4E7oyIrzUZZyJwEXBoRPy5SN8wv4SGpA2BvYDb+7/WZmZmNly5W4L1t12BQ4HbJM3NaZ8BJgJExGnAscAWwHdTLMzKiJgObAlcnNNGAudGxK8HtPZmZmY2rDi4tX4VEb8H1GacdwPvbpB+HzB19SnMzMzMGnO3BDMzMzOrDAe3ZmZmZlYZDm7NzMzMrDIc3JqZmZlZZTi4NTMzM7PKcHBrZmZmZpXh4NbMzMzMKsPBrZmZmZlVhoNbMzMzM6sMB7dmZmZmVhkObs3MzMysMhzcmpmZmVllOLg1MzMzs8pwcGtmZmZmleHg1szMzMwqw8GtmZmZmVWGg1szMzMzqwwHt2ZmZmZWGQ5uzczMzKwyHNyamZmZWWU4uDUzMzOzynBwa/1K0gRJV0maJ+kOSUc3GEeSviVpvqRbJe1U5B0m6Z78d9jA1t7MzMyGm5GDXQGrvJXAxyLiZkkbAXMkXRER84px9gUm57+dgVOBnSVtDhwHTAciT3tJRDw6sItgZmZmw4Xv3Fq/iojFEXFz/rwcuBPYum60mcAPIrkB2FTSOGBv4IqIWJoD2iuAfQaw+mZmZjbMOLi1ASNpEvBK4Ma6rK2BB4rhhTmtWXp9uUdKmi1p9pIlS/q0zmZmZja8OLi1ASFpNPBT4MMR8Xhflh0RZ0TE9IiYPnbs2L4s2szMzIYZB7fW7yStSwpsz4mIixqMsgiYUAyPz2nN0s3MzMwacnBr/UqSgDOBOyPia01GuwR4R/7WhF2AxyJiMXAZsJekzSRtBuyV08zMzMwa8rclWH/bFTgUuE3S3Jz2GWAiQEScBlwK7AfMB54E3pnzlkr6AnBTnu6EiFg6cFU3MzOz4cbBrfWriPg9oDbjBPCBJnlnAWf1Q9XMzMysgtwtwczMzMwqw8GtmZmZmVWGg1szMzMzqwwHt2ZmZmZWGQ5uzczMzKwyHNyamZmZWWU4uDUzMzOzynBwa2ZmZmaV4eDWzMzMzCrDwa2ZmZmZVYaDWzMzMzOrDAe3ZmZmZlYZDm7NzMzMrDIc3JqZmZlZZTi4NTMzM7PKcHBrZmZmZpXh4NbMzMzMKsPBrZmZmZlVhoNbMzMzM6sMB7dmZmZmVhkObs3MzMysMkYOdgWs2iSdBfwr8FBEvLxB/ieAQ/LgSGBHYGxELJW0AFgOPAesjIjpA1NrMzMzG65859b62yxgn2aZEfHliJgWEdOAY4DfRcTSYpTX53wHtmZmZtaWg1vrVxFxDbC07YjJwcB5/VgdMzMzqzgHtzYkSNqAdIf3p0VyAJdLmiPpyMGpmZmZmQ0n7nNrbUn6aAejPRERp6/BbN4M/KGuS8JuEbFI0guBKyTdle8E19fvSOBIgIkTJ65BFczMzGy4851b68QngNHARi3+PraG8ziIui4JEbEo/38IuBiY0WjCiDgjIqZHxPSxY8euYTXMzMxsOPOdW+vEDyPihFYjSNqwt4VL2gTYHXh7XXnrRMTy/HkvoGUdzMzMzBzcWlsR8cnejiPpPGAPYIykhcBxwLp5mtPyaPsDl0fEE8WkWwIXS4K0nZ4bEb/u7TKYmZnZ2sHBrXVM0tHA2aTvnv0e8Erg0xFxebNpIuLgduVGxCzSV4aVafcBU9egumZmZrYWcp9b64kjIuJxUheBzYBDgZMGt0pmZmZmXRzcWk8o/9+P1A/3jiLNzMzMbNC5W4L1xBxJlwPbAsdI2gh4fpDrZGuBuQ8s45Qr7wHgg3tOZtqETQe3QmZmNmQ5uLWeeBcwDbgvIp6UtAXwzsGtkq0NTrnyHq6866FVw2ce/upBrI2ZmQ1l7pZgbUl6EUBEPB8RN0fEsjz8SETcWo5j1h9WPL2y4WczM7N6vnNrnbgU2KkPxjEzW2O1biq1C53Ro0a6u4qZreLg1joxVdLjLfIFtMo3M+sz9d1UatxdxczAwa11ICJGDHYdzMxqandsN1o/ncKW/2Olu6uY2SoObs3M1mI33r+Ut51+PTD8Hu9PGbcxkJbBzKzGwa1ZB9zHz6qsPjj0430zG84c3FpbkkZGxFr9zK+nffzKYLi/A+H6wBuGZvDd0wuEcvx5i92le03NfWBZ0zucfrxvZlWiiBjsOtgQJ+nmiBgW34Qwffr0mD17do+nqw+87l3yBADbjd0Q6LqzVQYBADtvu3nD8uqDiDGjRzF1/CYNA4f6ebUbbjev0p47vJDdtx/L7+5ewoqnV/a47Hb5pdGjRnabV/1ws3p22oY1G60/ctXj6GZ62qaNlrMWfAOrXTyU6pezp23cqu6NLgBaXTg1utCpKdtzzx1e2G2d1NZBOdxofXY6r0bL3ZPhTrelst6ttotW66DdvNpZk32q3frtzbymbLUxx735ZW3rXU/SnIiY3uMJzYYgB7fWlqQ/RcQrB7senehtcPuuWTc1vDNbrz4IGEpqJ/ehWLdS/QVCJ3bedvMhv1z9pf7CqFE79HS7/PkHduXES+9sGtx2UpehsD5qQXgn++5QVl7grWm77rzt5lzwntf0eDoHt1Yl7pZgnRgr6aPNMiPiawNZmf5Qvn3dKugaPWr1XabZncfRo0Zyy8LHeHjF003Hn7f48VXzazfvRvMqp58ybmMueM9rVt35aXfCL+fX6K5X/Um22XI2GreVGZNSOWX9WrXhh/aczNQJm7a9U9ibujTSKpCur2e7ebVr43rl+qx5eMXTbddlq4C3VLZnuS032q4baVaXnrZLXynvrjfbLlptx53Us9V2X7//Ai3Xd6P126oePalrbdwpW7XexszWBg5urRMjgNGk77OttCnjNuaY/XbklCvvAeBDe04mYLXhmlqg0Ez9I+T68cs7xjMmbc4H95zcct718yqnrwUo0yZsypmHv3q1ee+x/ViuvnvJqrK+VQTAMyZtvlr/4dr0vVnO+qC+dsevN21YU1uudurr3Wj9tWvjRv2DG9VzTdu4XrsnCLUAppxXfVDXrK71akFh2Q41ZdmtLtLatUtZdqfDzbadZm08tc120Wo7brb+mu2v9er3X6Dl+i7Hb9VVqdG827VpJ/uQ2drC3RKsrbWhz+3bTr+eG+9f2utHer3VkwCyr6df03l3UnanQUJV9bSNy/F7Gmj1p4Fcn8Np2+lpwNmf+9yacrcEqxIHt9aWpKUR0fzZ3BAy3IJbM7OhwMGtVck6g10BGxYWDnYFzMzMzDrh4NY64S++NDMzs2HBL5RZJ8ZL+lazzIj40EBWxszMzKwZB7fWiaeAOYNdCTMzM7N2HNxaJx6JiO8PdiXMzMzM2nGfW+vEM40SJa0j6ZBWE0o6S9JDkm5vkr+HpMckzc1/xxZ5+0i6W9J8SZ9es0UwMzOztYGDW+vE3pKOkfRtSXsp+SBwH/AfbaadBezTZpxrI2Ja/jsBQNII4DvAvsAU4GBJU9ZsMczMzKzq3C3BOvED4FHgeuDdwGdIv1b2loiY22rCiLhG0qRezHMGMD8i7gOQdD4wE5jXi7LMzMxsLeHg1jrx4oj4JwBJ3wMWAxMj4h99VP5rJN0C/A34eETcAWwNPFCMsxDYudHEko4EjgSYOHFiH1XJzMzMhiN3S7BOPFv7EBHPAQv7MLC9GdgmIqYCpwA/62kBEXFGREyPiOljx47to2qZmZnZcOTg1joxVdLj+W858IraZ0mPr0nBEfF4RKzIny8F1pU0BlgETChGHZ/TzMzMzJpytwRrKyJG9FfZkl4E/D0iQtIM0gXXI8AyYLKkbUlB7UHAf/ZXPczMzKwaHNxav5J0HrAHMEbSQuA4YF2AiDgNOAB4n6SVpB+LOCgiAlgp6SjgMmAEcFbui2tmZmbWlINb61cRcXCb/G8D326SdylwaX/Uy8zMzKrJfW7NzMzMrDIc3JqZmZlZZTi4NTMzM7PKcHBrZmZmZpXh4NbMzMzMKsPBrZmZmZlVhoNbMzMzM6sMB7dmZmZmVhkObs3MzMysMhzcmpmZmVllOLg1MzMzs8pwcGtmZmZmleHg1szMzMwqw8GtmZmZmVWGg1szMzMzqwwHt2ZmZmZWGQ5uzczMzKwyHNyamZmZWWU4uDUzMzOzynBwa2ZmZmaV4eDWzMzMzCrDwa31K0lnSXpI0u1N8g+RdKuk2yRdJ2lqkbcgp8+VNHvgam1mZmbDlYNb62+zgH1a5N8P7B4R/wR8ATijLv/1ETEtIqb3U/3MzMysQkYOdgWs2iLiGkmTWuRfVwzeAIzv90qZmZlZZfnOrQ0l7wJ+VQwHcLmkOZKObDaRpCMlzZY0e8mSJf1eSTMzMxu6fOfWhgRJrycFt7sVybtFxCJJLwSukHRXRFxTP21EnEHuzjB9+vQYkAqbmZnZkOQ7tzboJL0C+B4wMyIeqaVHxKL8/yHgYmDG4NTQzMzMhgsHtzaoJE0ELgIOjYg/F+kbStqo9hnYC2j4jQtmZmZmNe6WYP1K0nnAHsAYSQuB44B1ASLiNOBYYAvgu5IAVuZvRtgSuDinjQTOjYhfD/gCmJmZ2bDi4Nb6VUQc3Cb/3cC7G6TfB0xdfQozMzOz5twtwczMzMwqw8GtmZmZmVWGg1szMzMzqwwHt2ZmZmZWGQ5uzczMzKwyHNyamZmZWWU4uDUzMzOzynBwa2ZmZmaV4eDWzMzMzCrDwa2ZmZmZVYaDWzMzMzOrDAe3ZmZmZlYZDm7NzMzMrDIc3JqZmZlZZTi4NTMzM7PKcHBrZmZmZpXh4NbMzMzMKsPBrZmZmZlVhoNbMzMzM6sMB7dmZmZmVhkObs3MzMysMhzcWr+SdJakhyTd3iRfkr4lab6kWyXtVOQdJume/HfYwNXazMzMhisHt9bfZgH7tMjfF5ic/44ETgWQtDlwHLAzMAM4TtJm/VpTMzMzG/Yc3Fq/iohrgKUtRpkJ/CCSG4BNJY0D9gauiIilEfEocAWtg2QzMzMzB7c26LYGHiiGF+a0ZumrkXSkpNmSZi9ZsqTfKmpmZmZDn4NbG/Yi4oyImB4R08eOHTvY1TEzM7NB5ODWBtsiYEIxPD6nNUs3MzMza8rBrQ22S4B35G9N2AV4LCIWA5cBe0naLL9ItldOMzMzM2tq5GBXwKpN0nnAHsAYSQtJ34CwLkBEnAZcCuwHzAeeBN6Z85ZK+gJwUy7qhIho9WKamZmZmYNb618RcXCb/AA+0CTvLOCs/qiXmZmZVZO7JZiZmZlZZTi4NTMzM7PKcHBrZmZmZpXh4NbMzMzMKsPBrZmZmZlVhoNbMzMzM6sMB7dmZmZmVhkObs3MzMysMhzcmpmZmVllOLg1MzMzs8pwcGtmZmZmleHg1szMzMwqw8GtmZmZmVWGg1szMzMzqwwHt2ZmZmZWGQ5uzczMzKwyHNyamZmZWWU4uDUzMzOzynBwa2ZmZmaVMXKwK2A2FEzZauNu/83MzGx4cnBrBhz35pcNdhXMzMysD7hbgvU7SftIulvSfEmfbpD/dUlz89+fJS0r8p4r8i4Z0IqbmZnZsOM7t9avJI0AvgO8EVgI3CTpkoiYVxsnIj5SjP9B4JVFEU9FxLQBqq6ZmZkNc75za/1tBjA/Iu6LiGeA84GZLcY/GDhvQGpmZmZmlePg1vrb1sADxfDCnLYaSdsA2wK/LZLXlzRb0g2S3tJkuiPzOLOXLFnSR9U2MzOz4cjBrQ0lBwEXRsRzRdo2ETEd+E/gG5K2q58oIs6IiOkRMX3s2LEDVVczMzMbghzcWn9bBEwohsfntEYOoq5LQkQsyv/vA66me39cMzMzs24c3Fp/uwmYLGlbSeuRAtjVvvVA0g7AZsD1Rdpmkkblz2OAXYF59dOamZmZ1fjbEqxfRcRKSUcBlwEjgLMi4g5JJwCzI6IW6B4EnB8RUUy+I3C6pOdJF2Inld+y0MicOXMelvSXDqo2Bni4p8szAIZqvcB1642hWi9w3XpjqNYL1rxu2/RVRcwGm7rHEmZrB0mzc1/eIWWo1gtct94YqvUC1603hmq9YGjXzWyguVuCmZmZmVWGg1szMzMzqwwHt7a2OmOwK9DEUK0XuG69MVTrBa5bbwzVesHQrpvZgHKfWzMzMzOrDN+5NTMzM7PKcHBrZmZmZpXh4NaGBUkLJN0maa6k2Tntgjw8N+fPLcY/RtJ8SXdL2rtI3yenzZf06SJ9W0k35vQL8g9OIGlUHp6f8yfVzeNZSU9Lureo1zRJN9TqKmlGTpekb+WybpW0U1HWYZLuyX+HFemvyss9P0+rnL65pCvy+FdI2qzBPJ7J+WWbTZV0fS7zF5I2HoQ2m5/rda2kuyTdKek1HS5Tf7fbfZKWSbq/qNeBku6Q9Lykbl+1NATa7Mt5+FZJF0vadAjV7Qu5XnMlXS5pq6GwPosyPyYplH4gZjD2z9sl/aauzY6XtEhdx7X9Bml9dpuH2bATEf7z35D/AxYAY1rkfxU4Nn+eAtwCjAK2Be4l/YDEiPz5xcB6eZwpeZofAwflz6cB78uf3w+clj8fBFxQN48FwE61eeS8y4F98+f9gKuLz78CBOwC3JjTNwfuy/83y583y3l/zOMqT1sr90vAp/PnTwMnN5jHYmBOXTvdBOyePx8BfGEQ2mwU8FPgoVz+esCmHS5Tf7fb94ETgRuLeu0IbE/6+efpRVsOhTbbCxiZxz25WJ6hULeNi7b6UFHGoK7PnD+B9MMyfyEfVwa4XgJ+CdyX02ttdjzw8QbHt4Fen6vmMdjHfv/5rzd/g14B//mvkz9aBLf5RPEAMDkPHwMcU+RfBrwm/11WpB+T/0T6ZZ9akLBqvNq0+fPIPJ6KaReQfhmoHO8y4G3588HAufnz6cDBxfzvBsblcU4v0k/PaeOAu4r0VePVps2fxwF3188j121+bbyc9hhdL5JOAOYNQpttAtxfjtfpMvVzux2R66VyvKKcq+ke3A56m9XVb3/gnCFat2OAU4fK+gQuBKZSHFcGsF4HF21WX6/jaRzcDtj6rJ9HT47T/vPfUPlztwQbLgK4XNIcSUfW5b0W+HtE3JOHtyYFuzULc1qz9C2AZRGxsi69W1k5/7E8fi09SHdqXwUclqf5MPBlSQ8AXyGdNHpTr63z5/p0gC0jYnH+/CCwZYN5BPBC4LdFm90BzMyfDyQFuL2p25q02bbAkvz/XEnfk7Rhh8vUSd16227P53qdDWwFnJrr1cxQaLPSEaS7gkOmbpK+mPeDQ4Bje1m3Pl2fkmYCiyLiFrobyP2z1mYbAVfVrc+jcreIs2rdGXpRtzVZn42Wx2xYcXBrw8VuEbETsC/wAUmvK/IOBs4bnGqtqtdlwD65Xu8DPhIRE4CPAGf2ZwUiIkiB7Gp1I3VD+BBdbXYE8H5Jc0gn1mf6s25NjCR15bgL+ATwBOnR7SotlqnPNJjHiFyvU0mPm5+qr9cgatlmkj4LrATOGUp1i4jP5v3gHOCo/qxEh+vzeOAzdAXa/a7Jtlxrs0XA2+lqs1OB7YBppG5FXx2oeppViYNbGxYiYlH+/xBwMVB7SWsk8FbggmL0RXTdkQQYn9OapT8CbJrLKtO7lZXzN8njLwIm1OpF6prwm1yvw4CLcvpPanXtRb0W5c/16QB/lzQu12scqb9jt3nkuo0Hbie3WUTcFRF7RcSrSBcE9w50m5HuCC0k9e1bRHpEvFMny9TP7bYusDAibszTXJDr1cxQaDMkHQ78K3BIDqSGTN0K5wD/3su69fX63Ba4RdKCnH6zpBcNYL3KNtuYos0i4u8R8VxEPA/8L70/dqzJ+my0PGbDioNbG/Lyo8SNap9JL9HcnrPfQOr3Vj4evAQ4KL8VvC0wmXTn5iZgcn6LeD3SyxSX5IDgKuCAPP1hwM+LsmrdDQ4AfpvHvwT4T0lb5Hm8lPRCxu3A34Dd8zT/AtxTlPWO/Mb0LsBj+dHlZcBekjbLjyH3IvWPWww8LmmX/Bb2O5rUq76+78ht9i+kR46P19pM0gtzO64DfI70oslAttlBwKOkk/2UPI89gXkdLFN/t9tM4AFJ/5HbbVquVzOD3maS9gE+CfxbRDw5xOo2uajPTNKd3Vp5g7U+b46IF0bEpIiYRAowd4qIBwewXu8A/g4sA57O5dTabFzRZvvTdZwbsPXZYB5mw89gd/r1n//a/ZHeBL4l/90BfLbImwW8t8E0nyXdlbyb/AZzTt8P+HPO+2zdPP5IegHrJ8ConL5+Hp6f819cTPMV4GngH6S3rj+b03cD5uT63gi8KqcL+E6e9210fznpiDyP+cA7i/TppBPcvcC36XoZbAvgSlLg/Btg87p5/IX0GPbPZZsBR+e0PwMn1cobwDarzWNBLvNW4Gekt9DbLdNAtNsDwJM5v1av/UlB0NOkoOSyIdRm83Od5+a/04ZQ3X6a18GtwC+ArYfC+qw7Tiyg64WygazXvTlvXl2b/TDP+1ZSsDlukNZnt3n4z3/D7c8/v2tmZmZmleFuCWZmZmZWGQ5uzczMzKwyHNyamZmZWWU4uDUzMzOzynBwa2ZmQ46kAyXdIel5SdNbjLeppAsl3SXpTkmvyenHS1okaW7+269uuomSVkj6eJH2kTzP2yWdJ2n9umm+JWlFMTxK0gWS5ku6UdKkIu+YnH63pL2L9H1y2nxJ5Q9xbJvLmJ/LXK/dPFq0ya8lLZP0f3Xp5+R53670C2jrtivLbDhycGtma50cEL0/f95K0oX9OK9p9YGVdSdpD0mz6pJvJ/1AyzVtJv8m8OuI2AGYCtxZ5H09Iqblv0vrpvsaXT9XjKStSb/mNz0iXk76hbODivzppK/rKr0LeDQiXgJ8HTg5jzslT/syYB/gu5JGSBpB+iqwfUnfC3xwHpc87ddzWY/mspvOo40vA4c2SD8H2AH4J+AFwLs7KMts2HFwa2Zro02B9wNExN8i4oDWo6+RaaTvIrUeiIg7I+LuVuNI2gR4HfknriPimYhY1q5sSW8B7id9B3RpJPACpV/u2oD0gyzkoPTLpB/MKM0Evp8/XwjsmX/QYSZwfkQ8HRH3k75Tdkb+mx8R90XEM8D5wMw8zb/kMshlvqXVPHKw/GVJN0m6VdJ7apWKiCuB5fXLHRGXRkb6jtvx9eOYVYGDWzNbG50EbJcfV/9E0u2QfspW0s8kXSFpgaSjJH1U0p8k3SBp8zzedvnR7xxJ10raIacfmB/53iLpmvxo+QTgbXleb5M0Q9L1uczrJG3fw3lfLembubzbJdV+inr34hH8n5R/1a/itgWWAGfnZf6e0q8Y1hyVA7+zlH5dDEmjgU8B/68sKNLPVX8F+CuwmPQLZZfXyiH98tfiuvlvTfqhCCJiJemX0LYo07OFOa1Z+hbAslxGmd5qHu/KdXw18Grgv5R+Wayt3B3hUODXnYxvNtw4uDWztdGngXsjYhrwibq8l5Meh78a+CLwZES8Erie9NOpAGcAH4yIVwEfB76b048F9o6IqaSfxH0mp12QH41fQPoZ2tfmMo8FTuzhvAE2yHV/P3BWTvs48IGc/lrSL9QNabkP6Vzge8C/FcH53m0mrRkJ7AScmtvpCdK6BTgV2I5053wx8NWcfjzp8f+KsqAc/M4kBcxbARtKerukrYADgVN6tZD9Zy/SzwXPJf0S4hakn8ztxHeBayLi2n6qm9mgGjnYFTAzG2KuiojlwHJJj5F+OhbSz6K+It/5+2fgJ+lpMgCj8v8/ALMk/Ri4qEn5mwDflzQZCKB8qaflvIvxzgOIiGskbSxp0zzvr0k6B7goIhb2YtkHVETsDKnPLXB4RBzewyIWAgsj4sY8fCE5uI2Iv9dGkvS/QO3lqp2BAyR9idQ95XlJ/yD9tPL9EbEkT3MRaT0/CrwEmJ/X9waS5uc+sIuACcDC3JVhE+CRIr1mfE6jSfojwKaSRua7s+X4zeYh0gXWZT1pMEnHAWOB97Qb12y48p1bM7Puni4+P18MP0+6IbAO6RHytOJvR4CIeC/wOVIwMkfSFg3K/wIpiH058GagfCO/3bxr6n83PSLiJNILQi8A/lDrKlFlEfEg8ECtawewJzAPQNK4YtT9SS+oERGvjYhJETEJ+AZwYkR8m9QdYRdJG+Q+sHsCd0bELyPiRcU0T+bAFuAS4LD8+QDgt7k/6yXAQUrfdLAt6Y7qH4GbgMlK34ywHumls0vyNFflMshl/rzNPC4D3pe7GCDppXVdMlYj6d3A3sDBEfF8q3HNhjMHt2a2NloO9KpPakQ8Dtwv6UCA/HLP1Px5u4i4MSKOJfUFndBgXpvQdVfu8N5Vn7fl+e1G6nf5WJ73bRFxMimIGtbBraT9JS0EXgP8UtJlOX0rSeU3H3wQOEfSraQuCLVuHl+SdFtOfz3wkVbzy3d/LwRuJt0pX4fU/aSVM4EtJM0HPkrXXeM7gB+TAu1fk7qLPJfvyh5FCkzvBH6cx4XUD/ijuawtctlN50HqyjEPuDn3GT+dfAEk6VrgJ6SXzxYW3TxOA7YErs/dP45ts3xmw5LSBaCZ2dpF0rmkR/13AjtGxMslHU76Kqij8jgL8vDDZV6+G3cqMI7UreD8iDghP8qeTHpkfCXwYdLXR12Wx/sf0h3C75P6h/4SeHtETOrBvK8G5gK75zKPiIg/SjqFFMQ9T/oWgMMjorwTbGa2VnBwa2Y2jOTg9uMRMXuw62JmNhS5W4KZmZmZVYbv3JqZmZlZZfjOrZmZmZlVhoNbMzMzM6sMB7dmZmZmVhkObs3MzMysMhzcmpmZmVll/H99GlxI5eVAxQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -560,7 +614,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -574,7 +628,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.10" + "version": "3.10.5" } }, "nbformat": 4, diff --git a/my-notebooks/end-to-end-rtts-single-sfu.ipynb b/my-notebooks/end-to-end-rtts-single-sfu.ipynb index bca5707..c027c10 100644 --- a/my-notebooks/end-to-end-rtts-single-sfu.ipynb +++ b/my-notebooks/end-to-end-rtts-single-sfu.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 1, "id": "500e9ea2", "metadata": { "tags": [] @@ -21,76 +21,73 @@ "output_type": "stream", "text": [ "\n", - "Room: Santo Domingo\n", + "Room: Pyongyang\n", "--------\n", "\n", - "Call ae2b890e-4c67-4947-9448-9b074ee947a7\n", + "Call 9236312f-2697-41e4-82d4-3ff43fd404e8\n", "\n", - "\tUserId: Peeves \n", - "\tClientId: 64aeee1c-b6b6-43d4-a076-80cc1377d174\n", - "\tJoined: 1654800562698\n", - "\tLeft: 1654801764402\n", - "\tDuration: 20 min\n", + "\tUserId: Dumbledore \n", + "\tClientId: 8b2a6420-b596-4005-aabf-e849a992502d\n", + "\tJoined: 1657197987140\n", + "\tLeft: 1657197993061\n", + "\tDuration: 0 min\n", "\n", - "\tUserId: Bellatrix Lestrange \n", - "\tClientId: e6c57372-08c8-4853-9cb3-912daadd3e20\n", - "\tJoined: 1654801711505\n", - "\tLeft: 1654801784404\n", - "\tDuration: 1 min\n", + "\tUserId: Fleur Delacour \n", + "\tClientId: 806b77ce-a81c-4e05-9b50-956ec618d442\n", + "\tJoined: 1657197994033\n", + "\tLeft: 1657197998063\n", + "\tDuration: 0 min\n", "\n", - "Call 3f7c39a9-1ae5-4d9f-a6e5-5f467d367ce3\n", + "Room: Kabul\n", + "--------\n", "\n", - "\tUserId: Hedwig \n", - "\tClientId: bf7b9ea1-d2c5-4762-93d8-33a3a9729bcd\n", - "\tJoined: 1654803322051\n", - "\tLeft: 1654858214687\n", - "\tDuration: 914 min\n", + "Call cf400eb5-d979-4441-a056-b7e98e64d9f3\n", "\n", - "\tUserId: Dumbledore \n", - "\tClientId: 89c82d9d-d9a9-4d82-bcb7-82fe9eec4811\n", - "\tJoined: 1654803326351\n", - "\tLeft: 1654858214687\n", - "\tDuration: 914 min\n", + "\tUserId: McGonagall \n", + "\tClientId: c2a49398-efb0-4ebe-b97f-b96b58aede93\n", + "\tJoined: 1657199265848\n", + "\tLeft: 1657204450188\n", + "\tDuration: 86 min\n", "\n", - "\tUserId: Bellatrix Lestrange \n", - "\tClientId: dff1e8a7-9633-49ca-9e9b-19f6e52a9931\n", - "\tJoined: 1654803329499\n", - "\tLeft: 1654858214687\n", - "\tDuration: 914 min\n", + "\tUserId: Snape \n", + "\tClientId: 3b26fb8c-80c6-4910-8f78-ddea858d6a59\n", + "\tJoined: 1657199277467\n", + "\tLeft: 1657204450188\n", + "\tDuration: 86 min\n", "\n", - "Room: Washington, D.C.\n", + "Room: Cairo\n", "--------\n", "\n", - "Call 84f0aacc-b135-42ad-932f-b7b010a5754c\n", + "Call 85987ce6-817d-4831-bb48-6e8f4762fed9\n", "\n", - "\tUserId: Seamus Finnigan \n", - "\tClientId: d0b47c12-969f-4681-836a-143f4fd27d66\n", - "\tJoined: 1654803655203\n", - "\tLeft: 1654803965004\n", - "\tDuration: 5 min\n", + "\tUserId: Ron Weasely \n", + "\tClientId: 1aece275-7992-4d0d-9537-3791f29d61b2\n", + "\tJoined: 1657204303021\n", + "\tLeft: 1657204450188\n", + "\tDuration: 2 min\n", "\n", - "\tUserId: Hedwig \n", - "\tClientId: a7ed9d5d-d6e4-49dc-8637-ba836fc04165\n", - "\tJoined: 1654803662356\n", - "\tLeft: 1654803960000\n", - "\tDuration: 4 min\n", + "\tUserId: Ginny \n", + "\tClientId: 468c9502-619f-48de-a89a-5043d6f6a08d\n", + "\tJoined: 1657204320108\n", + "\tLeft: 1657204450188\n", + "\tDuration: 2 min\n", "\n", - "Room: San José\n", + "Room: Caracas\n", "--------\n", "\n", - "Call c264c30d-ddbd-4112-87b6-ec99bfdb9f22\n", + "Call 635e0c58-b6da-4f9d-b3c2-ff6fe458df60\n", "\n", - "\tUserId: Nymphadora Tonks \n", - "\tClientId: c00acfd8-e6a5-4226-8938-052f5d3eb214\n", - "\tJoined: 1654845700631\n", - "\tLeft: 1654846507756\n", - "\tDuration: 13 min\n", + "\tUserId: Moaning Myrtle \n", + "\tClientId: 50c62bc3-7c52-4af2-b271-1352fac03f65\n", + "\tJoined: 1657204356211\n", + "\tLeft: 1657204450188\n", + "\tDuration: 1 min\n", "\n", - "\tUserId: Cornelius Fudge \n", - "\tClientId: f17cf111-932a-4757-b52c-ce4ca4ce53e3\n", - "\tJoined: 1654845714677\n", - "\tLeft: 1654846497758\n", - "\tDuration: 13 min\n" + "\tUserId: James Potter \n", + "\tClientId: b314af08-642c-4896-af4b-6bd9ce530038\n", + "\tJoined: 1657204361515\n", + "\tLeft: 1657204450188\n", + "\tDuration: 1 min\n" ] } ], @@ -99,7 +96,11 @@ "\n", "import time\n", "\n", - "MONGO_HOST=\"localhost\"\n", + "# if jupyter runs on localhost\n", + "# MONGO_HOST=\"localhost\"\n", + "\n", + "# if jupyter runs in docker\n", + "MONGO_HOST=\"host.docker.internal\"\n", "MONGO_USER=\"root\"\n", "MONGO_PASSWORD=\"password\"\n", "MONGO_PORT=27017\n", @@ -173,15 +174,23 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 9, "id": "d968cc3c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "selected call: cf400eb5-d979-4441-a056-b7e98e64d9f3 sleected client: c2a49398-efb0-4ebe-b97f-b96b58aede93\n" + ] + } + ], "source": [ - "CALL_ID = \"84f0aacc-b135-42ad-932f-b7b010a5754c\"\n", - "CLIENT_ID = \"a7ed9d5d-d6e4-49dc-8637-ba836fc04165\"\n", + "CALL_ID = \"cf400eb5-d979-4441-a056-b7e98e64d9f3\"\n", + "CLIENT_ID = \"c2a49398-efb0-4ebe-b97f-b96b58aede93\"\n", "\n", - "# print(\"selected call is \", CALL_ID, \"in room\", clients[CLIENT_ID][\"roomId\"], \"selected user is \", clients[CLIENT_ID][\"userId\"])\n", + "print(\"selected call:\", CALL_ID, \"sleected client:\", CLIENT_ID)\n", "\n" ] }, @@ -195,10 +204,19 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 10, "id": "2cc2def7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of measurements to analyze on c1e41306-599d-4852-b489-fecead2a53fa: 40\n", + "Number of measurements to analyze on e5f57ea7-6817-4c3e-bd34-f4e331b8768e: 38\n" + ] + } + ], "source": [ "peer_connection_rtts = {}\n", "\n", @@ -219,12 +237,18 @@ " peerconnection_id = payload[\"peerConnectionId\"]\n", " rtt_in_s = payload[\"roundTripTime\"]\n", " timestamp = payload[\"timestamp\"]\n", + "\n", " \n", " measurements = peer_connection_rtts.get(peerconnection_id, [])\n", " measurement = (rtt_in_s, timestamp)\n", " measurements.append(measurement)\n", " peer_connection_rtts[peerconnection_id] = measurements\n", - " \n" + " \n", + "# data check\n", + "for peerconnection_id in peer_connection_rtts:\n", + " print(\"Number of measurements to analyze on %s: %s\" % (peerconnection_id, len(peer_connection_rtts[peerconnection_id])))\n", + " \n", + " " ] }, { @@ -237,10 +261,19 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 11, "id": "b6300cc0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "client_id:c2a49398-efb0-4ebe-b97f-b96b58aede93 maps to the following remote_peer_ids: {'c2a49398-efb0-4ebe-b97f-b96b58aede93': 'e5f57ea7-6817-4c3e-bd34-f4e331b8768e', '3b26fb8c-80c6-4910-8f78-ddea858d6a59': 'c1e41306-599d-4852-b489-fecead2a53fa'}\n", + "client_id:3b26fb8c-80c6-4910-8f78-ddea858d6a59 maps to the following remote_peer_ids: {'c2a49398-efb0-4ebe-b97f-b96b58aede93': 'e5f57ea7-6817-4c3e-bd34-f4e331b8768e', '3b26fb8c-80c6-4910-8f78-ddea858d6a59': 'c1e41306-599d-4852-b489-fecead2a53fa'}\n" + ] + } + ], "source": [ "# map client ids to its peer connections subscribed to receive inbound tracks\n", "client_inb_pc_ids = {}\n", @@ -281,6 +314,10 @@ " client_remote_peers = client_outb_pc_pairs.get(remote_client_id, {})\n", " client_remote_peers[client_id] = remote_client_peerconnection_id\n", " client_outb_pc_pairs[client_id] = client_remote_peers\n", + "\n", + "# data check\n", + "for client_id in client_outb_pc_pairs:\n", + " print(\"client_id:%s maps to the following remote_peer_ids: %s\" % (client_id, client_outb_pc_pairs[client_id]))\n", "\n" ] }, @@ -294,10 +331,18 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 17, "id": "d34bb316", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "timestamp and rtt pairs: [(1657199277467, 0.0), (1657199277467, 0.804), (1657199287467, 0.796), (1657199287467, 0.806), (1657199297469, 0.798), (1657199297469, 0.804), (1657199307471, 0.794), (1657199307471, 0.804), (1657199317472, 0.806), (1657199317472, 0.808), (1657199327473, 0.818), (1657199327473, 0.804), (1657199337477, 0.796), (1657199337477, 0.806), (1657199347480, 0.794), (1657199347480, 0.808), (1657199357484, 0.8), (1657199357484, 0.806), (1657199367488, 0.824), (1657199367488, 0.808), (1657199377490, 0.81), (1657199377490, 0.804), (1657199387491, 0.792), (1657199387491, 0.804), (1657199397493, 0.812), (1657199397493, 0.806), (1657199407496, 0.8), (1657199407496, 0.808), (1657199417496, 0.804), (1657199417496, 0.872), (1657199427497, 0.816), (1657199427497, 0.826), (1657199437498, 1.43), (1657199437498, 2.638), (1657199447500, 0.808), (1657199447500, 0.814), (1657199457501, 0.794), (1657199457501, 0.806)]\n" + ] + } + ], "source": [ "client_to_client_rtts = {}\n", "\n", @@ -341,18 +386,23 @@ " i = i + 1\n", " j = j + 1\n", "\n", - " client_to_client_rtts[remote_client_id] = (timestamps, end_to_end_rtts)" + " client_to_client_rtts[remote_client_id] = (timestamps, end_to_end_rtts)\n", + "\n", + "# data check\n", + "for remote_client_id, remote_client_rtts in client_to_client_rtts.items():\n", + " x, y = remote_client_rtts\n", + " print(\"timestamp and rtt pairs: \", list(zip(x, y)))\n" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 13, "id": "58a3fed1", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAEWCAYAAACE1URWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA0D0lEQVR4nO3debxdVXnw8d9DwjyFSWUIBAEHwIIawKEqNSpoX0WtCrYqVChai6I4ofZFSltfhzpVUUFFUFFAaiWtKFoUsQpIQERGCYMQBgkgJICIyPP+sdYx+x7uGZKcm3vvzu/7+ZzPPWfvtddae1r7OWuvfW5kJpIkSVJbrTHZFZAkSZImkgGvJEmSWs2AV5IkSa1mwCtJkqRWM+CVJElSqxnwSpIkqdVWacAbESdGxL+syjJXRkRkROy4utdhVYqIGyLieUOmXa22zfKKiL+PiN9ExL0Rsdlk12d1FxGPjohzI2JpRHx0iPTPjIhr6v576Tjzj46Ir05QXadFWx0R50TEIdO5HiuzHyPioIj434lKP1VNlf2+Miby/F1ZEfEvEXFHRNw22XUZpSnVw7s8wc5kqyfcA/VidEdEfDMitoyI99Zp99b5f2x8vr7x/ncR8XDj870TUMdpHxBGxNsi4raIWBIRJ0TE2iuQxwnd26K53evrjxHxqSHyelVE/DQi7o+Ic7rmPS4izoiIxRFxV0ScFRGPH5DfiyPislqHn0bEzl3zHxsR/12DpDsi4sONeU+MiB9ExD0RsTAiXtaYtybwMeAFmblBZt7Zpw5H1e3zvK7pz4uIiyPivohYFBGvasx7bp23JCKui4hDG/O2jIj5EXFLzXdOv21Ql3lzPT+WRMSCiPjzxry31TKW1Dw/HhEzu5Y/vC5/X0RcGRGPG1Rmj3rsWvfbHRHR80fKI2Knen5/tTHtLyLilxFxd0TcGRH/GRFbNxY7FLgD2Cgz396V39l1WzXX6xjg03X/fWtAvfseexHxua7j/fcRsXS4rQIRsV5EfKZul3si4tyu+U+JEszfG+VL1uHD5j0ZImLbcdqAjIi3D156YN4REe+LiBvrMXtKRGy0HMtnPY479frCytZpQHkrde5ExHNqnYf6ghQRr6vpD2lMmxURJ0XE7fV19HKuxrB1jSjB3M31OD4nInbpSjNuuxcRm0fET+q5fXdEnBcRz2wst1Ln2Aqsy4S0mRGxLfB2YOfMfMyAOkREfKhukzvr+xgn3Xj7/C8i4od1P9zQI/9eddw7uuKniDhw0DabUgHvNHRYZm4A7AhsAPxbZn6gXqA2AN4InNf5nJnbN+a9ELilMW+DSVyPKSki9gGOBOYB2wGPBf5pOfP4c2CH7uld2/0xwO+AbwyR5V3AJ4APjjNvFjAfeDzwaOBnwBl96rYTcDLlOJkF/Bcwv9MwRcRawPeBH9Q6bgN8tc6bWfP+b2BTSjD11cbF6tHAOsDl/VYmInYAXgnc2jV9Z+BrwPuAjYHdgIvqvDWB/wSOq/P2Bz4WEbvVxR8Gvgv8Vb+yG2XtRdmer6j5fRH4z4iYUZPMB56SmRsBu9a6vKWx/CHAwcBfUs7D/0MJLFfEH4DTan79HAtc2DXtCmCfzJwFbAVcA3y2MX874Irs+m8/EfE3wJrjlLEdA/Zfwyz6HHuZ+cauY/7rDHe8dxxPOc6eWP++rVH/zSn7+zhgM0p7+L3lyHuVy8wbu7bHkyjH7X+MIPvXAa8Fnkk5DtYFBn6Z7rJbo34T1pO5sudObQs+CVwwZPpNgPfyyOP648B6wBxgT+C1EfG3w9ZjObwSeD3wLMpxfB7wlUb9erZ7wL112S2ATYAPAf/Vaa9HcI4NbYLbzG2BOzPz9iGqcijw0pr/nwEvBt7QVdde+/w+4ATgnT3WcdCxOSZ+ysyTBtY2M/u+KCfsfwCLgeuBtzTmHU25OHwZWFpXaG5j/pOBi+u8U4FTgH/pUc5XKA3O7ygH1rvq9JfUfO8GzgGeOKC+/we4pKb/KfBnjXk3AO8ALgXuqXVapzH/nZQL/y2UAzuBHXuUcw5wSOPzm4DLu9IcBPxvj+X3BhYNsf2TcqBeV3f2R4A1GvNfD1wJ/BY4C9iuTj+3Lntf3Z77Az8C/qrOf2ad/5f18zzgkkH51nlPoARidwFXA69qzDuREgx8u+73C4Ad+qzfa4FfA3dSGpkbgOfVeV8DPtBIOw+4bTm2zUzg55QTsd++PLDmEY1p+9XjaAlwLbBv1zKHAOcM2Heb1nI36zH/MODbjc9rUI7/efXzocCPeyy7a92vzTp/D/hn4HF1v2dN84M+dfwu8KLmdm9s+3/uscyja97rNaZdCLy6K93Mmm7OgO20P/Czxuf163JbjpN2M+B/gM80ttlNnW02TvodKF8Y7qzHyMnArCHOux2B7DHvAEq7dzTw1R5p1gb+HyXAhXJe/AF4sO6TzjG+MfAr4Gl1nWfW6dcytj1cG9iecg4vpZx/n+5Tfs9jr27fpcBzGtN6ttWU830JpWd6vLI+AHxl0DZtpP8GcBulDT4X2KUx70T6tB/A84Gr6rKfrtvjkB7l7EkJaO6mtOufBtbqkfb9wA+7pvVrA3vWAzgdeGcj7TOAB6jny6D9SP+2ajNKMLOE8qXmn+lxjRmUngHnzqBtUOcfCXy47rdxr+1d6T9HuVaew9jr5x3AHo3P76XR9g3a78Df1XoupXzxfEqP8t8NnNb4vAvwQONzz3avK581KMFdAo8a5hwbJ83R9Vg5taa9mPJFp7ltr22s08sa8yakzQSeR2lzHqa0OyfW6X9OiafursseVKf/FDi0sfzBwPnD7POuMm8YZ/v2a9f3Zoj46RHLDbFTLwKOAtai9LBdR+nF6OywBygXzBmUBv78Om8tSiDzNkrvxSsoDX7Pk4JHXnQ7F+7n1zzeBSykd6P1ZOB2YK9anwNrnms38v8ZJYjflHKCvLHO2xf4DSWQWJ9y4A8V8DYOqDO60hzEaALeH9b6bku5OHbK3a9ujydSgot/BH7ateyOjc/HAJ+q799LOZk+1Jj3yUH51m1zE/C3dd6TKY3VznX+iZTgYs86/2TglB7rtjPlpHo25YL+MeAhlgUDvwD2b6TfnMZFvN+2qfPf2VinfvvyB8DRjc97UhrW51POga2BJ3QtM0zA+1Lg1j7zDwPObHyeQTmfDq+fT6B8EfxO3cbnAE+q88YLeL8P/Gd9P4dGANWj/FdSj1keee5dR7k4/pISLHwV2LQx/2vAP9Q6P51y3s3uyn/YgHcjSjvTOW/fTPmi0ly3v6ZctJPy5Xu3On3bOu1wynF5PeUuwBp1/o51P65N6Zk5F/jEEOfduAFvreuvKL3tR9MVcNb63E25YPyBemFonBv/0pX+WEob+Yj9Nc4+OY9yjqxNOWeWdpc/zLFH6YH80xc8BrTVNf0vKb1wd9T3f9V1/nyScvG7nXKnYts+2/b1wIZ1PT7B2C/aJ9Kj/aCc/0tr/das9X2I3gHvUylfJGbW7Xsl8NZx0gWlLWzuq35tYN96UIKYdzXy6nQudI7Zvvuxpr2F8qXgmzTOH8oXkdMo7fCuwM30D3h7pmfwuTPo+rId5VzYgCEC3rpPF1Da1HN4ZMC7Z+Pz+4DfDrm9X1nXa4+6L3ekKzDvqvNFlNhiTUqw/q1h272a5lLKF9cEPj/MOdYjzdGU86yzXu+o+2DNxnptVbfX/pRYaMtV0GbuTSM2qdtsKfDqWs/NgN3rvHuAvRpp5wJLh9nnjTTjBbzD1PFBSsx2PaVtWr/f8ZeZAwPevYAbu6a9B/hSY4f9T2PezsDv6vtnU07a5g74KcsX8P5fxn4bW4NyYO/dY/nP0vXtjNID+ZxG/q9pzPsw8Ln6/gTgg415j2NwwHt/3eFJ6Q3ctivNQYwm4N238flNwNn1/XeAg7u2z/0s6+UdU39KD+ml9f13KUFb5wvKj4CXD8qXcuL9uKuOxwHvr+9PBL7QmPci4Koe63YUjWCY0ig/yLKAd0zPKuVk+1MANWDbzKY01huPty26TuY/Att3rc/HB+yXvgEvJSC6ma5ez640T6A0YntTgo7/SwmU3lPnf4/SIL6wzn8npRFdq26L6yhfAtcEXlC33Vl12Tn0CXgpAcc1jW15A2PPvQfrtMdRLmj/AZzcmP9iSmPzUH393ThlDBvwBuUL2B9qXmN6e7rS7kS5ID2mfn5GLePblNv6cygX4UfUp6Z/KfDzIc67XgHvJ4F31/dH07+H9d3A0xrTTqTR/lEuDpewLCAbs78Ye7dj27pt1m/M/9p45Q869oCzGfsFr29bXfdN1vVdC3gO5cvWE+v8X1GC/D0ow2j+HfjJoG1cl51V8+6cpyfSo/2gBBHnN+YFsIgeAe84Zb2V+oWwa/qz6vps0JjWrw3sWw9K2/Cruk83pvSwJuWL4cD9WPfHWnXbfBq4rB4jMyjnyBMaaT9A72tM3/QMOHf6bYP6+QxqhwQDAt5alwXU84FHBrxfpQT3G1LOvWuB3w+z3yk9z4cPeQysRTmHs+6H6xnb9vdt9xrp1qEEgAcOc471SHN013qtQQmyn9Uj/SXAfo1tMCFtJo8MeN/DOOdNnffHruNrp5p3DNrnjWXGC3gH1fExlHhzDcodk3OB4wbt/0FjeLcDtqoDtO+OiLvrRn50I03zKb77gXXqmJatgJuz1q76dedNRHynMdj4b3qUv1Vzmcx8mBLtbx1dDx006vv2rvrOrvn0qm9n7OxWNe9H1LWPt2TmxpRb5ptQLjQTobtenfXZDvhkY13vohxoWzO+84DHRcSjgd0pQ1Fm1zF4e1IOmkH5bgfs1bWN/4ZyAHb02sbdxmzzzLyP0rvTcS/lm2xH533zQYBe2+YTwDGZeU+PsjteS7kAXN+YNpvS4K6QiNiCEqx+JjO/3pjeHGC/bWZeRbkL8WlKQ7c55dbVorrI72rdvpOZDwL/Rvl2/cTM/AMlePtLyvZ+O6Unp7Nssz7jnStHU25D39BjNX5H+WL7q8y8l3KhfFHN7wmUnqPXUS4guwDvioi/HGLbPKtRl86YroMpdwx2qfm9BvjviNiqe/nMvIYyxOkzjXoCfDgz767rc1yjro+O8tDQzRGxhHJh3bzO+5tGXb4zRN13pzTOHx+UNjPvAk4Czuh+WKTmtUZdh8Mz86FB+VGO69/Wc6TjEW1Ur2OvMX9bygXty11592yrKdu40+P7YGb+iHJn5QWN+f+ZmRdm5gOUnphnRMTG45Q/IyI+GBHX1v1xQ521eSPZUG10rW/z/O8u63FRHvi8rZb1ga5yOg4E/qMe5x392sBB9TiBMn7zHMqx+sM6fRFD7MfMPLdu57spPVzbU3pZt6AEvuNep2LsA9OfG5SeAedOv20QES8GNszMUxlHd1tH6Yy4NDPPHy89ZWja7yhfws+gbL9OWzZoe4/bXvc4v4+ifDGbTQla/wn4QUSs19gm47Z7TZn5QD2/jmw8u9Ap9xHnWJ+2prleD7PsGOk86HVJY/vvyrLjd8LazHH0ux6Od42+t+6jQfu8n751zMzbMvOKzHy4XrvfxRDPjAwKeG8Crs/MWY3XhpnZa8M03Uo5MZpP7G3beZOZL8xlg41P7kzuyuMWykkHlCcCKRv/5nzkQwed+v5rV33XG6/h71Hf2ePVdZDM/CXwL8CxXes7Kt31uqW+vwl4Q9f6rpuZP+1Rz/spt0EOBy6rQdRPgSOAazPzjiHyvQn4Ude8DTLz71dgvcZs89roNH8+63LKYPiO3YDf5NhfHOi1beYBH6kXu84F9LyI+OuuOryOEpg03cQ4D7oNow7Q/x4wPzP/tTkvxw6wv7FOOz0zd83MzSjjCOew7GGoS3nkOdHM79LMfE5mbpaZ+1CGHP1snHTjnSvzgLc0ts9s4LSIeHePspvvdwV+lZln1Qbnaso38RcO2j6Z+eNGXTpPR+8O/He9yDycmd+lHBvP6JHNTJbtn6tZdntxvLp+oH5+UpYHOF5DuWiTmSc36jKw7pSL2BzgxrrN3gH8VURc3Keej2LsBaFjI0oP76k1r84+XxQRzxon/a3AJhGxfmPamDaq37HX8FpK7+t1XXn3bKspx0K37Jrfa/t3+2vKrfLnUXo/53Sq32eZZj2b7UUw9vzv9lnKuM+d6r5/b3c5EbEu5dbxeG1Arzawbz3qMfz+zJyTmdtQ2rGb62vgfhxHp8dsMaU3b9zrVDYemM7MNw5Kz+Bzp982mAfMbbQf+wNvjYgzal2627p5wMsa6Z8BfDQiPl3T35WZf5OZj6ntwhosa8sG7fdx2+se5/fuwKmZuSgzH8rMEymdVZ1fx1meYxnK3bXHdk17xDnWp61prtcalE6zWyJiO+DzlGFvm2V5EPYylh2/uzNxbWa3ftfD8a7RnY6Mvvt8gOWtYzLMjzBk/y73GZSB1O+mPGk6g3Kx2yOXdck3b8XMqQXPpHzruJESXK0JvJzBY3jPZ+wA6MdTbvnOY9kYl+voPYZ3LmXn7EU5MNan9IBtWOffwNjbtn+qP+VifRvlwF+P0hOUDP/Q2lqUYGu/xrSDGM2QhrMpJ+VsSgN+aJ33MspJsEv9vDHwysayt1F+lqqZ3wco43r+b/38D/XzsY00PfOl3HL6NeWkXrO+9mDZ7c0TGXvbtud6Ur6d3ksZEL8WpQezOYZ338Y+mUUZK/jBIbfNoyi9zp1XUsbzrdtY/hn1+Nqwq157Um7RzqNrDC/lHFiH8ssK59b3nTFXG1Ea6U8P2q+Nsp5a89yC0kP7ta7j/35KcDCDMnbtWurxT7mzsA7leO2M/+qMV59D/yENm3Vtn5soF/4N6vzX1/weW/M/jfpgEqXxuxd4LuU824EyfKR57q7DsgcpHk/j4dBx6nIg5XbVY2t+z6/r3dnmh1AfDKnHwuXAxxrLf5nyaxUbUi4YV1FvxdZ6f75uv62Bn9DnvKvlr1PLyfq+s03X69pm/0YZr7lFnf/yuq5rNPbnxY28T2TZMIHoymuPWt7Wjf17A2Pbq/NrmWtRzpklLGu/hjr2KBeS13dN69tW12kLKUNuZlLGpC5t7J/nUh5q2r2m/Ti9H7Z8E+XW7Eb1+PgMjXaWPu0Hy8ZyvrzW43D6j+H9GaVHLyjDh66mqz2mBOA30DXWkv5tYN96UIaz7FDL3bnm0zw3+u3HXep2nEHp2f5ErXenjek8ULhezXtR9zp1rUff9PQ/dwZdB5rH76l1v2/aox6zutJ3Olo2brQpm9X1fiHlFv0uQ27vV1Lar6cyeAzv+4H/pdylXoNyHbuP+iAr/du9p7HsWrUuJS5aCmw16BzrUZejKedZZ72OoByLa9Z99QClPZlB6c1trvNEtpl7M3ZIw7Z1PV9V69kcw/tGytj4zp2Py1n2XNSgfb4GpX19ISWmWIdGbDegjn9B6QztfPn5IXWobd9tPsRO2Ypye+E2SqN2PssCkqPpEfDWz3MpA6mXUk6IU+kf8O5HaXjvBt7ROOmuoIyV/RGNJ3p75LEvpbfkbso3nm8wRMBbPx9Z13O5f6WhTns3sKDx+SBG+ysNdwIfBWY05r+WMsB+CeWkP6Ex7411G9xN/SUFYJ+a53Pq513r5/27yu2X7+MpPXqLa51+wLIT4ESGDHgbJ+6NjPMrDXX+EZSxokuAL1GDj2G2zTjbcceuacfR4+nyetxdSjl2F7LsQc2Dal7N14mNdUmW/TJG59XvAZ7/rWXcVeuzftf8l9fyl9RjrvlE+0co5+S9lPF2zfHacxjw0FpXOWO2e532T3UfL6Y8PLdJY96rKBfDpZSL6IcY+wsZ3dso+5QdlIcmb6z5XQm8tjH/S/UYuK/W8yOM/XWVjSgX9aWUY/Uolj2QtQvlrsa9lEDr7QOOx852a75u6JH2aMa2H2+mXCzvo7QjpzD2yf4T6f0rNY/YX937hHJx+3FdlzFP9w9z7FHGkD7iC16d17etrtvxvLr8mCfG6/y/p/Rg/pby0NrsHuu5AeWW9VLKRe51DBnw1s/7Ui704z6t31XWsykXyXvrdjuGRwa8Z9H710j6tYE960EZ/3k1JQD5NXBEV7799uNz67L3UR4A/Balh7qz7BaUIGDYX2nom54+586gbdBVzpj9NkR7cw5jO4xeRbnu3k85T/fpSt93v1OudVfXbXoZ8OQe5a5DeVD01rpOF/PIX+AZt92jjF3/Bcva6x8Bz+5atuc51qP9aP5Kw89p/LoE8K+1nDsoDzk2j7GJbDP3pquNpIxzv6BxHBzYqMeHaz3vqu/HfVBvnH2+N49sa88Zso5HUNqb++u8fx9mm3cWliRJklpp8JgHSZIkaRoz4JUkSVKrGfBKkiSp1Qx4JUmS1GqP+EF0qS0233zznDNnzmRXQ5KmlYsuuuiOzNxisushjZIBr1przpw5LFiwYLKrIUnTSkQM859GpWnFIQ2SJElqNQNeSZIktZoBryRJklrNgFeSJEmtZsArSZKkVjPglSRJUqsZ8EqSJKnV/B1eSZPmkpvu5lNnX8O9v39oYNoN1p7Jm+ftxO6zZ018xSRJrWLAK2nSfOrsazj7qtuXa5kvHrTHBNVGktRWBrySJk2nZ3fDdWay85Yb9Ux3xa1LWPrAQ0P1BEuS1M2AV9Kk23nLjTj1DU/vOX//487jguvvWoU1kiS1iQ+tSZIkqdUMeCVJktRqBrySJElqNQNeSZIktZoBryRJklrNgFeSJEmtZsArSZKkVjPglSRJUqv5jyckrZYuueluPnX2NUP997YN1p7Jm+ftxO6zZ018xSRJI2fAqykhIvYFPgnMAL6QmR/smr8tcBIwq6Y5MjPPXNX1bPryeTdw1BmXc8x+u/C6p8+ZzKpoBXzq7Gs4+6rbl2uZLx60xwTVRm1j+yBNLQa8mnQRMQM4Fng+sAi4MCLmZ+YVjWT/CJyWmZ+NiJ2BM4E5q7yyDUedcfmf/n770lv7ph2mh3B5LpDDph11ujbp9OxuuM5Mdt5yo57prrh1CUsfeGhgT/DquE9G3Us+Ees8Wftl1O3DsP7pvy7niluWsPNWG/H+F++y0vlJbWHAq6lgT2BhZl4HEBGnAPsBzYA3gU5UsjFwy0RVZkUuuhdcf9fANGdfdTt7bb/pwDyOOuPygeUOezEdNs/luTiP0hW3Lhl5nsu7/3beciNOfcPTe87f/7jzhtq/zW04im097L6bzC9Ko+4ln4ggcSLPlVG2D9B/2wy7T664ZcnQ5UmrEwNeTQVbAzc1Pi8C9upKczTwvYh4M7A+8LzxMoqIQ4FDAbbddtsVqsywF7R11lyDB/7wMMBQgWz3+1EZdZ6TcbHcYO3hmqIrbl3C/sed1zdNM3AZJsCZCIPqOMo6LE+QOOqgrtmzO8w5cPZVt4902wz6ErkiecLw+2/YdKPYNsMe1xPxJVJqAwNeTRevBk7MzI9GxNOBr0TErpn5cDNRZh4PHA8wd+7cXNlC+12A1pxRAt69tt+0bw/hsLd9mxfjYS+kMNzFdN01Z/TNY9jgfSJssPZM3jJvp4FpAJY+8NByBYnDpB022F4ew9ZxFPtuRcqF5TvGBhl0Dhx84oV/6gke5bZZnvwmIs9h0s17wqP69tyuyLaZrONams48IzQV3AzMbnzepk5rOhjYFyAzz4uIdYDNgeW7n7qcRnFh2X32rKEedlqRC9+gi2nndvzMGTGS4H2yvLkGxMOMFf3Fort54A8Ps+6aM/izbTbum3aYYLtjmN7ljkFfGjrl7tbndvyw+255yl2RoK5f2cP2Ji7P/htm2yzP2OFR5znq42vYbTNRx7W0ujDg1VRwIbBTRGxPCXQPAP66K82NwDzgxIh4IrAOsHgiKrM8vZ2jvLAsT1AwbNnL2zM6VXuFhv3SMBGWdxsO+hIymeWuyN2GVfmlb1gTcTxM1jE2mce2tDqZmlc3rVYy86GIOAw4i/KTYydk5uURcQywIDPnA28HPh8Rb6M8wHZQZq70kIXx7LbNLC64/q5V3ts5ERe+FelZ01iTtQ0notxhj7Hl/fUFjxtJU11MUMwgTbq5c+fmggULlnu5zq3kqXp7X5ImUkRclJlzJ7se0ij5r4UlSZLUaga8kiRJajUDXkmSJLWaAa8kSZJazYBXkiRJrWbAK0mSpFYz4JUkSVKrGfBKkiSp1Qx4JUmS1GoGvJIkSWo1A15JkiS1mgGvJEmSWs2AV5IkSa1mwCtJkqRWM+CVJElSqxnwSpIkqdUMeCVJktRqBrySJElqNQNeSZIktZoBryRJklrNgFeSJEmtZsArSZKkVjPglSRJUqsZ8EqSJKnVDHglSZLUaga8kiRJajUDXkmSJLWaAa8kSZJazYBXkiRJrWbAK0mSpFYz4JUkSVKrGfBKkiSp1Qx4JUmS1GoGvJIkSWo1A15JkiS1mgGvJEmSWs2AV5IkSa1mwKspISL2jYirI2JhRBzZI82rIuKKiLg8Ir62qusoSZKmp5mTXQEpImYAxwLPBxYBF0bE/My8opFmJ+A9wDMz87cR8ajJqa0kSZpu7OHVVLAnsDAzr8vMB4FTgP260vwdcGxm/hYgM29fxXWUJEnTlAGvpoKtgZsanxfVaU2PAx4XET+JiPMjYt/xMoqIQyNiQUQsWLx48QRVV5IkTScGvJouZgI7AXsDrwY+HxGzuhNl5vGZOTcz526xxRartoaSJGlKMuDVVHAzMLvxeZs6rWkRMD8z/5CZ1wO/ogTAkiRJfRnwaiq4ENgpIraPiLWAA4D5XWm+RendJSI2pwxxuG4V1lGSJE1TBryadJn5EHAYcBZwJXBaZl4eEcdExEtqsrOAOyPiCuCHwDsz887JqbEkSZpO/FkyTQmZeSZwZte0oxrvEziiviRJkoZmD68kSZJazYBXkiRJrWbAK0mSpFYz4JUkSVKrGfBKkiSp1Qx4JUmS1GoGvJIkSWo1A15JkiS1mgGvJEmSWs2AV5IkSa1mwCtJkqRWM+CVJElSqxnwSpIkqdUMeCVJktRqBrySJElqNQNeSZIktZoBryRJklpt5mRXQO0QEUcMkey+zDxuwisjSZLUYA+vRuWdwAbAhn1eb5+02kmSpNWWPbwala9k5jH9EkTE+quqMpIkSR328GokMvNdo0gjSZI0aga8GqmIODwiNoriixFxcUS8YLLrJUmSVl8GvBq112fmEuAFwCbAa4EPTm6VJEnS6syAV6MW9e+LKON6L29MkyRJWuUMeDVqF0XE9ygB71kRsSHw8CTXSZIkrcb8lQaN2sHA7sB1mXl/RGwG/O3kVkmSJK3O7OHVSETEYwAy8+HMvDgz766f78zMS5tpJEmSViUDXo3KmSNKI0mSNFIOadCo7BYRS/rMD6DffEmSpAlhwKuRyMwZk10HSZKk8TikQZIkSa1mwCtJkqRWM+DVSESEw2MkSdKUZMCrUfnZZFdAkiRpPAa8GhX/fbAkSZqSvA2tUdkiIo7oNTMzP7YqKyNJktRhD69GZQawAbBhj1dfEbFvRFwdEQsj4sg+6f4qIjIi5o6o3pIkqeXs4dWo3JqZx6zIghExAzgWeD6wCLgwIuZn5hVd6TYEDgcuWNnKSpKk1Yc9vBqVOSux7J7Awsy8LjMfBE4B9hsn3T8DHwIeWImyJEnSasaAV6OyaCWW3Rq4qSuvrZsJIuIpwOzM/PZKlCNJklZDBrwalYcmKuOIWAP4GPD2IdIeGhELImLB4sWLJ6pKkiRpGnEMr0Zlm4j4914zM/MtfZa9GZjdzKtO69gQ2BU4JyIAHgPMj4iXZOaCrnKOB44HmDt3bi7XGkiSpFYy4NWo/A64aAWXvRDYKSK2pwS6BwB/3ZmZmfcAm3c+R8Q5wDu6g11JkqTxGPBqVO7MzJNWZMHMfCgiDgPOovy82QmZeXlEHAMsyMz5o6yoJElavRjwalQeHG9iHX/76sw8ud/CmXkmcGbXtKN6pN17BesoSZJWQz60plHZJyLeExGfjogXRPFm4DrgVZNdOUmStPqyh1ej8mXgt8B5wCHAe4EAXpqZl0xivSRJ0mrOgFej8tjMfBJARHwBuBXYNjP9JxGSJGlSOaRBo/KHzpvM/COwyGBXkiRNBfbwalR2i4gl9X0A69bPAWRmbjR5VZMkSaszA16NRGbOmOw6SJIkjcchDZIkSWo1A15JkiS1mgGvJEmSWs2AV5IkSa1mwCtJkqRWM+CVJElSqxnwSpIkqdUMeCVJktRqBrySJElqNQNeSZIktZoBryRJklrNgFeSJEmtZsArSZKkVjPglSRJUqsZ8EqSJKnVDHglSZLUaga8kiRJajUDXkmSJLWaAa8kSZJazYBXkiRJrWbAK0mSpFYz4JUkSVKrGfBKkiSp1Qx4JUmS1GoGvJIkSWo1A15JkiS1mgGvJEmSWs2AV5IkSa1mwCtJkqRWM+CVJElSqxnwSpIkqdUMeDUlRMS+EXF1RCyMiCPHmX9ERFwREZdGxNkRsd1k1FOSJE0/BryadBExAzgWeCGwM/DqiNi5K9nPgbmZ+WfA6cCHV20tJUnSdGXAq6lgT2BhZl6XmQ8CpwD7NRNk5g8z8/768Xxgm1VcR0mSNE0Z8Goq2Bq4qfF5UZ3Wy8HAd8abERGHRsSCiFiwePHiEVZRkiRNVwa8mlYi4jXAXOAj483PzOMzc25mzt1iiy1WbeUkSdKUNHOyKyABNwOzG5+3qdPGiIjnAe8DnpOZv19FdZMkSdOcPbyaCi4EdoqI7SNiLeAAYH4zQUQ8GTgOeElm3j4JdZQkSdOUAa8mXWY+BBwGnAVcCZyWmZdHxDER8ZKa7CPABsA3IuKSiJjfIztJkqQxHNKgKSEzzwTO7Jp2VOP981Z5pSRJUivYwytJkqRWM+CVJElSqxnwSpIkqdUMeCVJktRqBrySJElqNQNeSZIktZoBryRJklrNgFeSJEmtZsArSZKkVjPglSRJUqsZ8EqSJKnVDHglSZLUaga8kiRJajUDXkmSJLWaAa8kSZJazYBXkiRJrWbAK0mSpFYz4JUkSVKrGfBKkiSp1Qx4JUmS1GoGvJIkSWo1A15JkiS1mgGvJEmSWs2AV5IkSa1mwCtJkqRWM+CVJElSqxnwSpIkqdUMeCVJktRqBrySJElqNQNeSZIktZoBryRJklrNgFeSJEmtZsArSZKkVjPglSRJUqsZ8EqSJKnVDHglSZLUaga8kiRJajUDXk0JEbFvRFwdEQsj4shx5q8dEafW+RdExJxJqKYkSZqGDHg16SJiBnAs8EJgZ+DVEbFzV7KDgd9m5o7Ax4EPrdpaSpKk6cqAV1PBnsDCzLwuMx8ETgH260qzH3BSfX86MC8iYhXWUZIkTVMGvJoKtgZuanxeVKeNmyYzHwLuATbrzigiDo2IBRGxYPHixRNUXUmSNJ3MnOwKSKOUmccDxwPMnTs3VySPnbfaaMxfSZI0vRnwaiq4GZjd+LxNnTZemkURMRPYGLhzIirz/hfvMhHZSpKkSeKQBk0FFwI7RcT2EbEWcAAwvyvNfODA+v4VwA8yc4V6cCVJ0urFHl5Nusx8KCIOA84CZgAnZOblEXEMsCAz5wNfBL4SEQuBuyhBsSRJ0kAGvJoSMvNM4MyuaUc13j8AvHJV10uSJE1/DmmQJElSqxnwSpIkqdUMeCVJktRqBrySJElqtfCXndRWEbEY+PUQSTcH7pjg6qwKbVkPcF2mqrasS1vWAyZmXbbLzC1GnKc0qQx4tdqLiAWZOXey67Gy2rIe4LpMVW1Zl7asB7RrXaSJ5JAGSZIktZoBryRJklrNgFeC4ye7AiPSlvUA12Wqasu6tGU9oF3rIk0Yx/BKkiSp1ezhlSRJUqsZ8EqSJKnVDHg1rUXErIg4PSKuiogrI+LpEXF0RNwcEZfU14sa6d8TEQsj4uqI2Kcxfd86bWFEHNmYvn1EXFCnnxoRa9Xpa9fPC+v8OSuxDo9v1PWSiFgSEW+NiE0j4vsRcU39u0lNHxHx77XsSyPiKY28Dqzpr4mIAxvTnxoRv6zL/HtERJ0+bhkTsC7Tap80ynpbRFweEZdFxNcjYp0VKX9U6zji9TgxIq5v7JPda9ope3zVPA+v63F5RLy1XznTdF2m5bkiTXmZ6cvXtH0BJwGH1PdrAbOAo4F3jJN2Z+AXwNrA9sC1wIz6uhZ4bM3jF8DOdZnTgAPq+88Bf1/fvwn4XH1/AHDqiNZnBnAbsB3wYeDIOv1I4EP1/YuA7wABPA24oE7fFLiu/t2kvt+kzvtZTRt12RfW6eOWMQHrMu32CbA1cD2wbqPcg5a3/FGu44jX40TgFeOkn7LHF7ArcBmwHjAT+B9gx17lTNN1OZppdq748jUdXvbwatqKiI2BZwNfBMjMBzPz7j6L7Aeckpm/z8zrgYXAnvW1MDOvy8wHgVOA/WrPznOB0+vyJwEvbeR1Un1/OjCv0xO0kuYB12bmr7vK6C77y1mcD8yKiC2BfYDvZ+Zdmflb4PvAvnXeRpl5fmYm8OUe69EsYxSa69LLVN8nM4F1I2ImJTC5dQXKH+U6jmo9bumTdiofX0+kBK33Z+ZDwI+Al/cpZzquSy9T/VyRpjQDXk1n2wOLgS9FxM8j4gsRsX6dd1i9hXlC49bj1sBNjeUX1Wm9pm8G3F0vRs3pY/Kq8++p6VfWAcDX6/tHZ+at9f1twKNXcD22ru+7p/crYxSa6wLTbJ9k5s3AvwE3UgLde4CLVqD8Ua7jSNYjM79XZ/9r3Scfj4i1u9djyPquyuPrMuBZEbFZRKxH6cGd3aec6bguMM3OFWk6MODVdDYTeArw2cx8MnAf5VbjZ4EdgN0pF/iPTlYFl0cdX/cS4Bvd82pv04T+huAoyxhnXabdPqmBxn6UL1ZbAesD+05qpVbAeOsREa8B3gM8AdiDcmv/3RNZj1EcX5l5JfAh4HvAd4FLgD+Oupwh6jGR6zLtzhVpOjDg1XS2CFiUmRfUz6cDT8nM32TmHzPzYeDzlFt+ADezrAcFYJs6rdf0Oym3QGd2TR+TV52/cU2/Ml4IXJyZv6mff1NvsVL/3r6C63Fzfd89vV8ZK2vMukzTffI84PrMXJyZfwC+CTxzBcof5TqOaj2ekZm31lv9vwe+xIrvk1V6fGXmFzPzqZn5bOC3wK/6lDPt1mWanivSlGfAq2krM28DboqIx9dJ84ArOhel6mWUW4cA84ED6hPK2wM7UR5QuRDYqT7RvBblVvz82ovzQ+AVdfkDgTMaeXWe7H4F8IOafmW8mrFDAJpldJf9uvoE+tMot6hvBc4CXhARm9RevRcAZ9V5SyLiaXWc3ut6rEezjJU1Zl2m6T65EXhaRKxXt9s84IoVKH+U6ziq9biyEbwFZWxnc59M2eMrIh5V/25LGfP6tT7lTLt1mabnijT15RR4cs6XrxV9UW77LQAuBb5FeeL6K8Av67T5wJaN9O+jPNF8NfXp6zr9RZSeomuB9zWmP5ZyUVlIuT2/dp2+Tv28sM5/7Equx/qUHpaNG9M2A84GrqE8wb1pnR7AsbWuvwTmNpZ5fa3TQuBvG9PnUi6c1wKfZtl/WRy3jAlYl2m3T2qe/wRcVbfdVyhPyC93+aNaxxGvxw/qPrkM+CqwwTQ5vn5M+eLxC2DeND9XxluXaXmu+PI11V/+a2FJkiS1mkMaJEmS1GoGvJIkSWo1A15JkiS1mgGvJEmSWs2AV5I0pUXEKyPi8oh4OCLm9kk3KyJOj4irIuLKiHh6nX50RNwcEZfU14u6lts2Iu6NiHc0pr2tlnlZRHw9Itap07ePiAsiYmFEnFp/CoyIeGNE/LLm/78RsXMjr/fU9FdHxD6N6fvWaQsj4sjG9F5lrF0/L6zz5wyx7b4bEXdHxH93TT+5ln1ZlP/otuagvKTpzIBX0mqtBklvqu+3iojTJ7Cs3buDLY0VEXtHxIldky+j/E7tuQMW/yTw3cx8ArAbcGVj3sczc/f6OrNruY8B32nUYWvgLZSfMdsVmEH5fVso/x3t45m5I+WfRRxcp38tM5+UmbsDH655UgPfA4BdKP+p7zMRMSMiZlB+Mu2FwM7AqxtBcq8yDgZ+W6d/vKYb5CPAa8eZfjLlP+09CVgXOGSIvKRpy4BX0upuFvAmgMy8JTNf0T/5Stmd8pupWg6ZeWVmXt0vTURsDDwb+GJd5sHMvHtQ3hHxUuB64PKuWTOBdaP8J7L1gFvqP6N4LuW/OgKcRPmnHWTmksay67PsXw/vB5ySmb/PzOspv327Z30tzMzrMvNB4BRgv35l1LxOqu9PB+bVf6oxIyI+EhEXRsSlEfGGTkUy82xgafd6Z+aZWVF+i3eb7jRSmxjwSlrdfRDYod6K/kZEXAYQEQdFxLci4vsRcUNEHBYRR0TEzyPi/IjYtKbbod42vigifhwRT6jTX1lvF/8iIs6tt6WPAfavZe0fEXtGxHk1z59G/a+By1H2ORHxyZrfZRGxZ53+nMbt+59HxIaTsF1Xte2BxcCX6jp/ISLWb8w/rAaDJ0T572pExAbAuyn/mONPMvNm4N8o/6XuVsp/aPse5Z9P3J2ZD9Wki4CtO8tFxD9ExLWUHt631MlbAzc1su8s02t6vzL+tEydf09Nf3Ct4x7AHsDfRflvbAPVoQyvBb47THppujLglbS6OxK4tt6KfmfXvF0pt9L3AP4VuD8znwycR/m3swDHA2/OzKcC7wA+U6cfBeyTmbsBL6m9eEcBp9bb6qdS/vvZs2qeRwEfWM6yAdardX8TcEKd9g7gH+r0ZwG/W4HtskrVMamXAF8AXtII2PcZsGjHTOApwGfrdrqPsm8BPgvsQOlhvxX4aJ1+NGXowL1dddmE0pu6PbAVsH5EvGZQBTLz2MzcgRJE/+OQ9R6FF1D+hfIlwAWUIHinIZf9DHBuZv54guomTQkzJ7sCkjSF/TAzlwJLI+Ie4L/q9F8Cf1Z7CJ8BfKPciQbKv+0F+AlwYkScBnyzR/4bAydFxE6UW+DNB4f6lt1I93WAzDw3IjaKiFm17I9FxMnANzNz0Qqs+yqVmXtBGcMLHJSZBy1nFouARZl5Qf18OjXgzczfdBJFxOeBzgNcewGviIgPU4a2PBwRDwC/Aa7PzMV1mW9S9vPJwKyImFl7WLcBbh6nLqdQgmzq/NmNec1lxpt+Z58yOnktqkMtNq7pg/Kl66xBG6kpIt4PbAG8YVBaabqzh1eSevt94/3Djc8PUzoM1qDcft698XoiQGa+kdLLNxu4KCI2Gyf/f6YEtrsCLwbWWY6yO7r/P3xm5gcpDyGtC/ykM8yizTLzNuCmzrAQYB5wBUBEbNlI+jLKQ3Bk5rMyc05mzgE+AXwgMz9NGcrwtIhYr46pnQdcWce7/hDojPM+EDijltHsUf1L4Jr6fj5wQJRfWNie0vP6M+BCYKcov8iwFuXBtvn9yqh5HVjfvwL4QU1/FvD3dXgCEfG4ruEcjxARhwD7AK/OzIf7pZXawIBX0upuKbBCY1zrg0rXR8QrAeoDRLvV9ztk5gWZeRRlbOnsccramGW9dwetWPXZv5b355RxnPfUsn+ZmR+iBFbTOuCNiJdFxCLg6cC3I+KsOn2riGj+4sKbgZMj4lLK8IXOEJEPR/nJsEuBvwDe1q+82kt8OnAxpUd9DcrQFSjDFY6IiIWUoQNfrNMPi/IzZpcAR1AD08y8HDiNEnx/lzLU5I+19/YwSrB6JXBaTduvjC8Cm9XpR7BsyMYXav4X1zHox1G/FEXEj4FvUB5wW9QYIvI54NHAeXXoyFH9tok03UX5cihJq6+I+BplmMCVwBMzc9eIOIjys1SH1TQ31M93NOfVXrvPAltShiSckpnH1NvgO1FuN58NvBXYhBLgrAn8P0pP4kmU8abfBl6TmXOWo+xzgEuA59Q8X5+ZP4uIT1ECu4cpvz5wUGY2e4wlabViwCtJ01QNeN+RmQsmuy6SNJU5pEGSJEmtZg+vJEmSWs0eXkmSJLWaAa8kSZJazYBXkiRJrWbAK0mSpFYz4JUkSVKr/X+H1Lk/6i4axAAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -390,7 +440,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -404,7 +454,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.10" + "version": "3.10.5" } }, "nbformat": 4, diff --git a/my-webrtc-app/Dockerfile.alpine b/my-webrtc-app/Dockerfile.alpine deleted file mode 100644 index fae3a58..0000000 --- a/my-webrtc-app/Dockerfile.alpine +++ /dev/null @@ -1,19 +0,0 @@ -FROM node:alpine -# FROM ubuntu:jammy-20220531 -USER root - -ENV TZ=Europe/Helsinki - -WORKDIR /app - -COPY package.json ./ - -COPY ./ ./ - -RUN npm install - -RUN npm install typescript -g -RUN npm install webpack webpack-cli --save-dev -RUN npm run prod-compile - -CMD ["npm", "run", "start"] \ No newline at end of file