Blame view

trunk/research/api-server/server.py 47.0 KB
winlin authored
1 2 3 4
#!/usr/bin/python
'''
The MIT License (MIT)
5
Copyright (c) 2013-2014 winlin
winlin authored
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

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.
'''

"""
the api-server is a default demo server for srs to call
when srs get some event, for example, when client connect
to srs, srs can invoke the http api of the api-server
"""
31
import sys
winlin authored
32
# reload sys model to enable the getdefaultencoding method.
33
reload(sys)
winlin authored
34 35
# set the default encoding to utf-8
# using exec to set the encoding, to avoid error in IDE.
36 37
exec("sys.setdefaultencoding('utf-8')")
assert sys.getdefaultencoding().lower() == "utf-8"
winlin authored
38
winlin authored
39
import os, json, time, datetime, cherrypy, threading
winlin authored
40
winlin authored
41
# simple log functions.
winlin authored
42 43 44 45
def trace(msg):
    date = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    print "[%s][trace] %s"%(date, msg)
winlin authored
46
# enable crossdomain access for js-client
47 48 49 50
# define the following method:
#   def OPTIONS(self, *args, **kwargs)
#       enable_crossdomain()
# invoke this method to enable js to request crossdomain.
51 52 53 54 55 56 57
def enable_crossdomain():
    cherrypy.response.headers["Access-Control-Allow-Origin"] = "*"
    cherrypy.response.headers["Access-Control-Allow-Methods"] = "GET, POST, HEAD, PUT, DELETE"
    # generate allow headers for crossdomain.
    allow_headers = ["Cache-Control", "X-Proxy-Authorization", "X-Requested-With", "Content-Type"]
    cherrypy.response.headers["Access-Control-Allow-Headers"] = ",".join(allow_headers)
winlin authored
58
# error codes definition
59 60 61 62 63
class Error:
    # ok, success, completed.
    success = 0
    # error when parse json
    system_parse_json = 100
64 65
    # request action invalid
    request_invalid_action = 200
winlin authored
66 67
    # cdn node not exists
    cdn_node_not_exists = 201
68 69

'''
70
handle the clients requests: connect/disconnect vhost/app.
71
'''
winlin authored
72
class RESTClients(object):
73
    exposed = True
winlin authored
74
75
    def GET(self):
76
        enable_crossdomain()
77
78 79 80 81
        clients = {}
        return json.dumps(clients)

    '''
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
    for SRS hook: on_connect/on_close
    on_connect:
        when client connect to vhost/app, call the hook,
        the request in the POST data string is a object encode by json:
              {
                  "action": "on_connect",
                  "client_id": 1985,
                  "ip": "192.168.1.10", "vhost": "video.test.com", "app": "live",
                  "pageUrl": "http://www.test.com/live.html"
              }
    on_close:
        when client close/disconnect to vhost/app/stream, call the hook,
        the request in the POST data string is a object encode by json:
              {
                  "action": "on_close",
                  "client_id": 1985,
                  "ip": "192.168.1.10", "vhost": "video.test.com", "app": "live"
              }
100 101 102 103
    if valid, the hook must return HTTP code 200(Stauts OK) and response
    an int value specifies the error code(0 corresponding to success):
          0
    '''
104
    def POST(self):
105
        enable_crossdomain()
106
107
        # return the error code in str
108
        code = Error.success
109 110 111

        req = cherrypy.request.body.read()
        trace("post to clients, req=%s"%(req))
112 113 114
        try:
            json_req = json.loads(req)
        except Exception, ex:
115 116 117
            code = Error.system_parse_json
            trace("parse the request to json failed, req=%s, ex=%s, code=%s"%(req, ex, code))
            return str(code)
118
119 120 121 122 123 124 125 126 127 128 129
        action = json_req["action"]
        if action == "on_connect":
            code = self.__on_connect(json_req)
        elif action == "on_close":
            code = self.__on_close(json_req)
        else:
            trace("invalid request action: %s"%(json_req["action"]))
            code = Error.request_invalid_action

        return str(code)
130
    def OPTIONS(self, *args, **kwargs):
131 132 133 134 135
        enable_crossdomain()

    def __on_connect(self, req):
        code = Error.success
136 137
        trace("srs %s: client id=%s, ip=%s, vhost=%s, app=%s, tcUrl=%s, pageUrl=%s"%(
            req["action"], req["client_id"], req["ip"], req["vhost"], req["app"], req["tcUrl"], req["pageUrl"]
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
        ))

        # TODO: process the on_connect event

        return code

    def __on_close(self, req):
        code = Error.success

        trace("srs %s: client id=%s, ip=%s, vhost=%s, app=%s"%(
            req["action"], req["client_id"], req["ip"], req["vhost"], req["app"]
        ))

        # TODO: process the on_close event

        return code

'''
handle the streams requests: publish/unpublish stream.
'''
class RESTStreams(object):
    exposed = True

    def GET(self):
        enable_crossdomain()

        streams = {}
        return json.dumps(streams)

    '''
    for SRS hook: on_publish/on_unpublish
    on_publish:
        when client(encoder) publish to vhost/app/stream, call the hook,
        the request in the POST data string is a object encode by json:
              {
                  "action": "on_publish",
                  "client_id": 1985,
                  "ip": "192.168.1.10", "vhost": "video.test.com", "app": "live",
                  "stream": "livestream"
              }
    on_unpublish:
        when client(encoder) stop publish to vhost/app/stream, call the hook,
        the request in the POST data string is a object encode by json:
              {
                  "action": "on_unpublish",
                  "client_id": 1985,
                  "ip": "192.168.1.10", "vhost": "video.test.com", "app": "live",
                  "stream": "livestream"
              }
    if valid, the hook must return HTTP code 200(Stauts OK) and response
    an int value specifies the error code(0 corresponding to success):
          0
    '''
    def POST(self):
        enable_crossdomain()

        # return the error code in str
        code = Error.success

        req = cherrypy.request.body.read()
        trace("post to streams, req=%s"%(req))
        try:
            json_req = json.loads(req)
        except Exception, ex:
            code = Error.system_parse_json
            trace("parse the request to json failed, req=%s, ex=%s, code=%s"%(req, ex, code))
            return str(code)

        action = json_req["action"]
        if action == "on_publish":
            code = self.__on_publish(json_req)
        elif action == "on_unpublish":
            code = self.__on_unpublish(json_req)
        else:
            trace("invalid request action: %s"%(json_req["action"]))
            code = Error.request_invalid_action

        return str(code)
217
    def OPTIONS(self, *args, **kwargs):
218 219 220 221 222 223 224
        enable_crossdomain()

    def __on_publish(self, req):
        code = Error.success

        trace("srs %s: client id=%s, ip=%s, vhost=%s, app=%s, stream=%s"%(
            req["action"], req["client_id"], req["ip"], req["vhost"], req["app"], req["stream"]
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 295 296 297 298 299 300
        # TODO: process the on_publish event

        return code

    def __on_unpublish(self, req):
        code = Error.success

        trace("srs %s: client id=%s, ip=%s, vhost=%s, app=%s, stream=%s"%(
            req["action"], req["client_id"], req["ip"], req["vhost"], req["app"], req["stream"]
        ))

        # TODO: process the on_unpublish event

        return code

'''
handle the sessions requests: client play/stop stream
'''
class RESTSessions(object):
    exposed = True

    def GET(self):
        enable_crossdomain()

        sessions = {}
        return json.dumps(sessions)

    '''
    for SRS hook: on_play/on_stop
    on_play:
        when client(encoder) publish to vhost/app/stream, call the hook,
        the request in the POST data string is a object encode by json:
              {
                  "action": "on_play",
                  "client_id": 1985,
                  "ip": "192.168.1.10", "vhost": "video.test.com", "app": "live",
                  "stream": "livestream"
              }
    on_stop:
        when client(encoder) stop publish to vhost/app/stream, call the hook,
        the request in the POST data string is a object encode by json:
              {
                  "action": "on_stop",
                  "client_id": 1985,
                  "ip": "192.168.1.10", "vhost": "video.test.com", "app": "live",
                  "stream": "livestream"
              }
    if valid, the hook must return HTTP code 200(Stauts OK) and response
    an int value specifies the error code(0 corresponding to success):
          0
    '''
    def POST(self):
        enable_crossdomain()

        # return the error code in str
        code = Error.success

        req = cherrypy.request.body.read()
        trace("post to sessions, req=%s"%(req))
        try:
            json_req = json.loads(req)
        except Exception, ex:
            code = Error.system_parse_json
            trace("parse the request to json failed, req=%s, ex=%s, code=%s"%(req, ex, code))
            return str(code)

        action = json_req["action"]
        if action == "on_play":
            code = self.__on_play(json_req)
        elif action == "on_stop":
            code = self.__on_stop(json_req)
        else:
            trace("invalid request action: %s"%(json_req["action"]))
            code = Error.request_invalid_action
301
302
        return str(code)
303
304
    def OPTIONS(self, *args, **kwargs):
305
        enable_crossdomain()
winlin authored
306
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
    def __on_play(self, req):
        code = Error.success

        trace("srs %s: client id=%s, ip=%s, vhost=%s, app=%s, stream=%s"%(
            req["action"], req["client_id"], req["ip"], req["vhost"], req["app"], req["stream"]
        ))

        # TODO: process the on_play event

        return code

    def __on_stop(self, req):
        code = Error.success

        trace("srs %s: client id=%s, ip=%s, vhost=%s, app=%s, stream=%s"%(
            req["action"], req["client_id"], req["ip"], req["vhost"], req["app"], req["stream"]
        ))

        # TODO: process the on_stop event

        return code
winlin authored
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360
global_arm_server_id = os.getpid();
class ArmServer:
    def __init__(self):
        global global_arm_server_id
        global_arm_server_id += 1
        
        self.id = str(global_arm_server_id)
        self.ip = None
        self.device_id = None
        
        self.public_ip = cherrypy.request.remote.ip
        self.heartbeat = time.time()
        
        self.clients = 0
    
    def dead(self):
        dead_time_seconds = 20
        if time.time() - self.heartbeat > dead_time_seconds:
            return True
        return False
    
    def json_dump(self):
        data = {}
        data["id"] = self.id
        data["ip"] = self.ip
        data["device_id"] = self.device_id
        data["public_ip"] = self.public_ip
        data["heartbeat"] = self.heartbeat
        data["heartbeat_h"] = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(self.heartbeat))
        data["summaries"] = "http://%s:1985/api/v1/summaries"%(self.ip)
        return data
        
361 362 363 364 365 366 367
'''
the server list
'''
class RESTServers(object):
    exposed = True
    
    def __init__(self):
winlin authored
368 369
        self.__nodes = []
        
winlin authored
370
        self.__last_update = datetime.datetime.now();
371 372
        
        self.__lock = threading.Lock()
winlin authored
373 374 375 376 377 378 379 380
        
    def __get_node(self, device_id):
        for node in self.__nodes:
            if node.device_id == device_id:
                return node
        return None
        
    def __refresh_nodes(self):
381
        while len(self.__nodes) > 0:
382
            has_dead_node = False
winlin authored
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
            for node in self.__nodes:
                if node.dead():
                    self.__nodes.remove(node)
                    has_dead_node = True
            if not has_dead_node:
                break

    def __json_dump_nodes(self, peers):
        data = []
        for node in peers:
            data.append(node.json_dump())
        return data

    def __get_peers_for_play(self, device_id):
        peers = []
        for node in self.__nodes:
            if node.device_id == device_id:
                peers.append(node)
        return peers
        
    def __select_peer(self, peers, device_id):
        target = None
        for peer in peers:
            if target is None or target.clients > peer.clients:
                target = peer
        if target is None:
            return None
        target.clients += 1
        return target.ip
412
winlin authored
413
    '''
winlin authored
414 415 416 417 418
    post to update server ip.
    request body: the new raspberry-pi server ip. TODO: FIXME: more info.
    '''
    def POST(self):
        enable_crossdomain()
419
        
winlin authored
420
        try:
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
            self.__lock.acquire()

            req = cherrypy.request.body.read()
            trace("post to nodes, req=%s"%(req))
            try:
                json_req = json.loads(req)
            except Exception, ex:
                code = Error.system_parse_json
                trace("parse the request to json failed, req=%s, ex=%s, code=%s"%(req, ex, code))
                return json.dumps({"code":code, "data": None})
                
            device_id = json_req["device_id"]
            node = self.__get_node(device_id)
            if node is None:
                node = ArmServer()
                self.__nodes.append(node)
                
            node.ip = json_req["ip"]
            node.device_id = device_id
            node.public_ip = cherrypy.request.remote.ip
            node.heartbeat = time.time()
winlin authored
442
            
443 444 445
            return json.dumps({"code":Error.success, "data": {"id":node.id}})
        finally:
            self.__lock.release()
winlin authored
446 447
    
    '''
winlin authored
448
    id canbe:
winlin authored
449
        pi: the pi demo, raspberry-pi default demo.
winlin authored
450
            device_id: the id of device to get.
451 452 453
            action: canbe play or mgmt, play to play the inest stream, mgmt to get api/v1/versions.
            stream: the stream to play, for example, live/livestream for http://server:8080/live/livestream.html
        meeting: the meeting demo. jump to web meeting if index is None.
winlin authored
454
            device_id: the id of device to get.
455 456
            local: whether view the local raspberry-pi stream. if "true", redirect to the local(internal) api server.
            index: the meeting stream index, dynamic get the streams from root.api.v1.chats.get_url_by_index(index)
winlin authored
457 458
        gslb: the gslb to get edge ip
            device_id: the id of device to get.
winlin authored
459
        ingest: deprecated, alias for pi.
winlin authored
460
    '''
winlin authored
461
    def GET(self, id=None, action="play", stream="live/livestream", index=None, local="false", device_id=None):
462
        enable_crossdomain()
winlin authored
463
        
464 465
        try:
            self.__lock.acquire()
winlin authored
466
        
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
            self.__refresh_nodes()
            data = self.__json_dump_nodes(self.__nodes)
            
            server_ip = "demo.chnvideo.com"
            ip = cherrypy.request.remote.ip
            if type is not None:
                peers = self.__get_peers_for_play(device_id)
                if len(peers) > 0:
                    server_ip = self.__select_peer(peers, device_id)
            
            # demo, srs meeting urls.
            if id == "meeting":
                if index is None:
                    url = "http://%s:8085"%(server_ip)
                elif local == "true":
                    url = "http://%s:8085/api/v1/servers?id=%s&index=%s&local=false"%(server_ip, id, index)
                else:
                    rtmp_url = root.api.v1.chats.get_url_by_index(index)
                    if rtmp_url is None:
                        return "meeting stream not found"
                    urls = rtmp_url.replace("...vhost...", "?vhost=").replace("rtmp://", "").split("/")
                    hls_url = "http://%s:8080/%s/%s.m3u8"%(urls[0].strip(":19350").strip(":1935"), urls[1].split("?")[0], urls[2])
                    return self.__generate_hls(hls_url)
            # raspberry-pi urls.
            elif id == "ingest" or id == "pi":
                if action == "play":
                    url = "http://%s:8080/%s.html"%(server_ip, stream)
                elif action == "rtmp":
                    url = "../../players/srs_player.html?server=%s&vhost=%s&app=%s&stream=%s&autostart=true"%(server_ip, server_ip, stream.split("/")[0], stream.split("/")[1])
                elif action == "hls":
                    hls_url = "http://%s:8080/%s.m3u8"%(server_ip, stream);
                    if stream.startswith("http://"):
                        hls_url = stream;
                    return self.__generate_hls(hls_url.replace(".m3u8.m3u8", ".m3u8"))
                else:
                    url = "http://%s:8080/api/v1/versions"%(server_ip)
            elif id == "gslb":
                return json.dumps({"code":Error.success, "data": {
                    "edge":server_ip, "client":ip, 
                    "peers":self.__json_dump_nodes(peers),
                    "streams": {
winlin authored
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
                        "pi": {
                            "livestream": {
                                "sales-pi-hls": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-sales-arm&stream=live/livestream",
                                "dev-pi-hls": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-dev-arm&stream=live/livestream"
                            },
                            "cztv": {
                                "sales-pi-hls": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-sales-arm&stream=live/rtmp_cztv01-sd",
                                "dev-pi-hls": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-dev-arm&stream=live/rtmp_cztv01-sd"
                            }
                        },
                        "hiwifi": {
                            "hls": {
                                "dev-livestream": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-dev-hiwifi&stream=live/livestream",
                                "sales-livestream": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-sales-hiwifi&stream=live/livestream"
                            },
                            "rtmp":{
                                "dev-livestream": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-dev-hiwifi&stream=live/livestream",
                                "sales-livestream": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-sales-hiwifi&stream=live/livestream"
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
                            },
                            "meiyi": {
                                "rtmp": {
                                    "avatar": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-sales-hiwifi&stream=live/avatar",
                                    "MenInBlack3": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-sales-hiwifi&stream=live/MenInBlack3",
                                    "skyfall": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-sales-hiwifi&stream=live/skyfall",
                                    "SpiderMan": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-sales-hiwifi&stream=live/SpiderMan",
                                    "thehobbit": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-sales-hiwifi&stream=live/thehobbit",
                                    "thorthedarkworld": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-sales-hiwifi&stream=live/thorthedarkworld",
                                    "transformers": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-sales-hiwifi&stream=live/transformers"
                                },
                                "hls": {
                                    "avatar": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-sales-hiwifi&stream=live/avatar",
                                    "MenInBlack3": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-sales-hiwifi&stream=live/MenInBlack3",
                                    "skyfall": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-sales-hiwifi&stream=live/skyfall",
                                    "SpiderMan": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-sales-hiwifi&stream=live/SpiderMan",
                                    "thehobbit": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-sales-hiwifi&stream=live/thehobbit",
                                    "thorthedarkworld": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-sales-hiwifi&stream=live/thorthedarkworld",
                                    "transformers": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-sales-hiwifi&stream=live/transformers"
                                }
winlin authored
546
                            }
winlin authored
547 548 549 550
                        },
                        "cubieboard": {
                            "meiyi": {
                                "rtmp": {
551 552 553 554 555 556 557 558
                                    "livesteam": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard&stream=live/livestream",
                                    "stream1": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard&stream=live/stream1",
                                    "stream2": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard&stream=live/stream2",
                                    "stream3": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard&stream=live/stream3",
                                    "stream4": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard&stream=live/stream4",
                                    "stream5": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard&stream=live/stream5",
                                    "stream6": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard&stream=live/stream6",
                                    "stream7": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard&stream=live/stream7"
winlin authored
559 560
                                },
                                "hls": {
561 562 563 564 565 566 567 568 569 570
                                    "livesteam": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard&stream=live/livestream",
                                    "stream1": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard&stream=live/stream1",
                                    "stream2": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard&stream=live/stream2",
                                    "stream3": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard&stream=live/stream3",
                                    "stream4": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard&stream=live/stream4",
                                    "stream5": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard&stream=live/stream5",
                                    "stream6": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard&stream=live/stream6",
                                    "stream7": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard&stream=live/stream7"
                                }
                            },
571 572 573 574 575 576 577 578
                            "meiyi-house": {
                                "rtmp": {
                                    "livesteam": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard-house&stream=live/livestream"
                                },
                                "hls": {
                                    "livesteam": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard-house&stream=live/livestream"
                                }
                            },
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
                            "meiyi-bk": {
                                "rtmp": {
                                    "livesteam": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/livestream",
                                    "stream1": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream1",
                                    "stream2": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream2",
                                    "stream3": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream3",
                                    "stream4": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream4",
                                    "stream5": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream5",
                                    "stream6": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream6",
                                    "stream7": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream7"
                                },
                                "hls": {
                                    "livesteam": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/livestream",
                                    "stream1": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream1",
                                    "stream2": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream2",
                                    "stream3": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream3",
                                    "stream4": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream4",
                                    "stream5": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream5",
                                    "stream6": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream6",
                                    "stream7": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard-bk&stream=live/stream7"
winlin authored
599
                                }
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
                            },
                            "meiyi-dev1": {
                                "rtmp": {
                                    "livesteam": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard-dev1&stream=live/livestream"
                                },
                                "hls": {
                                    "livesteam": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard-dev1&stream=live/livestream"
                                }
                            },
                            "meiyi-dev2": {
                                "rtmp": {
                                    "livesteam": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=rtmp&device_id=chnvideo-meiyi-cubieboard-dev2&stream=live/livestream"
                                },
                                "hls": {
                                    "livesteam": "http://demo.chnvideo.com:8085/api/v1/servers?id=ingest&action=hls&device_id=chnvideo-meiyi-cubieboard-dev2&stream=live/livestream"
                                }
winlin authored
616
                            }
winlin authored
617
                        }
618 619 620
                    }
                }})
            # others, default.
621
            else:
622 623 624 625 626
                return json.dumps(data)
            #return "id=%s, action=%s, stream=%s, url=%s, index=%s, local=%s"%(id, action, stream, url, index, local)
            raise cherrypy.HTTPRedirect(url)
        finally:
            self.__lock.release()
627 628 629 630 631 632 633 634 635

    def DELETE(self, id):
        enable_crossdomain()
        raise cherrypy.HTTPError(405, "Not allowed.")

    def PUT(self, id):
        enable_crossdomain()
        raise cherrypy.HTTPError(405, "Not allowed.")
636
    def OPTIONS(self, *args, **kwargs):
637
        enable_crossdomain()
winlin authored
638 639
    
    def __generate_hls(self, hls_url):
winlin authored
640 641 642 643
        return SrsUtility().hls_html(hls_url)

class SrsUtility:
    def hls_html(self, hls_url):
winlin authored
644
        return """
winlin authored
645
<h1>%s</h1>
winlin authored
646 647 648 649
<video width="640" height="360"
        autoplay controls autobuffer 
        src="%s"
        type="application/vnd.apple.mpegurl">
winlin authored
650 651 652 653 654 655 656 657 658 659
</video>"""%(hls_url, hls_url);

global_cdn_id = os.getpid();
class CdnNode:
    def __init__(self):
        global global_cdn_id
        global_cdn_id += 1
        
        self.id = str(global_cdn_id)
        self.ip = None
winlin authored
660
        self.origin = None
winlin authored
661 662 663 664 665
        self.os = None
        self.srs_status = None
        
        self.public_ip = cherrypy.request.remote.ip
        self.heartbeat = time.time()
666 667
        
        self.clients = 0
winlin authored
668 669 670 671 672 673 674 675 676 677 678
    
    def dead(self):
        dead_time_seconds = 10
        if time.time() - self.heartbeat > dead_time_seconds:
            return True
        return False
    
    def json_dump(self):
        data = {}
        data["id"] = self.id
        data["ip"] = self.ip
winlin authored
679
        data["origin"] = self.origin
winlin authored
680 681 682 683 684
        data["os"] = self.os
        data["srs_status"] = self.srs_status
        data["public_ip"] = self.public_ip
        data["heartbeat"] = self.heartbeat
        data["heartbeat_h"] = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(self.heartbeat))
685
        data["clients"] = self.clients
winlin authored
686
        data["summaries"] = "http://%s:1985/api/v1/summaries"%(self.ip)
winlin authored
687 688 689 690 691 692 693 694 695 696
        return data
        
'''
the cdn nodes list
'''
class RESTNodes(object):
    exposed = True
    
    def __init__(self):
        self.__nodes = []
697 698 699 700
        # @remark, if there is shared data, such as the self.__nodes,
        # we must use lock for cherrypy, or the cpu of cherrypy will high
        # and performance suffer.
        self.__lock = threading.Lock()
winlin authored
701 702 703 704 705 706 707 708
        
    def __get_node(self, id):
        for node in self.__nodes:
            if node.id == id:
                return node
        return None
        
    def __refresh_nodes(self):
709
        while len(self.__nodes) > 0:
710
            has_dead_node = False
winlin authored
711 712 713 714 715 716 717 718 719 720
            for node in self.__nodes:
                if node.dead():
                    self.__nodes.remove(node)
                    has_dead_node = True
            if not has_dead_node:
                break
    
    def __get_peers(self, target_node):
        peers = []
        for node in self.__nodes:
721
            if str(node.id).strip() == str(target_node.id).strip():
winlin authored
722
                continue
winlin authored
723
            if node.public_ip == target_node.public_ip and node.srs_status == "running" and node.origin != target_node.ip:
winlin authored
724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
                peers.append(node)
        return peers
        
    def __get_peers_for_play(self, ip):
        peers = []
        for node in self.__nodes:
            if node.public_ip == ip and node.srs_status == "running":
                peers.append(node)
        return peers

    def __json_dump_nodes(self, peers):
        data = []
        for node in peers:
            data.append(node.json_dump())
        return data
739 740 741 742 743 744 745 746 747 748
        
    def __select_peer(self, peers, ip):
        target = None
        for peer in peers:
            if target is None or target.clients > peer.clients:
                target = peer
        if target is None:
            return None
        target.clients += 1
        return target.ip
winlin authored
749
    
750
    def GET(self, type=None, format=None, origin=None, vhost=None, port=None, stream=None, node_id=None):
winlin authored
751 752
        enable_crossdomain()
        
753 754
        try:
            self.__lock.acquire()
winlin authored
755
        
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786
            self.__refresh_nodes()
            data = self.__json_dump_nodes(self.__nodes)
            
            ip = cherrypy.request.remote.ip
            if type is not None:
                server = origin
                peers = self.__get_peers_for_play(ip)
                if len(peers) > 0:
                    server = self.__select_peer(peers, ip)
                if type == "hls":
                    hls_url = "http://%s:%s/%s.m3u8"%(server, port, stream)
                    hls_url = hls_url.replace(".m3u8.m3u8", ".m3u8")
                    if format == "html":
                        return SrsUtility().hls_html(hls_url)
                    else:
                        #return hls_url
                        raise cherrypy.HTTPRedirect(hls_url)
                elif type == "rtmp":
                    rtmp_url = "rtmp://%s:%s/%s?vhost=%s/%s"%(server, port, stream.split("/")[0], vhost, stream.split("/")[1])
                    if format == "html":
                        html = "%s?server=%s&port=%s&vhost=%s&app=%s&stream=%s&autostart=true"%(
                            "http://demo.chnvideo.com:8085/srs/trunk/research/players/srs_player.html",
                            server, port, vhost, stream.split("/")[0], stream.split("/")[1])
                        #return html
                        raise cherrypy.HTTPRedirect(html)
                    return rtmp_url
                elif type == "gslb":
                    return json.dumps({"code":Error.success, "data": {
                        "edge":server, "client":ip, 
                        "peers":self.__json_dump_nodes(peers),
                        "streams": {
787 788 789 790 791 792 793 794
                            "cztv": {
                                "hls": "http://demo.chnvideo.com:8085/api/v1/nodes?type=hls&format=html&origin=demo.chnvideo.com&port=8080&stream=live/rtmp_cztv01-sd",
                                "rtmp": "http://demo.chnvideo.com:8085/api/v1/nodes?type=rtmp&format=html&origin=demo.chnvideo.com&vhost=android&port=1935&stream=live/rtmp_cztv01-sd"
                            },
                            "livestream": {
                                "hls": "http://demo.chnvideo.com:8085/api/v1/nodes?type=hls&format=html&origin=demo.chnvideo.com&port=8080&stream=live/livestream",
                                "rtmp": "http://demo.chnvideo.com:8085/api/v1/nodes?type=rtmp&format=html&origin=demo.chnvideo.com&vhost=demo.srs.com&port=1935&stream=live/livestream"
                            },
795 796 797 798 799 800 801
                            "apk": "http://demo.chnvideo.com/android.srs.apk"
                        }
                    }})
            
            return json.dumps({"code":Error.success, "data": data})
        finally:
            self.__lock.release()
winlin authored
802 803 804 805

    def PUT(self):
        enable_crossdomain()
        
806 807 808 809 810 811 812 813 814 815 816
        try:
            self.__lock.acquire()

            req = cherrypy.request.body.read()
            trace("put to nodes, req=%s"%(req))
            try:
                json_req = json.loads(req)
            except Exception, ex:
                code = Error.system_parse_json
                trace("parse the request to json failed, req=%s, ex=%s, code=%s"%(req, ex, code))
                return json.dumps({"code":code, "data": None})
winlin authored
817
            
818 819 820 821 822 823
            id = str(json_req["id"])
            node = self.__get_node(id)
            if node is None:
                code = Error.cdn_node_not_exists
                trace("cdn node not exists, req=%s, id=%s, code=%s"%(req, id, code))
                return json.dumps({"code":code, "data": None})
winlin authored
824
            
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
            node.heartbeat = time.time()
            node.srs_status = str(json_req["srs_status"])
            node.ip = str(json_req["ip"])
            if "origin" in json_req:
                node.origin = str(json_req["origin"]);
            node.public_ip = cherrypy.request.remote.ip
            # reset if restart.
            if node.srs_status != "running":
                node.clients = 0
                
            self.__refresh_nodes()
            peers = self.__get_peers(node)
            peers_data = self.__json_dump_nodes(peers)
                
            res = json.dumps({"code":Error.success, "data": {"id":node.id, "peers":peers_data}})
            trace(res)
            return res
        finally:
            self.__lock.release()
winlin authored
844 845 846

    def POST(self):
        enable_crossdomain()
847
        
winlin authored
848
        try:
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870
            self.__lock.acquire()

            req = cherrypy.request.body.read()
            trace("post to nodes, req=%s"%(req))
            try:
                json_req = json.loads(req)
            except Exception, ex:
                code = Error.system_parse_json
                trace("parse the request to json failed, req=%s, ex=%s, code=%s"%(req, ex, code))
                return json.dumps({"code":code, "data": None})
                
            node = CdnNode()
            node.ip = str(json_req["ip"]);
            node.os = str(json_req["os"]);
            if "origin" in json_req:
                node.origin = str(json_req["origin"]);
            node.srs_status = str(json_req["srs_status"])
            self.__nodes.append(node)
                
            self.__refresh_nodes()
            peers = self.__get_peers(node)
            peers_data = self.__json_dump_nodes(peers)
winlin authored
871
            
872 873 874 875 876
            res = json.dumps({"code":Error.success, "data": {"id":node.id, "peers":peers_data}})
            trace(res)
            return res
        finally:
            self.__lock.release()
winlin authored
877 878 879
        
    def OPTIONS(self, *args, **kwargs):
        enable_crossdomain()
880
winlin authored
881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903
global_chat_id = os.getpid();
'''
the chat streams, public chat room.
'''
class RESTChats(object):
    exposed = True
    global_id = 100
    
    def __init__(self):
        # object fields:
        # id: an int value indicates the id of user.
        # username: a str indicates the user name.
        # url: a str indicates the url of user stream.
        # agent: a str indicates the agent of user.
        # join_date: a number indicates the join timestamp in seconds.
        # join_date_str: a str specifies the formated friendly time.
        # heatbeat: a number indicates the heartbeat timestamp in seconds.
        # vcodec: a dict indicates the video codec info.
        # acodec: a dict indicates the audio codec info.
        self.__chats = [];
        self.__chat_lock = threading.Lock();

        # dead time in seconds, if exceed, remove the chat.
904
        self.__dead_time = 15;
905 906 907 908 909 910 911 912 913
    
    '''
    get the rtmp url of chat object. None if overflow.
    '''
    def get_url_by_index(self, index):
        index = int(index)
        if index is None or index >= len(self.__chats):
            return None;
        return self.__chats[index]["url"];
winlin authored
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002

    def GET(self):
        enable_crossdomain()

        try:
            self.__chat_lock.acquire();

            chats = [];
            copy = self.__chats[:];
            for chat in copy:
                if time.time() - chat["heartbeat"] > self.__dead_time:
                    self.__chats.remove(chat);
                    continue;

                chats.append({
                    "id": chat["id"],
                    "username": chat["username"],
                    "url": chat["url"],
                    "join_date_str": chat["join_date_str"],
                    "heartbeat": chat["heartbeat"],
                });
        finally:
            self.__chat_lock.release();
            
        return json.dumps({"code":0, "data": {"now": time.time(), "chats": chats}})
        
    def POST(self):
        enable_crossdomain()
        
        req = cherrypy.request.body.read()
        chat = json.loads(req)

        global global_chat_id;
        chat["id"] = global_chat_id
        global_chat_id += 1

        chat["join_date"] = time.time();
        chat["heartbeat"] = time.time();
        chat["join_date_str"] = time.strftime("%Y-%m-%d %H:%M:%S");

        try:
            self.__chat_lock.acquire();

            self.__chats.append(chat)
        finally:
            self.__chat_lock.release();

        trace("create chat success, id=%s"%(chat["id"]))
        
        return json.dumps({"code":0, "data": chat["id"]})

    def DELETE(self, id):
        enable_crossdomain()

        try:
            self.__chat_lock.acquire();

            for chat in self.__chats:
                if str(id) != str(chat["id"]):
                    continue

                self.__chats.remove(chat)
                trace("delete chat success, id=%s"%(id))

                return json.dumps({"code":0, "data": None})
        finally:
            self.__chat_lock.release();

        raise cherrypy.HTTPError(405, "Not allowed.")

    def PUT(self, id):
        enable_crossdomain()

        try:
            self.__chat_lock.acquire();

            for chat in self.__chats:
                if str(id) != str(chat["id"]):
                    continue

                chat["heartbeat"] = time.time();
                trace("heartbeat chat success, id=%s"%(id))

                return json.dumps({"code":0, "data": None})
        finally:
            self.__chat_lock.release();

        raise cherrypy.HTTPError(405, "Not allowed.")
1003
    def OPTIONS(self, *args, **kwargs):
winlin authored
1004 1005
        enable_crossdomain()
winlin authored
1006
# HTTP RESTful path.
winlin authored
1007
class Root(object):
winlin authored
1008 1009
    exposed = True
winlin authored
1010 1011
    def __init__(self):
        self.api = Api()
winlin authored
1012 1013 1014 1015 1016
    def GET(self):
        enable_crossdomain();
        return json.dumps({"code":Error.success, "urls":{"api":"the api root"}})
    def OPTIONS(self, *args, **kwargs):
        enable_crossdomain();
winlin authored
1017
# HTTP RESTful path.
winlin authored
1018
class Api(object):
winlin authored
1019 1020
    exposed = True
winlin authored
1021 1022
    def __init__(self):
        self.v1 = V1()
winlin authored
1023 1024 1025 1026 1027 1028 1029 1030 1031
    def GET(self):
        enable_crossdomain();
        return json.dumps({"code":Error.success, 
            "urls": {
                "v1": "the api version 1.0"
            }
        });
    def OPTIONS(self, *args, **kwargs):
        enable_crossdomain();
winlin authored
1032 1033
# HTTP RESTful path. to access as:
#   http://127.0.0.1:8085/api/v1/clients
winlin authored
1034
class V1(object):
winlin authored
1035 1036
    exposed = True
winlin authored
1037 1038
    def __init__(self):
        self.clients = RESTClients()
1039 1040
        self.streams = RESTStreams()
        self.sessions = RESTSessions()
winlin authored
1041
        self.chats = RESTChats()
1042
        self.servers = RESTServers()
winlin authored
1043
        self.nodes = RESTNodes()
winlin authored
1044 1045 1046 1047 1048 1049 1050
    def GET(self):
        enable_crossdomain();
        return json.dumps({"code":Error.success, "urls":{
            "clients": "for srs http callback, to handle the clients requests: connect/disconnect vhost/app.", 
            "streams": "for srs http callback, to handle the streams requests: publish/unpublish stream.",
            "sessions": "for srs http callback, to handle the sessions requests: client play/stop stream",
            "chats": "for srs demo meeting, the chat streams, public chat room.",
winlin authored
1051 1052 1053 1054
            "nodes": {
                "summary": "for srs cdn node",
                "POST ip=node_ip&os=node_os": "register a new node",
                "GET": "get the active edge nodes",
winlin authored
1055
                "GET type=gslb&origin=demo.chnvideo.com": "get the gslb edge ip",
winlin authored
1056 1057 1058
                "GET type=hls&format=html&origin=demo.chnvideo.com&port=8080&stream=live/livestream": "get the play url, html for hls",
                "GET type=rtmp&format=html&origin=demo.chnvideo.com&vhost=demo.srs.com&port=1935&stream=live/livestream": "get the play url, for rtmp"
            },
winlin authored
1059 1060 1061
            "servers": {
                "summary": "for srs raspberry-pi and meeting demo",
                "GET": "get the current raspberry-pi servers info",
winlin authored
1062 1063
                "GET id=gslb&device_id=chnvideo-sales-arm": "get the gslb edge ip",
                "POST ip=node_ip&device_id=device_id": "the new raspberry-pi server info.",
winlin authored
1064
                "GET id=ingest&action=play&stream=live/livestream": "play the ingest HLS stream on raspberry-pi",
1065
                "GET id=ingest&action=rtmp&stream=live/livestream": "play the ingest RTMP stream on raspberry-pi",
winlin authored
1066
                "GET id=ingest&action=hls&stream=live/livestream": "play the ingest HLS stream on raspberry-pi",
winlin authored
1067 1068 1069 1070 1071 1072 1073 1074
                "GET id=ingest&action=mgmt": "open the HTTP api url of raspberry-pi",
                "GET id=meeting": "redirect to local raspberry-pi meeting url(local ignored)",
                "GET id=meeting&local=false&index=0": "play the first(index=0) meeting HLS stream on demo.chnvideo.com(not local)",
                "GET id=meeting&local=true&index=0": "play the first(index=0) meeting HLS stream on local server(local x86/x64 server), warn: raspberry-pi donot support HLS meeting."
            }
        }});
    def OPTIONS(self, *args, **kwargs):
        enable_crossdomain();
winlin authored
1075
winlin authored
1076 1077 1078 1079 1080
'''
main code start.
'''
# donot support use this module as library.
if __name__ != "__main__":
1081
    raise Exception("embed not support")
winlin authored
1082 1083 1084

# check the user options
if len(sys.argv) <= 1:
1085
    print "SRS api callback server, Copyright (c) 2013-2014 winlin"
winlin authored
1086 1087 1088 1089 1090 1091 1092 1093 1094
    print "Usage: python %s <port>"%(sys.argv[0])
    print "    port: the port to listen at."
    print "For example:"
    print "    python %s 8085"%(sys.argv[0])
    print ""
    print "See also: https://github.com/winlinvip/simple-rtmp-server"
    sys.exit(1)

# parse port from user options.
winlin authored
1095
port = int(sys.argv[1])
1096 1097
static_dir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), "static-dir"))
trace("api server listen at port: %s, static_dir: %s"%(port, static_dir))
winlin authored
1098
winlin authored
1099
# cherrypy config.
winlin authored
1100 1101 1102 1103 1104 1105
conf = {
    'global': {
        'server.shutdown_timeout': 1,
        'server.socket_host': '0.0.0.0',
        'server.socket_port': port,
        'tools.encode.on': True,
1106
        'tools.staticdir.on': True,
1107
        'tools.encode.encoding': "utf-8",
1108
        #'server.thread_pool': 2, # single thread server.
winlin authored
1109 1110
    },
    '/': {
1111 1112
        'tools.staticdir.dir': static_dir,
        'tools.staticdir.index': "index.html",
winlin authored
1113
        # for cherrypy RESTful api support
winlin authored
1114 1115 1116 1117
        'request.dispatch': cherrypy.dispatch.MethodDispatcher()
    }
}
winlin authored
1118
# start cherrypy web engine
winlin authored
1119
trace("start cherrypy server")
1120 1121 1122
root = Root()
cherrypy.quickstart(root, '/', conf)