Blame view

trunk/src/app/srs_app_config.hpp 32.5 KB
1 2 3
/*
The MIT License (MIT)
4
Copyright (c) 2013-2014 winlin
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
24 25
#ifndef SRS_APP_CONFIG_HPP
#define SRS_APP_CONFIG_HPP
26 27

/*
28
#include <srs_app_config.hpp>
29 30 31 32 33 34
*/
#include <srs_core.hpp>

#include <vector>
#include <string>
35
#include <srs_app_reload.hpp>
36
winlin authored
37 38 39
///////////////////////////////////////////////////////////
// default consts values
///////////////////////////////////////////////////////////
winlin authored
40
#define SRS_CONF_DEFAULT_PID_FILE "./objs/srs.pid"
winlin authored
41 42 43 44 45
#define SRS_CONF_DEFAULT_LOG_FILE "./objs/srs.log"
#define SRS_CONF_DEFAULT_LOG_LEVEL "trace"
#define SRS_CONF_DEFAULT_LOG_TANK_CONSOLE "console"
#define SRS_CONF_DEFAULT_COFNIG_FILE "conf/srs.conf"
#define SRS_CONF_DEFAULT_FF_LOG_DIR "./objs"
46
winlin authored
47
#define SRS_CONF_DEFAULT_MAX_CONNECTIONS 1000
48 49 50
#define SRS_CONF_DEFAULT_HLS_PATH "./objs/nginx/html"
#define SRS_CONF_DEFAULT_HLS_FRAGMENT 10
#define SRS_CONF_DEFAULT_HLS_WINDOW 60
winlin authored
51
#define SRS_CONF_DEFAULT_DVR_PATH "./objs/nginx/html"
52 53 54 55
#define SRS_CONF_DEFAULT_DVR_PLAN_SESSION "session"
#define SRS_CONF_DEFAULT_DVR_PLAN_SEGMENT "segment"
#define SRS_CONF_DEFAULT_DVR_PLAN SRS_CONF_DEFAULT_DVR_PLAN_SESSION
#define SRS_CONF_DEFAULT_DVR_DURATION 30
56
#define SRS_CONF_DEFAULT_TIME_JITTER "full"
winlin authored
57 58 59 60
// in seconds, the live queue length.
#define SRS_CONF_DEFAULT_QUEUE_LENGTH 30
// in seconds, the paused queue length.
#define SRS_CONF_DEFAULT_PAUSED_LENGTH 10
61 62 63 64
// the interval in seconds for bandwidth check
#define SRS_CONF_DEFAULT_BANDWIDTH_INTERVAL 30
// the interval in seconds for bandwidth check
#define SRS_CONF_DEFAULT_BANDWIDTH_LIMIT_KBPS 1000
65
winlin authored
66 67 68
#define SRS_CONF_DEFAULT_HTTP_MOUNT "/"
#define SRS_CONF_DEFAULT_HTTP_DIR SRS_CONF_DEFAULT_HLS_PATH
69 70 71
#define SRS_CONF_DEFAULT_HTTP_STREAM_PORT 8080
#define SRS_CONF_DEFAULT_HTTP_API_PORT 1985
72 73
#define SRS_CONF_DEFAULT_HTTP_HEAETBEAT_ENABLED false
#define SRS_CONF_DEFAULT_HTTP_HEAETBEAT_INTERVAL 9.9
winlin authored
74
#define SRS_CONF_DEFAULT_HTTP_HEAETBEAT_URL "http://"SRS_CONSTS_LOCALHOST":8085/api/v1/servers"
75
#define SRS_CONF_DEFAULT_HTTP_HEAETBEAT_SUMMARIES false
76
77 78
#define SRS_CONF_DEFAULT_STATS_NETWORK_DEVICE_INDEX 0
winlin authored
79 80 81 82 83 84 85 86 87 88
#define SRS_CONF_DEFAULT_STAGE_PLAY_USER_INTERVAL_MS 10000
#define SRS_CONF_DEFAULT_STAGE_PUBLISH_USER_INTERVAL_MS 10000
#define SRS_CONF_DEFAULT_STAGE_FORWARDER_INTERVAL_MS 10000
#define SRS_CONF_DEFAULT_STAGE_ENCODER_INTERVAL_MS 10000
#define SRS_CONF_DEFAULT_STAGE_INGESTER_INTERVAL_MS 10000
#define SRS_CONF_DEFAULT_STAGE_HLS_INTERVAL_MS 10000
#define SRS_CONF_DEFAULT_STAGE_EDGE_INTERVAL_MS 10000

#define SRS_CONF_DEFAULT_INGEST_TYPE_FILE "file"
#define SRS_CONF_DEFAULT_INGEST_TYPE_STREAM "stream"
89
winlin authored
90 91 92
#define SRS_CONF_DEFAULT_TRANSCODE_IFORMAT "flv"
#define SRS_CONF_DEFAULT_TRANSCODE_OFORMAT "flv"
93 94
namespace _srs_internal
{
winlin authored
95
    class SrsConfigBuffer;
96
};
97
winlin authored
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
/**
* the config directive.
* the config file is a group of directives,
* all directive has name, args and child-directives.
* for example, the following config text:
        vhost vhost.ossrs.net {
            enabled         on;
            ingest livestream {
                enabled      on;
                ffmpeg       /bin/ffmpeg;
            }
        }
* will be parsed to:
*       SrsConfDirective: name="vhost", arg0="vhost.ossrs.net", child-directives=[
*           SrsConfDirective: name="enabled", arg0="on", child-directives=[]
*           SrsConfDirective: name="ingest", arg0="livestream", child-directives=[
*               SrsConfDirective: name="enabled", arg0="on", child-directives=[]
*               SrsConfDirective: name="ffmpeg", arg0="/bin/ffmpeg", child-directives=[]
*           ]
*       ]
winlin authored
118 119
* @remark, allow empty directive, for example: "dir0 {}"
* @remark, don't allow empty name, for example: ";" or "{dir0 arg0;}
winlin authored
120
*/
121 122 123
class SrsConfDirective
{
public:
winlin authored
124 125 126
    /**
    * the line of config file in which the directive from
    */
127
    int conf_line;
winlin authored
128 129 130 131 132
    /**
    * the name of directive, for example, the following config text:
    *       enabled     on;
    * will be parsed to a directive, its name is "enalbed"
    */
133
    std::string name;
winlin authored
134 135 136 137 138
    /**
    * the args of directive, for example, the following config text:
    *       listen      1935 1936;
    * will be parsed to a directive, its args is ["1935", "1936"].
    */
139
    std::vector<std::string> args;
winlin authored
140 141 142 143 144 145 146 147 148 149 150
    /**
    * the child directives, for example, the following config text:
    *       vhost vhost.ossrs.net {
    *           enabled         on;
    *       }
    * will be parsed to a directive, its directives is a vector contains 
    * a directive, which is:
    *       name:"enalbed", args:["on"], directives:[]
    * 
    * @remark, the directives can contains directives.
    */
151
    std::vector<SrsConfDirective*> directives;
152
public:
153 154
    SrsConfDirective();
    virtual ~SrsConfDirective();
winlin authored
155
// args
156
public:
winlin authored
157 158 159 160
    /**
    * get the args0,1,2, if user want to get more args,
    * directly use the args.at(index).
    */
161
    virtual std::string arg0();
winlin authored
162
    virtual std::string arg1();
163
    virtual std::string arg2();
winlin authored
164 165 166 167 168 169
// directives
public:
    /**
    * get the directive by index.
    * @remark, assert the index<directives.size().
    */
170
    virtual SrsConfDirective* at(int index);
winlin authored
171 172 173
    /**
    * get the directive by name, return the first match.
    */
174
    virtual SrsConfDirective* get(std::string _name);
winlin authored
175 176 177
    /**
    * get the directive by name and its arg0, return the first match.
    */
178
    virtual SrsConfDirective* get(std::string _name, std::string _arg0);
winlin authored
179
// help utilities
180
public:
winlin authored
181 182 183
    /**
    * whether current directive is vhost.
    */
winlin authored
184
    virtual bool is_vhost();
winlin authored
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
// parse utilities
public:
    /**
    * parse config directive from file buffer.
    */
    virtual int parse(_srs_internal::SrsConfigBuffer* buffer);
// private parse.
private:
    /**
    * the directive parsing type.
    */
    enum SrsDirectiveType {
        /**
        * the root directives, parsing file.
        */
        parse_file, 
        /**
        * for each direcitve, parsing text block.
        */
        parse_block
    };
    /**
    * parse the conf from buffer. the work flow:
    * 1. read a token(directive args and a ret flag), 
    * 2. initialize the directive by args, args[0] is name, args[1-N] is args of directive,
    * 3. if ret flag indicates there are child-directives, read_conf(directive, block) recursively.
    */
    virtual int parse_conf(_srs_internal::SrsConfigBuffer* buffer, SrsDirectiveType type);
    /**
    * read a token from buffer.
    * a token, is the directive args and a flag indicates whether has child-directives.
    * @param args, the output directive args, the first is the directive name, left is the args.
217
    * @param line_start, the actual start line of directive.
winlin authored
218 219
    * @return, an error code indicates error or has child-directives.
    */
220
    virtual int read_token(_srs_internal::SrsConfigBuffer* buffer, std::vector<std::string>& args, int& line_start);
221 222 223
};

/**
224
* the config service provider.
225 226 227 228 229 230 231
* for the config supports reload, so never keep the reference cross st-thread,
* that is, never save the SrsConfDirective* get by any api of config,
* for it maybe free in the reload st-thread cycle.
* you can keep it before st-thread switch, or simply never keep it.
*/
class SrsConfig
{
winlin authored
232
// user command
233
private:
winlin authored
234 235 236
    /**
    * whether show help and exit.
    */
237
    bool show_help;
winlin authored
238 239 240
    /**
    * whether test config file and exit.
    */
241
    bool test_conf;
winlin authored
242 243 244
    /**
    * whether show SRS version and exit.
    */
245
    bool show_version;
winlin authored
246 247 248 249 250 251
// global env variables.
private:
    /**
    * the user parameters, the argc and argv.
    * the argv is " ".join(argv), where argv is from main(argc, argv).
    */
winlin authored
252
    std::string _argv;
winlin authored
253 254 255
    /**
    * current working directory.
    */
winlin authored
256
    std::string _cwd;
winlin authored
257 258 259 260 261 262 263 264 265 266
// config section
private:
    /**
    * the last parsed config file.
    * if reload, reload the config file.
    */
    std::string config_file;
    /**
    * the directive root.
    */
267
    SrsConfDirective* root;
winlin authored
268 269 270 271 272
// reload section
private:
    /**
    * the reload subscribers, when reload, callback all handlers.
    */
273
    std::vector<ISrsReloadHandler*> subscribes;
274
public:
275 276
    SrsConfig();
    virtual ~SrsConfig();
winlin authored
277
// reload
278
public:
winlin authored
279 280 281 282
    /**
    * for reload handler to register itself,
    * when config service do the reload, callback the handler.
    */
283
    virtual void subscribe(ISrsReloadHandler* handler);
winlin authored
284 285 286
    /**
    * for reload handler to unregister itself.
    */
287
    virtual void unsubscribe(ISrsReloadHandler* handler);
winlin authored
288 289 290 291
    /**
    * reload the config file.
    * @remark, user can test the config before reload it.
    */
winlin authored
292
    virtual int reload();
293 294 295 296 297 298
protected:
    /**
    * reload from the config.
    * @remark, use protected for the utest to override with mock.
    */
    virtual int reload_conf(SrsConfig* conf);
winlin authored
299
private:
winlin authored
300 301 302
    /**
    * reload the http_api section of config.
    */
winlin authored
303
    virtual int reload_http_api(SrsConfDirective* old_root);
winlin authored
304 305 306
    /**
    * reload the http_stream section of config.
    */
winlin authored
307
    virtual int reload_http_stream(SrsConfDirective* old_root);
winlin authored
308 309 310
    /**
    * reload the vhost section of config.
    */
winlin authored
311
    virtual int reload_vhost(SrsConfDirective* old_root);
winlin authored
312 313 314
    /**
    * reload the transcode section of vhost of config.
    */
winlin authored
315
    virtual int reload_transcode(SrsConfDirective* new_vhost, SrsConfDirective* old_vhost);
winlin authored
316 317 318
    /**
    * reload the ingest section of vhost of config.
    */
winlin authored
319
    virtual int reload_ingest(SrsConfDirective* new_vhost, SrsConfDirective* old_vhost);
winlin authored
320
// parse options and file
321
public:
winlin authored
322 323 324
    /**
    * parse the cli, the main(argc,argv) function.
    */
325
    virtual int parse_options(int argc, char** argv);
326 327 328 329
    /**
    * get the config file path.
    */
    virtual std::string config();
330
private:
winlin authored
331 332 333
    /**
    * parse each argv.
    */
334
    virtual int parse_argv(int& i, char** argv);
winlin authored
335 336 337
    /**
    * print help and exit.
    */
338
    virtual void print_help(char** argv);
winlin authored
339 340 341
    /**
    * parse the config file, which is specified by cli.
    */
342
    virtual int parse_file(const char* filename);
343 344 345 346 347
public:
    /**
    * check the parsed config.
    */
    virtual int check_config();
348 349 350 351
protected:
    /**
    * parse config from the buffer.
    * @param buffer, the config buffer, user must delete it.
352
    * @remark, use protected for the utest to override with mock.
353 354
    */
    virtual int parse_buffer(_srs_internal::SrsConfigBuffer* buffer);
winlin authored
355
// global env
winlin authored
356
public:
winlin authored
357 358 359
    /**
    * get the current work directory.
    */
360
    virtual std::string         cwd();
winlin authored
361 362 363
    /**
    * get the cli, the main(argc,argv), program start command.
    */
364
    virtual std::string         argv();
365 366
// global section
public:
winlin authored
367 368 369 370 371
    /**
    * get the directive root, corresponding to the config file.
    * the root directive, no name and args, contains directives.
    * all directive parsed can retrieve from root.
    */
winlin authored
372
    virtual SrsConfDirective*   get_root();
winlin authored
373
    /**
374 375 376
    * get the deamon config.
    * if true, SRS will run in deamon mode, fork and fork to reap the 
    * grand-child process to init process.
winlin authored
377
    */
378
    virtual bool                get_deamon();
winlin authored
379
    /**
380 381 382 383 384 385
    * get the max connections limit of system.
    * if exceed the max connection, SRS will disconnect the connection.
    * @remark, linux will limit the connections of each process, 
    *       for example, when you need SRS to service 10000+ connections,
    *       user must use "ulimit -HSn 10000" and config the max connections
    *       of SRS.
winlin authored
386
    */
387
    virtual int                 get_max_connections();
winlin authored
388
    /**
389 390 391
    * get the listen port of SRS.
    * user can specifies multiple listen ports,
    * each args of directive is a listen port.
winlin authored
392
    */
393
    virtual std::vector<std::string>        get_listen();
winlin authored
394
    /**
395 396 397 398 399 400
    * get the pid file path.
    * the pid file is used to save the pid of SRS,
    * use file lock to prevent multiple SRS starting.
    * @remark, if user need to run multiple SRS instance,
    *       for example, to start multiple SRS for multiple CPUs,
    *       user can use different pid file for each process.
winlin authored
401
    */
402
    virtual std::string         get_pid_file();
403 404 405 406
// pithy print
private:
    virtual SrsConfDirective*   get_pithy_print();
public:
winlin authored
407
    /**
408 409
    * get the pithy print interval for publish, in ms,
    * the publish(flash/FMLE) message print.
winlin authored
410
    */
411
    virtual int                 get_pithy_print_publish();
winlin authored
412
    /**
413 414
    * get the pithy print interval for forwarder, in ms,
    * the forwarder message print, for SRS forward stream to other servers.
winlin authored
415
    */
416
    virtual int                 get_pithy_print_forwarder();
winlin authored
417
    /**
418 419
    * get the pithy print interval for encoder, in ms,
    * the encoder message print, for FFMPEG transcoder.
winlin authored
420
    */
421
    virtual int                 get_pithy_print_encoder();
winlin authored
422
    /**
423 424 425
    * get the pithy print interval for ingester, in ms,
    * the ingest used FFMPEG, or your tools, to read and transcode other stream 
    * to RTMP to SRS.
winlin authored
426
    */
427
    virtual int                 get_pithy_print_ingester();
winlin authored
428
    /**
429 430
    * get the pithy print interval for HLS, in ms,
    * the HLS used for IOS/android/PC, SRS will mux RTMP to HLS.
winlin authored
431
    */
432
    virtual int                 get_pithy_print_hls();
winlin authored
433
    /**
434 435
    * get the pithy print interval for Play, in ms,
    * the play is client or edge playing RTMP stream
winlin authored
436
    */
437
    virtual int                 get_pithy_print_play();
winlin authored
438
    /**
439 440
    * get the pithy print interval for edge, in ms,
    * the edge will get stream from upnode.
winlin authored
441
    */
442
    virtual int                 get_pithy_print_edge();
443
// vhost specified section
winlin authored
444
public:
445 446 447 448
    /**
    * get the vhost directive by vhost name.
    * @param vhost, the name of vhost to get.
    */
winlin authored
449
    virtual SrsConfDirective*   get_vhost(std::string vhost);
winlin authored
450
    /**
451
    * get all vhosts in config file.
winlin authored
452
    */
453
    virtual std::vector<SrsConfDirective*>  get_vhosts();
winlin authored
454
    /**
winlin authored
455 456 457
    * whether vhost is enabled
    * @param vhost, the vhost name.
    * @return true when vhost is ok; otherwise, false.
winlin authored
458
    */
winlin authored
459
    virtual bool                get_vhost_enabled(std::string vhost);
winlin authored
460
    /**
winlin authored
461 462 463
    * whether vhost is enabled
    * @param vhost, the vhost directive.
    * @return true when vhost is ok; otherwise, false.
winlin authored
464
    */
winlin authored
465
    virtual bool                get_vhost_enabled(SrsConfDirective* vhost);
winlin authored
466
    /**
winlin authored
467 468 469
    * whether gop_cache is enabled of vhost.
    * gop_cache used to cache last gop, for client to fast startup.
    * @return true when gop_cache is ok; otherwise, false.
470
    * @remark, default true.
winlin authored
471
    */
winlin authored
472
    virtual bool                get_gop_cache(std::string vhost);
winlin authored
473
    /**
474 475 476 477 478 479 480 481 482
    * whether debug_srs_upnode is enabled of vhost.
    * debug_srs_upnode is very important feature for tracable log,
    * but some server, for instance, flussonic donot support it.
    * @see https://github.com/winlinvip/simple-rtmp-server/issues/160
    * @return true when debug_srs_upnode is ok; otherwise, false.
    * @remark, default true.
    */
    virtual bool                get_debug_srs_upnode(std::string vhost);
    /**
winlin authored
483 484 485
    * whether atc is enabled of vhost.
    * atc always use encoder timestamp, SRS never adjust the time.
    * @return true when atc is ok; otherwise, false.
486
    * @remark, default false.
winlin authored
487
    */
winlin authored
488
    virtual bool                get_atc(std::string vhost);
winlin authored
489
    /**
winlin authored
490 491 492
    * whether atc_auto is enabled of vhost.
    * atc_auto used to auto enable atc, when metadata specified the bravo_atc.
    * @return true when atc_auto is ok; otherwise, false.
493
    * @remark, default true.
winlin authored
494
    */
winlin authored
495
    virtual bool                get_atc_auto(std::string vhost);
winlin authored
496
    /**
winlin authored
497 498
    * get the time_jitter algorithm.
    * @return the time_jitter algorithm, defined in SrsRtmpJitterAlgorithm.
499
    * @remark, default full.
winlin authored
500
    */
winlin authored
501
    virtual int                 get_time_jitter(std::string vhost);
winlin authored
502
    /**
503 504
    * get the cache queue length, in seconds.
    * when exceed the queue length, drop packet util I frame.
505
    * @remark, default 10.
winlin authored
506
    */
winlin authored
507
    virtual double              get_queue_length(std::string vhost);
winlin authored
508
    /**
509 510 511 512
    * get the refer antisuck directive.
    * each args of directive is a refer config.
    * when the client refer(pageUrl) not match the refer config,
    * SRS will reject the connection.
513
    * @remark, default NULL.
winlin authored
514
    */
winlin authored
515
    virtual SrsConfDirective*   get_refer(std::string vhost);
winlin authored
516
    /**
517
    * get the play refer, refer for play clients.
518
    * @remark, default NULL.
winlin authored
519
    */
winlin authored
520
    virtual SrsConfDirective*   get_refer_play(std::string vhost);
winlin authored
521
    /**
522
    * get the publish refer, refer for publish clients.
523
    * @remark, default NULL.
winlin authored
524
    */
winlin authored
525
    virtual SrsConfDirective*   get_refer_publish(std::string vhost);
winlin authored
526
    /**
527
    * get the chunk size of vhost.
528 529
    * @param vhost, the vhost to get the chunk size. use global if not specified.
    *       empty string to get the global.
530
    * @remark, default 60000.
winlin authored
531
    */
532
    virtual int                 get_chunk_size(std::string vhost);
533 534 535 536 537
private:
    /**
    * get the global chunk size.
    */
    virtual int                 get_global_chunk_size();
winlin authored
538 539
// forward section
public:
winlin authored
540
    /**
541
    * get the forward directive of vhost.
winlin authored
542
    */
winlin authored
543 544
    virtual SrsConfDirective*   get_forward(std::string vhost);
// http_hooks section
545 546 547 548 549
private:
    /**
    * get the http_hooks directive of vhost.
    */
    virtual SrsConfDirective*   get_vhost_http_hooks(std::string vhost);
winlin authored
550
public:
winlin authored
551
    /**
552 553 554 555 556
    * whether vhost http-hooks enabled.
    * @remark, if not enabled, donot callback all http hooks.
    */
    virtual bool                get_vhost_http_hooks_enabled(std::string vhost);
    /**
winlin authored
557 558
    * get the on_connect callbacks of vhost.
    * @return the on_connect callback directive, the args is the url to callback.
winlin authored
559
    */
winlin authored
560
    virtual SrsConfDirective*   get_vhost_on_connect(std::string vhost);
winlin authored
561
    /**
winlin authored
562 563
    * get the on_close callbacks of vhost.
    * @return the on_close callback directive, the args is the url to callback.
winlin authored
564
    */
winlin authored
565
    virtual SrsConfDirective*   get_vhost_on_close(std::string vhost);
winlin authored
566
    /**
winlin authored
567 568
    * get the on_publish callbacks of vhost.
    * @return the on_publish callback directive, the args is the url to callback.
winlin authored
569
    */
winlin authored
570
    virtual SrsConfDirective*   get_vhost_on_publish(std::string vhost);
winlin authored
571
    /**
winlin authored
572 573
    * get the on_unpublish callbacks of vhost.
    * @return the on_unpublish callback directive, the args is the url to callback.
winlin authored
574
    */
winlin authored
575
    virtual SrsConfDirective*   get_vhost_on_unpublish(std::string vhost);
winlin authored
576
    /**
winlin authored
577 578
    * get the on_play callbacks of vhost.
    * @return the on_play callback directive, the args is the url to callback.
winlin authored
579
    */
winlin authored
580
    virtual SrsConfDirective*   get_vhost_on_play(std::string vhost);
winlin authored
581
    /**
winlin authored
582 583
    * get the on_stop callbacks of vhost.
    * @return the on_stop callback directive, the args is the url to callback.
winlin authored
584
    */
winlin authored
585
    virtual SrsConfDirective*   get_vhost_on_stop(std::string vhost);
586 587
// bwct(bandwidth check tool) section
public:
winlin authored
588
    /**
589 590 591
    * whether bw check enabled for vhost.
    * if enabled, serve all clients with bandwidth check services.
    * oterwise, serve all cleints with stream.
winlin authored
592
    */
593
    virtual bool                get_bw_check_enabled(std::string vhost);
winlin authored
594
    /**
595
    * the key of server, if client key mot match, reject.
winlin authored
596
    */
597
    virtual std::string         get_bw_check_key(std::string vhost);
winlin authored
598
    /**
599 600 601 602
    * the check interval, in ms.
    * if the client request check in very short time(in the interval),
    * SRS will reject client.
    * @remark this is used to prevent the bandwidth check attack.
winlin authored
603
    */
604
    virtual int                 get_bw_check_interval_ms(std::string vhost);
winlin authored
605
    /**
606 607 608
    * the max kbps that user can test,
    * if exceed the kbps, server will slowdown the send-recv.
    * @remark this is used to protect the service bandwidth.
winlin authored
609
    */
610
    virtual int                 get_bw_check_limit_kbps(std::string vhost);
611 612
// vhost edge section
public:
winlin authored
613
    /**
614 615 616
    * whether vhost is edge mode.
    * for edge, publish client will be proxyed to upnode,
    * for edge, play client will share a connection to get stream from upnode.
winlin authored
617
    */
618
    virtual bool                get_vhost_is_edge(std::string vhost);
winlin authored
619
    /**
620 621 622
    * whether vhost is edge mode.
    * for edge, publish client will be proxyed to upnode,
    * for edge, play client will share a connection to get stream from upnode.
winlin authored
623
    */
624
    virtual bool                get_vhost_is_edge(SrsConfDirective* vhost);
winlin authored
625
    /**
626 627
    * get the origin config of edge,
    * specifies the origin ip address, port.
winlin authored
628
    */
629
    virtual SrsConfDirective*   get_vhost_edge_origin(std::string vhost);
winlin authored
630
    /**
631 632 633 634
    * whether edge token tranverse is enabled,
    * if true, edge will send connect origin to verfy the token of client.
    * for example, we verify all clients on the origin FMS by server-side as,
    * all clients connected to edge must be tranverse to origin to verify.
winlin authored
635
    */
636
    virtual bool                get_vhost_edge_token_traverse(std::string vhost);
637 638
// vhost transcode section
public:
winlin authored
639
    /**
640 641 642 643 644 645 646 647 648
    * get the transcode directive of vhost in specified scope.
    * @param vhost, the vhost name to get the transcode directive.
    * @param scope, the scope, empty to get all. for example, user can transcode
    *       the app scope stream, by config with app:
    *                   transcode live {...}
    *       when the scope is "live", this directive is matched.
    *       the scope can be: empty for all, app, app/stream.
    * @remark, please see the samples of full.conf, the app.transcode.srs.com
    *       and stream.transcode.srs.com.
winlin authored
649
    */
winlin authored
650
    virtual SrsConfDirective*   get_transcode(std::string vhost, std::string scope);
winlin authored
651
    /**
652
    * whether the transcode directive is enabled.
winlin authored
653
    */
winlin authored
654
    virtual bool                get_transcode_enabled(SrsConfDirective* transcode);
winlin authored
655
    /**
656
    * get the ffmpeg tool path of transcode.
winlin authored
657
    */
winlin authored
658
    virtual std::string         get_transcode_ffmpeg(SrsConfDirective* transcode);
winlin authored
659
    /**
660
    * get the engines of transcode.
winlin authored
661
    */
662
    virtual std::vector<SrsConfDirective*>      get_transcode_engines(SrsConfDirective* transcode);
winlin authored
663
    /**
winlin authored
664
    * whether the engine is enabled.
winlin authored
665
    */
666
    virtual bool                get_engine_enabled(SrsConfDirective* engine);
winlin authored
667
    /**
668 669 670 671
    * get the iformat of engine
    */
    virtual std::string         get_engine_iformat(SrsConfDirective* engine);
    /**
winlin authored
672 673 674 675 676 677 678
    * get the vfilter of engine,
    * the video filter set before the vcodec of FFMPEG.
    */
    virtual std::vector<std::string> get_engine_vfilter(SrsConfDirective* engine);
    /**
    * get the vcodec of engine,
    * the codec of video, copy or libx264
winlin authored
679
    */
winlin authored
680
    virtual std::string         get_engine_vcodec(SrsConfDirective* engine);
winlin authored
681
    /**
winlin authored
682 683
    * get the vbitrate of engine,
    * the bitrate in kbps of video, for example, 800kbps
winlin authored
684
    */
winlin authored
685
    virtual int                 get_engine_vbitrate(SrsConfDirective* engine);
winlin authored
686
    /**
winlin authored
687 688
    * get the vfps of engine.
    * the video fps, for example, 25fps
winlin authored
689
    */
winlin authored
690
    virtual double              get_engine_vfps(SrsConfDirective* engine);
winlin authored
691
    /**
winlin authored
692 693
    * get the vwidth of engine,
    * the video width, for example, 1024
winlin authored
694
    */
winlin authored
695
    virtual int                 get_engine_vwidth(SrsConfDirective* engine);
winlin authored
696
    /**
winlin authored
697 698
    * get the vheight of engine,
    * the video height, for example, 576
winlin authored
699
    */
winlin authored
700
    virtual int                 get_engine_vheight(SrsConfDirective* engine);
winlin authored
701
    /**
winlin authored
702 703
    * get the vthreads of engine,
    * the video transcode libx264 threads, for instance, 8
winlin authored
704
    */
winlin authored
705
    virtual int                 get_engine_vthreads(SrsConfDirective* engine);
winlin authored
706
    /**
winlin authored
707 708
    * get the vprofile of engine,
    * the libx264 profile, can be high,main,baseline
winlin authored
709
    */
winlin authored
710
    virtual std::string         get_engine_vprofile(SrsConfDirective* engine);
winlin authored
711
    /**
winlin authored
712 713
    * get the vpreset of engine,
    * the libx264 preset, can be ultrafast,superfast,veryfast,faster,fast,medium,slow,slower,veryslow,placebo
winlin authored
714
    */
winlin authored
715
    virtual std::string         get_engine_vpreset(SrsConfDirective* engine);
winlin authored
716
    /**
winlin authored
717
    * get the additional video params.
winlin authored
718
    */
winlin authored
719
    virtual std::vector<std::string> get_engine_vparams(SrsConfDirective* engine);
winlin authored
720
    /**
winlin authored
721 722
    * get the acodec of engine,
    * the audio codec can be copy or libaacplus
winlin authored
723
    */
winlin authored
724
    virtual std::string         get_engine_acodec(SrsConfDirective* engine);
winlin authored
725
    /**
winlin authored
726 727
    * get the abitrate of engine,
    * the audio bitrate in kbps, for instance, 64kbps.
winlin authored
728
    */
winlin authored
729
    virtual int                 get_engine_abitrate(SrsConfDirective* engine);
winlin authored
730
    /**
winlin authored
731 732
    * get the asample_rate of engine,
    * the audio sample_rate, for instance, 44100HZ
winlin authored
733
    */
winlin authored
734
    virtual int                 get_engine_asample_rate(SrsConfDirective* engine);
winlin authored
735
    /**
winlin authored
736 737
    * get the achannels of engine,
    * the audio channel, for instance, 1 for mono, 2 for stereo.
winlin authored
738
    */
winlin authored
739
    virtual int                 get_engine_achannels(SrsConfDirective* engine);
winlin authored
740
    /**
winlin authored
741 742
    * get the aparams of engine,
    * the audio additional params.
winlin authored
743
    */
winlin authored
744
    virtual std::vector<std::string> get_engine_aparams(SrsConfDirective* engine);
winlin authored
745
    /**
746 747 748 749
    * get the oformat of engine
    */
    virtual std::string         get_engine_oformat(SrsConfDirective* engine);
    /**
winlin authored
750
    * get the output of engine, for example, rtmp://localhost/live/livestream,
winlin authored
751
    * @remark, we will use some variable, for instance, [vhost] to substitude with vhost.
winlin authored
752
    */
winlin authored
753
    virtual std::string         get_engine_output(SrsConfDirective* engine);
winlin authored
754
// ingest section
winlin authored
755
public:
winlin authored
756
    /**
winlin authored
757
    * get the ingest directives of vhost.
winlin authored
758
    */
winlin authored
759
    virtual std::vector<SrsConfDirective*> get_ingesters(std::string vhost);
winlin authored
760
    /**
winlin authored
761
    * get specified ingest.
winlin authored
762
    */
763
    virtual SrsConfDirective*   get_ingest_by_id(std::string vhost, std::string ingest_id);
winlin authored
764
    /**
winlin authored
765
    * whether ingest is enalbed.
winlin authored
766
    */
winlin authored
767
    virtual bool                get_ingest_enabled(SrsConfDirective* ingest);
winlin authored
768
    /**
winlin authored
769
    * get the ingest ffmpeg tool
winlin authored
770
    */
winlin authored
771
    virtual std::string         get_ingest_ffmpeg(SrsConfDirective* ingest);
winlin authored
772
    /**
winlin authored
773
    * get the ingest input type, file or stream.
winlin authored
774
    */
775
    virtual std::string         get_ingest_input_type(SrsConfDirective* ingest);
winlin authored
776
    /**
winlin authored
777
    * get the ingest input url.
winlin authored
778
    */
779
    virtual std::string         get_ingest_input_url(SrsConfDirective* ingest);
780 781
// log section
public:
winlin authored
782
    /**
winlin authored
783
    * whether log to file.
winlin authored
784
    */
785
    virtual bool                get_log_tank_file();
winlin authored
786
    /**
winlin authored
787
    * get the log level.
winlin authored
788
    */
789
    virtual std::string         get_log_level();
winlin authored
790
    /**
winlin authored
791
    * get the log file path.
winlin authored
792
    */
793
    virtual std::string         get_log_file();
winlin authored
794
    /**
winlin authored
795
    * whether ffmpeg log enabled
winlin authored
796
    */
797
    virtual bool                get_ffmpeg_log_enabled();
winlin authored
798
    /**
winlin authored
799 800
    * the ffmpeg log dir.
    * @remark, /dev/null to disable it.
winlin authored
801
    */
802
    virtual std::string         get_ffmpeg_log_dir();
803
// hls section
winlin authored
804
private:
winlin authored
805
    /**
winlin authored
806
    * get the hls directive of vhost.
winlin authored
807
    */
winlin authored
808
    virtual SrsConfDirective*   get_hls(std::string vhost);
winlin authored
809
public:
winlin authored
810
    /**
winlin authored
811
    * whether HLS is enabled.
winlin authored
812
    */
813
    virtual bool                get_hls_enabled(std::string vhost);
winlin authored
814
    /**
winlin authored
815
    * get the HLS ts/m3u8 file store path.
winlin authored
816
    */
winlin authored
817
    virtual std::string         get_hls_path(std::string vhost);
winlin authored
818
    /**
winlin authored
819 820
    * get the hls fragment time, in seconds.
    * a fragment is a ts file.
winlin authored
821
    */
winlin authored
822
    virtual double              get_hls_fragment(std::string vhost);
winlin authored
823
    /**
winlin authored
824 825 826
    * get the hls window time, in seconds.
    * a window is a set of ts, the ts collection in m3u8.
    * @remark SRS will delete the ts exceed the window.
winlin authored
827
    */
winlin authored
828
    virtual double              get_hls_window(std::string vhost);
winlin authored
829 830
// dvr section
private:
winlin authored
831
    /**
winlin authored
832
    * get the dvr directive.
winlin authored
833
    */
winlin authored
834 835
    virtual SrsConfDirective*   get_dvr(std::string vhost);
public:
winlin authored
836
    /**
winlin authored
837
    * whether dvr is enabled.
winlin authored
838
    */
winlin authored
839
    virtual bool                get_dvr_enabled(std::string vhost);
winlin authored
840
    /**
winlin authored
841
    * get the dvr path, the flv file to save in.
winlin authored
842
    */
winlin authored
843
    virtual std::string         get_dvr_path(std::string vhost);
winlin authored
844
    /**
winlin authored
845
    * get the plan of dvr, how to reap the flv file.
winlin authored
846
    */
847
    virtual std::string         get_dvr_plan(std::string vhost);
winlin authored
848
    /**
winlin authored
849
    * get the duration of dvr flv, for segment plan.
winlin authored
850
    */
851
    virtual int                 get_dvr_duration(std::string vhost);
winlin authored
852
    /**
853 854 855 856
    * whether wait keyframe to reap segment, for segment plan.
    */
    virtual bool                get_dvr_wait_keyframe(std::string vhost);
    /**
winlin authored
857
    * get the time_jitter algorithm for dvr.
winlin authored
858
    */
859
    virtual int                 get_dvr_time_jitter(std::string vhost);
860 861
// http api section
private:
winlin authored
862
    /**
winlin authored
863
    * get the http api directive.
winlin authored
864
    */
865
    virtual SrsConfDirective*   get_http_api();
winlin authored
866
    /**
winlin authored
867
    * whether http api enabled
winlin authored
868
    */
winlin authored
869 870
    virtual bool                get_http_api_enabled(SrsConfDirective* conf);
public:
winlin authored
871
    /**
winlin authored
872
    * whether http api enabled.
winlin authored
873
    */
winlin authored
874
    virtual bool                get_http_api_enabled();
winlin authored
875
    /**
winlin authored
876
    * get the http api listen port.
winlin authored
877
    */
878 879 880
    virtual int                 get_http_api_listen();
// http stream section
private:
winlin authored
881
    /**
winlin authored
882
    * get the http stream directive.
winlin authored
883
    */
884
    virtual SrsConfDirective*   get_http_stream();
winlin authored
885
    /**
winlin authored
886
    * whether http stream enabled.
winlin authored
887
    */
winlin authored
888 889
    virtual bool                get_http_stream_enabled(SrsConfDirective* conf);
public:
winlin authored
890
    /**
winlin authored
891
    * whether http stream enabled.
winlin authored
892
    */
winlin authored
893
    virtual bool                get_http_stream_enabled();
winlin authored
894
    /**
winlin authored
895
    * get the http stream listen port.
winlin authored
896
    */
897
    virtual int                 get_http_stream_listen();
winlin authored
898
    /**
winlin authored
899
    * get the http stream root dir.
winlin authored
900
    */
901
    virtual std::string         get_http_stream_dir();
winlin authored
902
public:
winlin authored
903
    /**
winlin authored
904
    * get whether vhost enabled http stream
winlin authored
905
    */
winlin authored
906
    virtual bool                get_vhost_http_enabled(std::string vhost);
winlin authored
907
    /**
winlin authored
908 909 910 911
    * get the http mount point for vhost,
    * vhost can use sub dir of http.
    * for example, http://server/vhost1/live/livestream
    * where the vhost1 is mount point for vhost1.
winlin authored
912
    */
winlin authored
913
    virtual std::string         get_vhost_http_mount(std::string vhost);
winlin authored
914
    /**
winlin authored
915 916 917 918 919
    * get the http dir for vhost.
    * the http dir of vhost will mount to the mount point of vhost.
    * for example, http://server/vhost1/live/livestream
    * where the vhost1 is mount point for vhost1,
    * and vhost1 dir is specified by this http dir.
winlin authored
920
    */
winlin authored
921
    virtual std::string         get_vhost_http_dir(std::string vhost);
922 923
// http heartbeart section
private:
winlin authored
924
    /**
winlin authored
925
    * get the heartbeat directive.
winlin authored
926
    */
927 928
    virtual SrsConfDirective*   get_heartbeart();
public:
winlin authored
929
    /**
winlin authored
930
    * whether heartbeat enabled.
winlin authored
931
    */
932
    virtual bool                get_heartbeat_enabled();
winlin authored
933
    /**
winlin authored
934
    * get the heartbeat interval, in ms.
winlin authored
935
    */
936
    virtual int64_t             get_heartbeat_interval();
winlin authored
937
    /**
winlin authored
938
    * get the heartbeat report url.
winlin authored
939
    */
940
    virtual std::string         get_heartbeat_url();
winlin authored
941
    /**
winlin authored
942
    * get the device id of heartbeat, to report to server.
winlin authored
943
    */
944
    virtual std::string         get_heartbeat_device_id();
winlin authored
945
    /**
winlin authored
946
    * whether report with summaries of http api: /api/v1/summaries.
winlin authored
947
    */
948
    virtual bool                get_heartbeat_summaries();
949 950 951 952 953 954 955 956 957 958 959 960
// stats section
private:
    /**
    * get the stats directive.
    */
    virtual SrsConfDirective*   get_stats();
public:
    /**
    * get the network device index, used to retrieve the ip of device,
    * for heartbeat to report to server, or to get the local ip.
    * for example, 0 means the eth0 maybe.
    */
961
    virtual int                 get_stats_network();
962 963 964 965 966 967
    /**
    * get the disk stat device name list.
    * the device name configed in args of directive.
    * @return the disk device name to stat. NULL if not configed.
    */
    virtual SrsConfDirective*   get_stats_disk_device();
968 969
};
970 971
namespace _srs_internal
{
winlin authored
972 973 974 975
    /**
    * the buffer of config content.
    */
    class SrsConfigBuffer
976
    {
winlin authored
977
    protected:
978 979 980 981 982 983 984 985 986 987 988
        // last available position.
        char* last;
        // end of buffer.
        char* end;
        // start of buffer.
        char* start;
    public:
        // current consumed position.
        char* pos;
        // current parsed line.
        int line;
winlin authored
989 990 991 992 993 994 995
    public:
        SrsConfigBuffer();
        virtual ~SrsConfigBuffer();
    public:
        /**
        * fullfill the buffer with content of file specified by filename.
        */
996
        virtual int fullfill(const char* filename);
winlin authored
997 998 999
        /**
        * whether buffer is empty.
        */
1000 1001 1002 1003
        virtual bool empty();
    };
};
1004 1005 1006 1007 1008 1009
/**
* deep compare directive.
*/
bool srs_directive_equals(SrsConfDirective* a, SrsConfDirective* b);

// global config
winlin authored
1010
extern SrsConfig* _srs_config;
1011
1012
#endif