-
Notifications
You must be signed in to change notification settings - Fork 9
/
_functions_jitsi.sh
294 lines (273 loc) · 14.1 KB
/
_functions_jitsi.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
#!/bin/bash -eu
# Don't load it several times
set +u
${_FUNCTIONS_JITSI_LOADED:-false} && return
set -u
# if the script was started from the base directory, then the
# expansion returns a period
if test "${SCRIPT_DIR}" == "."; then
SCRIPT_DIR="$PWD"
# if the script was not called with an absolute path, then we need to add the
# current working directory to the relative path of the script
elif test "${SCRIPT_DIR:0:1}" != "/"; then
SCRIPT_DIR="$PWD/${SCRIPT_DIR}"
fi
do_get_jitsi_settings() {
if [ "${DEPLOYMENT_JITSI_ENABLED}" == "false" ]; then
return;
fi
env_var DEPLOYMENT_JITSI_CALL_CONTAINER_NAME "${INSTANCE_KEY}_jitsi_call"
env_var DEPLOYMENT_JITSI_WEB_CONTAINER_NAME "${INSTANCE_KEY}_jitsi_web"
env_var DEPLOYMENT_JITSI_PROSODY_CONTAINER_NAME "${INSTANCE_KEY}_jitsi_prosody"
env_var DEPLOYMENT_JITSI_JICOFO_CONTAINER_NAME "${INSTANCE_KEY}_jitsi_jicofo"
env_var DEPLOYMENT_JITSI_JVB_CONTAINER_NAME "${INSTANCE_KEY}_jitsi_jvb"
env_var DEPLOYMENT_JITSI_JIBRI_CONTAINER_NAME "${INSTANCE_KEY}_jitsi_jibri"
env_var DEPLOYMENT_JITSI_EXCALIDRAW_BACKEND_CONTAINER_NAME "${INSTANCE_KEY}_jitsi_excalidraw_backend"
env_var DEPLOYMENT_JITSI_NETWORK_NAME "$(tolower "${INSTANCE_KEY}").jitsi"
}
#
# Drops all Jitsi data used by the instance.
#
do_drop_jitsi_data() {
echo_info "Dropping Jitsi data ..."
if ${DEPLOYMENT_JITSI_ENABLED}; then
echo_info "Drops Jitsi docker network ${DEPLOYMENT_JITSI_NETWORK_NAME} ..."
delete_docker_network ${DEPLOYMENT_JITSI_NETWORK_NAME}
echo_info "Drops Jitsi call container ${DEPLOYMENT_JITSI_CALL_CONTAINER_NAME} ..."
delete_docker_container ${DEPLOYMENT_JITSI_CALL_CONTAINER_NAME}
echo_info "Drops Jitsi web container ${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME} ..."
delete_docker_container ${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME}
echo_info "Drops Jitsi prosody container ${DEPLOYMENT_JITSI_PROSODY_CONTAINER_NAME} ..."
delete_docker_container ${DEPLOYMENT_JITSI_PROSODY_CONTAINER_NAME}
echo_info "Drops Jitsi jicofo container ${DEPLOYMENT_JITSI_JICOFO_CONTAINER_NAME} ..."
delete_docker_container ${DEPLOYMENT_JITSI_JICOFO_CONTAINER_NAME}
echo_info "Drops Jitsi jvb container ${DEPLOYMENT_JITSI_JVB_CONTAINER_NAME} ..."
delete_docker_container ${DEPLOYMENT_JITSI_JVB_CONTAINER_NAME}
echo_info "Drops Jitsi jibri container ${DEPLOYMENT_JITSI_JIBRI_CONTAINER_NAME} ..."
delete_docker_container ${DEPLOYMENT_JITSI_JIBRI_CONTAINER_NAME}
echo_info "Drops Jitsi excalidraw brackend container ${DEPLOYMENT_JITSI_EXCALIDRAW_BACKEND_CONTAINER_NAME} ..."
delete_docker_container ${DEPLOYMENT_JITSI_EXCALIDRAW_BACKEND_CONTAINER_NAME}
echo_info "Done."
echo_info "Jitsi data dropped"
else
echo_info "Skip Drops Jitsi container ..."
fi
}
do_create_jitsi() {
if ${DEPLOYMENT_JITSI_ENABLED}; then
echo_info "Creation of the Jitsi Docker network ${DEPLOYMENT_JITSI_NETWORK_NAME} ..."
create_docker_network ${DEPLOYMENT_JITSI_NETWORK_NAME}
fi
}
do_stop_jitsi() {
echo_info "Stopping Jitsi ..."
if [ "${DEPLOYMENT_JITSI_ENABLED}" == "false" ]; then
echo_info "Jitsi wasn't specified, skiping its containers shutdown"
return
fi
ensure_docker_container_stopped ${DEPLOYMENT_JITSI_CALL_CONTAINER_NAME}
echo_info "Jitsi container ${DEPLOYMENT_JITSI_CALL_CONTAINER_NAME} stopped."
ensure_docker_container_stopped ${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME}
echo_info "Jitsi container ${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME} stopped."
ensure_docker_container_stopped ${DEPLOYMENT_JITSI_PROSODY_CONTAINER_NAME}
echo_info "Jitsi container ${DEPLOYMENT_JITSI_PROSODY_CONTAINER_NAME} stopped."
ensure_docker_container_stopped ${DEPLOYMENT_JITSI_JICOFO_CONTAINER_NAME}
echo_info "Jitsi container ${DEPLOYMENT_JITSI_JICOFO_CONTAINER_NAME} stopped."
ensure_docker_container_stopped ${DEPLOYMENT_JITSI_JVB_CONTAINER_NAME}
echo_info "Jitsi container ${DEPLOYMENT_JITSI_JVB_CONTAINER_NAME} stopped."
ensure_docker_container_stopped ${DEPLOYMENT_JITSI_JIBRI_CONTAINER_NAME}
echo_info "Jitsi container ${DEPLOYMENT_JITSI_JIBRI_CONTAINER_NAME} stopped."
ensure_docker_container_stopped ${DEPLOYMENT_JITSI_EXCALIDRAW_BACKEND_CONTAINER_NAME}
echo_info "Jitsi container ${DEPLOYMENT_JITSI_EXCALIDRAW_BACKEND_CONTAINER_NAME} stopped."
echo_info "Done."
}
do_start_jitsi() {
echo_info "Starting Jitsi..."
if [ "${DEPLOYMENT_JITSI_ENABLED}" == "false" ]; then
echo_info "Jitsi not specified, skiping its containers startup"
return
fi
# TL;DR: export All envrionment variables included on this template
jitsi_major_version=$(echo ${DEPLOYMENT_JITSI_IMAGE_VERSION} | grep -oP [0-9] | head -n 1)
[[ "${jitsi_major_version:-}" =~ ^[7-9]$ ]] || jitsi_major_version="9" # latest version
export DEPLOYMENT_URL DEPLOYMENT_JITSI_NETWORK_NAME DEPLOYMENT_JITSI_JVB_PORT jitsi_major_version
evaluate_file_content ${ETC_DIR}/jitsi/jitsi${jitsi_major_version}x.env.template ${DEPLOYMENT_DIR}/jitsi.env
echo_info "Starting Jitsi call container ${DEPLOYMENT_JITSI_CALL_CONTAINER_NAME} based on image ${DEPLOYMENT_JITSI_IMAGE}:${DEPLOYMENT_JITSI_CALL_IMAGE_VERSION:-latest}"
# Ensure there is no container with the same name
delete_docker_container ${DEPLOYMENT_JITSI_CALL_CONTAINER_NAME}
create_docker_network ${DEPLOYMENT_JITSI_NETWORK_NAME}
${DOCKER_CMD} pull ${DEPLOYMENT_JITSI_IMAGE}:${DEPLOYMENT_JITSI_CALL_IMAGE_VERSION:-latest}
${DOCKER_CMD} run \
-d \
-p "${DEPLOYMENT_JITSI_CALL_HTTP_PORT}:80" \
--env-file ${DEPLOYMENT_DIR}/jitsi.env \
--network "${DEPLOYMENT_JITSI_NETWORK_NAME}" \
--memory "${DEPLOYMENT_JITSI_MEM_LIMIT}" \
--name ${DEPLOYMENT_JITSI_CALL_CONTAINER_NAME} ${DEPLOYMENT_JITSI_IMAGE}:${DEPLOYMENT_JITSI_CALL_IMAGE_VERSION:-latest}
echo_info "${DEPLOYMENT_JITSI_CALL_CONTAINER_NAME} container started"
check_jitsi_call_availability
echo_info "Starting Jitsi prosody container ${DEPLOYMENT_JITSI_PROSODY_CONTAINER_NAME} based on image jitsi/prosody:${DEPLOYMENT_JITSI_IMAGE_VERSION}"
# Ensure there is no container with the same name
delete_docker_container ${DEPLOYMENT_JITSI_PROSODY_CONTAINER_NAME}
cp -v ${ETC_DIR}/jitsi/algorithm.cfg.lua ${DEPLOYMENT_DIR}/algorithm.cfg.lua
${DOCKER_CMD} run \
-d \
-v ${DEPLOYMENT_DIR}/algorithm.cfg.lua:/config/config.d/algorithm.cfg.lua:ro \
--env-file ${DEPLOYMENT_DIR}/jitsi.env \
--network "${DEPLOYMENT_JITSI_NETWORK_NAME}" \
--network-alias "xmpp.${DEPLOYMENT_JITSI_NETWORK_NAME}" \
--restart unless-stopped \
-h "jitsi-prosody" \
--health-cmd="timeout 2 /bin/bash -c '</dev/tcp/jitsi-prosody/5222' && timeout 2 /bin/bash -c '</dev/tcp/jitsi-prosody/5280' || exit 1" \
--health-interval=30s \
--health-timeout=30s \
--health-retries=3 \
--name ${DEPLOYMENT_JITSI_PROSODY_CONTAINER_NAME} jitsi/prosody:${DEPLOYMENT_JITSI_IMAGE_VERSION}
echo_info "${DEPLOYMENT_JITSI_PROSODY_CONTAINER_NAME} container started"
echo_info "Starting Jitsi Jicofo container ${DEPLOYMENT_JITSI_JICOFO_CONTAINER_NAME} based on image jitsi/jicofo:${DEPLOYMENT_JITSI_IMAGE_VERSION}"
# Ensure there is no container with the same name
delete_docker_container ${DEPLOYMENT_JITSI_JICOFO_CONTAINER_NAME}
${DOCKER_CMD} run \
-d \
-e JICOFO_MAX_MEMORY="${DEPLOYMENT_JITSI_JICOFO_XMX}" \
--env-file ${DEPLOYMENT_DIR}/jitsi.env \
--network "${DEPLOYMENT_JITSI_NETWORK_NAME}" \
--restart unless-stopped \
--health-cmd="wget -qO /dev/null http://127.0.0.1:8888/about/health?list_jvb=true || exit 1" \
--health-interval=30s \
--health-timeout=30s \
--health-retries=3 \
--name ${DEPLOYMENT_JITSI_JICOFO_CONTAINER_NAME} jitsi/jicofo:"${DEPLOYMENT_JITSI_IMAGE_VERSION}"
echo_info "${DEPLOYMENT_JITSI_JICOFO_CONTAINER_NAME} container started"
echo_info "Starting Jitsi JVB container ${DEPLOYMENT_JITSI_JVB_CONTAINER_NAME} based on image jitsi/jvb:${DEPLOYMENT_JITSI_IMAGE_VERSION}"
# Ensure there is no container with the same name
delete_docker_container ${DEPLOYMENT_JITSI_JVB_CONTAINER_NAME}
${DOCKER_CMD} run \
-d \
-p "${DEPLOYMENT_JITSI_JVB_PORT}:${DEPLOYMENT_JITSI_JVB_PORT}/udp" \
-p "${DEPLOYMENT_JITSI_JVB_COLIBRI_PORT}:9090" \
-e VIDEOBRIDGE_MAX_MEMORY="${DEPLOYMENT_JITSI_JVB_XMX}" \
--env-file ${DEPLOYMENT_DIR}/jitsi.env \
--network "${DEPLOYMENT_JITSI_NETWORK_NAME}" \
--network-alias "jvb.${DEPLOYMENT_JITSI_NETWORK_NAME}" \
--restart unless-stopped \
--health-cmd="curl --silent --fail http://127.0.0.1:8080/about/health || exit 1" \
--health-interval=30s \
--health-timeout=30s \
--health-retries=3 \
--name ${DEPLOYMENT_JITSI_JVB_CONTAINER_NAME} jitsi/jvb:"${DEPLOYMENT_JITSI_IMAGE_VERSION}"
echo_info "${DEPLOYMENT_JITSI_JVB_CONTAINER_NAME} container started"
echo_info "Starting Jitsi Jibri container ${DEPLOYMENT_JITSI_JIBRI_CONTAINER_NAME} based on image jitsi/jibri:${DEPLOYMENT_JITSI_IMAGE_VERSION}"
# Ensure there is no container with the same name
delete_docker_container ${DEPLOYMENT_JITSI_JIBRI_CONTAINER_NAME}
cp -v ${ETC_DIR}/jitsi/finalize.sh ${DEPLOYMENT_DIR}/finalize.sh
chmod +x ${DEPLOYMENT_DIR}/finalize.sh
evaluate_file_content ${ETC_DIR}/jitsi/jibri/jibri.conf.j2 ${DEPLOYMENT_DIR}/jibri.conf
${DOCKER_CMD} run \
-d \
-v /dev/shm:/dev/shm \
-v ${DEPLOYMENT_DIR}/jibri.conf:/etc/jitsi/jibri/jibri.conf:ro \
-v ${DEPLOYMENT_DIR}/finalize.sh:/tmp/finalize.sh \
--memory "${DEPLOYMENT_JITSI_MEM_LIMIT}" \
--cap-add SYS_ADMIN \
--cap-add NET_BIND_SERVICE \
--device /dev/snd \
--shm-size=2gb \
--env-file ${DEPLOYMENT_DIR}/jitsi.env \
--network "${DEPLOYMENT_JITSI_NETWORK_NAME}" \
--restart unless-stopped \
--health-cmd="curl --silent --fail http://127.0.0.1:2222/jibri/api/v1.0/health | jq -e '.status.health.healthStatus == \"HEALTHY\"' || exit 1" \
--health-interval=30s \
--health-timeout=30s \
--health-retries=3 \
--name ${DEPLOYMENT_JITSI_JIBRI_CONTAINER_NAME} jitsi/jibri:"${DEPLOYMENT_JITSI_IMAGE_VERSION}"
echo_info "${DEPLOYMENT_JITSI_JVB_CONTAINER_NAME} container started"
echo_info "Starting Jitsi Web container ${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME} based on image exoplatform/jitsi-web:${DEPLOYMENT_JITSI_IMAGE_VERSION}"
# Ensure there is no container with the same name
delete_docker_container ${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME}
${DOCKER_CMD} run \
-d \
-p "${DEPLOYMENT_JITSI_WEB_HTTP_PORT}:80" \
-p "${DEPLOYMENT_JITSI_WEB_HTTPS_PORT}:443" \
--env-file ${DEPLOYMENT_DIR}/jitsi.env \
--network "${DEPLOYMENT_JITSI_NETWORK_NAME}" \
--network-alias "${DEPLOYMENT_JITSI_NETWORK_NAME}" \
--restart unless-stopped \
--health-cmd="wget -qO /dev/null 127.0.0.1 || exit 1" \
--health-interval=30s \
--health-timeout=30s \
--health-retries=3 \
--name ${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME} exoplatform/jitsi-web:"${DEPLOYMENT_JITSI_IMAGE_VERSION}"
echo_info "${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME} container started"
check_jitsi_web_availability
${DOCKER_CMD} exec ${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME} bash -c "echo \"interfaceConfig['DEFAULT_LOGO_URL'] = '${DEPLOYMENT_URL}/jitsicall/images/logo.png';\" >> \"/config/interface_config.js\""
${DOCKER_CMD} exec ${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME} bash -c "echo \"interfaceConfig['JITSI_WATERMARK_LINK'] = '';\" >> \"/config/interface_config.js\""
${DOCKER_CMD} exec ${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME} bash -c "rm -fv /usr/share/jitsi-meet/sounds/recordingOff.mp3 /usr/share/jitsi-meet/sounds/recordingOn.mp3"
echo_info "Starting Jitsi excalidraw backend container ${DEPLOYMENT_JITSI_EXCALIDRAW_BACKEND_CONTAINER_NAME} based on image exoplatform/exo-excalidraw-backend:${DEPLOYMENT_JITSI_EXCALIDRAW_BACKEND_IMAGE_VERSION}"
delete_docker_container ${DEPLOYMENT_JITSI_EXCALIDRAW_BACKEND_CONTAINER_NAME}
${DOCKER_CMD} run \
-d \
-p "${DEPLOYMENT_JITSI_EXCALIDRAW_BACKEND_PORT}:80" \
--network "${DEPLOYMENT_JITSI_NETWORK_NAME}" \
--network-alias "${DEPLOYMENT_JITSI_NETWORK_NAME}" \
--restart unless-stopped \
-h "jitsi-excalidraw-backend" \
--health-cmd='wget -qO- http://jitsi-excalidraw-backend &> /dev/null || exit 1' \
--health-interval=30s \
--health-timeout=30s \
--health-retries=3 \
--name ${DEPLOYMENT_JITSI_EXCALIDRAW_BACKEND_CONTAINER_NAME} exoplatform/exo-excalidraw-backend:"${DEPLOYMENT_JITSI_EXCALIDRAW_BACKEND_IMAGE_VERSION}"
echo_info "${DEPLOYMENT_JITSI_EXCALIDRAW_BACKEND_CONTAINER_NAME} container started"
}
check_jitsi_call_availability() {
echo_info "Waiting for Jitsi Call availability on port ${DEPLOYMENT_JITSI_CALL_HTTP_PORT}"
local count=0
local try=600
local wait_time=1
local RET=-1
while [ $count -lt $try -a $RET -ne 0 ]; do
count=$(( $count + 1 ))
set +e
curl -s -q --max-time ${wait_time} http://localhost:${DEPLOYMENT_JITSI_CALL_HTTP_PORT} > /dev/null
RET=$?
if [ $RET -ne 0 ]; then
[ $(( ${count} % 10 )) -eq 0 ] && echo_info "Jitsi Call not yet available (${count} / ${try})..."
echo -n "."
sleep $wait_time
fi
set -e
done
if [ $count -eq $try ]; then
echo_error "Jitsi Call ${DEPLOYMENT_JITSI_CALL_CONTAINER_NAME} not available after $(( ${count} * ${wait_time}))s"
exit 1
fi
echo_info "Jitsi Call ${DEPLOYMENT_JITSI_CALL_CONTAINER_NAME} up and available"
}
check_jitsi_web_availability() {
echo_info "Waiting for Jitsi Web availability on port ${DEPLOYMENT_JITSI_WEB_HTTPS_PORT}"
local count=0
local try=600
local wait_time=1
local RET=-1
while [ $count -lt $try -a $RET -ne 0 ]; do
count=$(( $count + 1 ))
set +e
curl -s -q --max-time ${wait_time} http://localhost:${DEPLOYMENT_JITSI_WEB_HTTP_PORT} > /dev/null
RET=$?
if [ $RET -ne 0 ]; then
[ $(( ${count} % 10 )) -eq 0 ] && echo_info "Jitsi Web not yet available (${count} / ${try})..."
echo -n "."
sleep $wait_time
fi
set -e
done
if [ $count -eq $try ]; then
echo_error "Jitsi Web ${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME} not available after $(( ${count} * ${wait_time}))s"
exit 1
fi
echo_info "Jitsi Web ${DEPLOYMENT_JITSI_WEB_CONTAINER_NAME} up and available"
}
# #############################################################################
# Env var to not load it several times
_FUNCTIONS_JITSI_LOADED=true
echo_debug "_function_jitsi.sh Loaded"