This repository has been archived by the owner on May 9, 2019. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 21
/
janus.cfg
175 lines (161 loc) · 8.55 KB
/
janus.cfg
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
; General configuration: folders where the configuration and the plugins
; can be found, how output should be logged, whether Janus should run as
; a daemon or in foreground, default interface to use, debug/logging level
; and, if needed, shared apisecret and/or token authentication mechanism
; between application(s) and Janus.
[general]
configs_folder = /opt/janus/etc/janus ; Configuration files folder
plugins_folder = /opt/janus/lib/janus/plugins ; Plugins folder
transports_folder = /opt/janus/lib/janus/transports ; Transports folder
;log_to_stdout = false ; Whether the Janus output should be written
; to stdout or not (default=true)
log_to_file = /var/log/janus.log ; Whether to use a log file or not
:daemonize = true ; Whether Janus should run as a daemon
; or not (default=run in foreground)
pid_file = /var/run/janus.pid ; PID file to create when Janus has been
; started, and to destroy at shutdown
;interface = 1.2.3.4 ; Interface to use (will be used in SDP)
debug_level = 4 ; Debug/logging level, valid values are 0-7
;debug_timestamps = yes ; Whether to show a timestamp for each log line
;debug_colors = no ; Whether colors should be disabled in the log
;api_secret = mattermost ; String that all Janus requests must contain
; to be accepted/authorized by the Janus core.
; Useful if you're wrapping all Janus API requests
; in your servers (that is, not in the browser,
; where you do the things your way) and you
; don't want other application to mess with
; this Janus instance.
token_auth = yes ; Enable a token based authentication
; mechanism to force users to always provide
; a valid token in all requests. Useful if
; you want to authenticate requests from web
; users. For this to work, the Admin API MUST
; be enabled, as tokens are added and removed
; through messages sent there.
admin_secret = janusoverlord ; String that all Janus requests must contain
; to be accepted/authorized by the admin/monitor.
; only needed if you enabled the admin API
; in any of the available transports.
server_name = MattermostWebRTC ; Public name of this Janus instance
; as it will appear in an info request
; Certificate and key to use for DTLS.
[certificates]
cert_pem = /opt/janus/certs/certificate.crt
cert_key = /opt/janus/certs/privateKey.key
; Media-related stuff: you can configure whether if you want
; to enable IPv6 support (still WIP, so handle with care), the maximum size
; of the NACK queue (in milliseconds, defaults to 1000ms=1s) for retransmissions, the
; range of ports to use for RTP and RTCP (by default, no range is envisaged), the
; starting MTU for DTLS (1472 by default, it adapts automatically),
; if BUNDLE should be forced (defaults to false) and if RTCP muxing should
; be forced (defaults to false).
[media]
;ipv6 = true
;max_nack_queue = 1000
;rtp_port_range = 20000-40000
;dtls_mtu = 1200
;force-bundle = true
;force-rtcp-mux = true
; NAT-related stuff: specifically, you can configure the STUN/TURN
; servers to use to gather candidates if the gateway is behind a NAT,
; and srflx/relay candidates are needed. In case STUN is not enough and
; this is needed (it shouldn't), you can also configure Janus to use a
; TURN server; please notice that this does NOT refer to TURN usage in
; browsers, but in the gathering of relay candidates by Janus itself,
; e.g., if you want to limit the ports used by a Janus instance on a
; private machine. Furthermore, you can choose whether Janus should be
; configured to work in ICE-Lite mode (by default it doesn't). Finally,
; you can also enable ICE-TCP support (beware that it currently *only*
; works if you enable ICE Lite as well), choose which interfaces should
; be used for gathering candidates, and enable or disable the
; internal libnice debugging, if needed.
[nat]
stun_server = stun.l.google.com
stun_port = 19302
;nice_debug = false
;ice_lite = true
;ice_tcp = true
; In case you're deploying Janus on a server which is configured with
; a 1:1 NAT (e.g., Amazon EC2), you might want to also specify the public
; address of the machine using the setting below. This will result in
; all host candidates (which normally have a private IP address) to
; be rewritten with the public address provided in the settings. As
; such, use the option with caution and only if you know what you're doing.
; Besides, it's still recommended to also enable STUN in those cases,
; and keep ICE Lite disabled as it's not strictly speaking a public server.
;nat_1_1_mapping = 1.2.3.4
; You can configure a TURN server in two different ways: specifying a
; statically configured TURN server, and thus provide the address of the
; TURN server, the transport (udp/tcp/tls) to use, and a set of valid
; credentials to authenticate...
;turn_server = myturnserver.com
;turn_port = 3478
;turn_type = udp
;turn_user = myuser
;turn_pwd = mypassword
; ... or you can make use of the TURN REST API to get info on one or more
; TURN services dynamically. This makes use of the proposed standard of
; such an API (https://tools.ietf.org/html/draft-uberti-behave-turn-rest-00)
; which is currently available in both rfc5766-turn-server and coturn.
; You enable this by specifying the address of your TURN REST API backend,
; the HTTP method to use (GET or POST) and, if required, the API key Janus
; must provide.
;turn_rest_api = http://yourbackend.com/path/to/api
;turn_rest_api_key = anyapikeyyoumayhaveset
;turn_rest_api_method = GET
; You can also choose which interfaces should be explicitly used by the
; gateway for the purpose of ICE candidates gathering, thus excluding
; others that may be available. To do so, use the 'ice_enforce_list'
; setting and pass it a comma-separated list of interfaces or IP addresses
; to enforce. This is especially useful if the server hosting the gateway
; has several interfaces, and you only want a subset to be used. Any of
; the following examples are valid:
; ice_enforce_list = eth0
; ice_enforce_list = eth0,eth1
; ice_enforce_list = eth0,192.168.
; ice_enforce_list = eth0,192.168.0.1
; By default, no interface is enforced, meaning Janus will try to use them all.
;ice_enforce_list = eth0
; In case you don't want to specify specific interfaces to use, but would
; rather tell Janus to use all the available interfaces except some that
; you don't want to involve, you can also choose which interfaces or IP
; addresses should be excluded and ignored by the gateway for the purpose
; of ICE candidates gathering. To do so, use the 'ice_ignore_list' setting
; and pass it a comma-separated list of interfaces or IP addresses to
; ignore. This is especially useful if the server hosting the gateway
; has several interfaces you already know will not be used or will simply
; always slow down ICE (e.g., virtual interfaces created by VMware).
; Partial strings are supported, which means that any of the following
; examples are valid:
; ice_ignore_list = vmnet8,192.168.0.1,10.0.0.1
; ice_ignore_list = vmnet,192.168.
; Just beware that the ICE ignore list is not used if an enforce list
; has been configured. By default, Janus ignores all interfaces whose
; name starts with 'vmnet', to skip VMware interfaces:
ice_ignore_list = vmnet
; You can choose which of the available plugins should be
; enabled or not. Use the 'disable' directive to prevent Janus from
; loading one or more plugins: use a comma separated list of plugin file
; names to identify the plugins to disable. By default all available
; plugins are enabled and loaded at startup.
[plugins]
; disable = libjanus_voicemail.so,libjanus_recordplay.so
; You can choose which of the available transports should be enabled or
; not. Use the 'disable' directive to prevent Janus from loading one
; or more transport: use a comma separated list of transport file names
; to identify the transports to disable. By default all available
; transports are enabled and loaded at startup.
[transports]
; disable = libjanus_rabbitmq.so
; Event handlers allow you to receive live events from Janus happening
; in core and/or plugins. Since this can require some more resources,
; the feature is disabled by default. Setting broadcast to yes will
; enable them. You can then choose which of the available event handlers
; should be loaded or not. Use the 'disable' directive to prevent Janus
; from loading one or more event handlers: use a comma separated list of
; file names to identify the event handlers to disable. By default, if
; broadcast is set to yes all available event handlers are enabled and
; loaded at startup.
[events]
; broadcast = yes
; disable = libjanus_sampleevh.so