class WebRTCGatewayWeb(object):
__metaclass__ = Singleton
app = Klein()
_resource = None
_ws_resource = None
def __init__(self, ws_factory):
self._ws_resource = WebSocketResource(ws_factory)
def resource(self):
if self._resource is None:
self._resource = self.app.resource()
return self._resource
@app.route('/')
def index(self, request):
path = Resources.get('html/webrtcgateway/index.html')
r = StaticFileResource(path)
r.isLeaf = True
return r
@app.route('/ws')
def ws(self, request):
return self._ws_resource
@app.route('/js/', branch=True)
def js(self, request):
path = Resources.get('html/webrtcgateway/js/')
return StaticFileResource(path)
@app.route('/test/', branch=True)
def test(self, request):
path = Resources.get('html/webrtcgateway/test/')
return StaticFileResource(path)
class AdminWebHandler(object):
__metaclass__ = Singleton
app = Klein()
def __init__(self):
self.listener = None
def start(self):
host, port = GeneralConfig.http_management_interface
# noinspection PyUnresolvedReferences
self.listener = reactor.listenTCP(port, Site(self.app.resource()), interface=host)
log.info('Admin web handler started at http://%s:%d' % (host, port))
def stop(self):
if self.listener is not None:
self.listener.stopListening()
self.listener = None
# Admin web API
def _check_auth(self, request):
auth_secret = GeneralConfig.http_management_auth_secret
if auth_secret:
auth_headers = request.requestHeaders.getRawHeaders('Authorization', default=None)
if not auth_headers or auth_headers[0] != auth_secret:
raise AuthError()
@app.handle_errors(AuthError)
def auth_error(self, request, failure):
request.setResponseCode(403)
return 'Authentication error'
@app.route('/tokens/<string:account>')
def get_tokens(self, request, account):
self._check_auth(request)
request.setHeader('Content-Type', 'application/json')
storage = TokenStorage()
tokens = storage[account]
if isinstance(tokens, defer.Deferred):
return tokens.addCallback(lambda result: json.dumps({'tokens': result}))
else:
return json.dumps({'tokens': tokens})
@app.route('/tokens/<string:account>/<string:device_token>', methods=['DELETE'])
def process_token(self, request, account, device_token):
self._check_auth(request)
request.setHeader('Content-Type', 'application/json')
storage = TokenStorage()
if request.method == 'DELETE':
storage.remove(account, device_token)
return json.dumps({'success': True})
class WebRTCGatewayWeb(object):
__metaclass__ = Singleton
app = Klein()
def __init__(self, ws_factory):
self._resource = self.app.resource()
self._ws_resource = WebSocketResource(ws_factory)
@property
def resource(self):
return self._resource
@app.route('/', branch=True)
def index(self, request):
return StaticFileResource(Resources.get('html/webrtcgateway/'))
@app.route('/ws')
def ws(self, request):
return self._ws_resource
class AdminWebHandler(object):
__metaclass__ = Singleton
app = Klein()
def __init__(self):
self.listener = None
def start(self):
host, port = GeneralConfig.http_management_interface
# noinspection PyUnresolvedReferences
self.listener = reactor.listenTCP(port, Site(self.app.resource()), interface=host)
log.info('Admin web handler started at http://%s:%d' % (host, port))
def stop(self):
if self.listener is not None:
self.listener.stopListening()
self.listener = None
# Admin web API
def _check_auth(self, request):
auth_secret = GeneralConfig.http_management_auth_secret
if auth_secret:
auth_headers = request.requestHeaders.getRawHeaders('Authorization', default=None)
if not auth_headers or auth_headers[0] != auth_secret:
raise AuthError()
@app.handle_errors(AuthError)
def auth_error(self, request, failure):
request.setResponseCode(403)
return 'Authentication error'
@app.route('/incoming_session', methods=['POST'])
def incoming_session(self, request):
self._check_auth(request)
request.setHeader('Content-Type', 'application/json')
try:
data = json.load(request.content)
originator = data['originator']
destination = data['destination']
except Exception as e:
return json.dumps({'success': False, 'error': str(e)})
else:
storage = TokenStorage()
tokens = storage[destination]
push.incoming_session(originator, destination, tokens)
return json.dumps({'success': True})
@app.route('/missed_session', methods=['POST'])
def missed_session(self, request):
self._check_auth(request)
request.setHeader('Content-Type', 'application/json')
try:
data = json.load(request.content)
originator = data['originator']
destination = data['destination']
except Exception as e:
return json.dumps({'success': False, 'error': str(e)})
else:
storage = TokenStorage()
tokens = storage[destination]
push.missed_session(originator, destination, tokens)
return json.dumps({'success': True})
@app.route('/tokens/<string:account>')
def get_tokens(self, request, account):
self._check_auth(request)
request.setHeader('Content-Type', 'application/json')
storage = TokenStorage()
tokens = storage[account]
return json.dumps({'tokens': list(tokens)})
@app.route('/tokens/<string:account>/<string:token>', methods=['POST', 'DELETE'])
def process_token(self, request, account, token):
self._check_auth(request)
request.setHeader('Content-Type', 'application/json')
storage = TokenStorage()
if request.method == 'POST':
storage.add(account, token)
elif request.method == 'DELETE':
storage.remove(account, token)
return json.dumps({'success': True})
class WebRTCGatewayWeb(object):
__metaclass__ = Singleton
app = Klein()
def __init__(self, ws_factory):
self._resource = self.app.resource()
self._ws_resource = WebSocketResource(ws_factory)
self._ws_factory = ws_factory
@property
def resource(self):
return self._resource
@app.route('/', branch=True)
def index(self, request):
return StaticFileResource(Resources.get('html/webrtcgateway/'))
@app.route('/ws')
def ws(self, request):
return self._ws_resource
@app.route('/filesharing/<string:conference>/<string:session_id>/<string:filename>', methods=['OPTIONS', 'POST', 'GET'])
def filesharing(self, request, conference, session_id, filename):
conference_uri = conference.lower()
if conference_uri in self._ws_factory.videorooms:
videoroom = self._ws_factory.videorooms[conference_uri]
if session_id in videoroom:
request.setHeader('Access-Control-Allow-Origin', '*')
request.setHeader('Access-Control-Allow-Headers', 'content-type')
method = request.method.upper()
session = videoroom[session_id]
if method == 'POST':
def log_result(result):
if isinstance(result, Failure):
videoroom.log.warning('{file.uploader.uri} failed to upload {file.filename}: {error}'.format(file=upload_request.shared_file, error=result.value))
else:
videoroom.log.info('{file.uploader.uri} has uploaded {file.filename}'.format(file=upload_request.shared_file))
return result
filename = secure_filename(filename)
filesize = int(request.getHeader('Content-Length'))
shared_file = sylkrtc.SharedFile(filename=filename, filesize=filesize, uploader=dict(uri=session.account.id, display_name=session.account.display_name), session=session_id)
session.owner.log.info('wants to upload file {filename} to video room {conference_uri} with session {session_id}'.format(filename=filename, conference_uri=conference_uri, session_id=session_id))
upload_request = FileUploadRequest(shared_file, request.content)
videoroom.add_file(upload_request)
upload_request.deferred.addBoth(log_result)
return upload_request.deferred
elif method == 'GET':
filename = secure_filename(filename)
session.owner.log.info('wants to download file {filename} from video room {conference_uri} with session {session_id}'.format(filename=filename, conference_uri=conference_uri, session_id=session_id))
try:
path = videoroom.get_file(filename)
except LookupError as e:
videoroom.log.warning('{session.account.id} failed to download {filename}: {error}'.format(session=session, filename=filename, error=e))
raise NotFound()
else:
videoroom.log.info('{session.account.id} is downloading {filename}'.format(session=session, filename=filename))
request.setHeader('Content-Disposition', 'attachment;filename=%s' % filename)
return File(path)
else:
return 'OK'
raise Forbidden()
class ConferenceWeb(object):
__metaclass__ = Singleton
app = Klein()
screensharing_template = """
<html>
<head>
<title>SylkServer Screen Sharing</title>
</head>
<script type="text/javascript">
var today = new Date();
var c = today.getTime();
function reloadScreen() {
document.screenImage.src = "%(image)s" + "?" + c;
c = c + 1;
}
function startTimer() {
setTimeout('reloadScreen()', 1000);
}
</script>
<body bgcolor="#999999">
<div>
<img src='%(image)s' name='screenImage' onload='startTimer()' style='position: relative; top: 0px; margin: 0px 0px 0px 0px; clear: both; float: left; %(width)s' />
</div>
</body>
</html>
"""
def __init__(self, conference):
self._resource = self.app.resource()
self.conference = conference
@property
def resource(self):
return self._resource
@app.route('/')
def home(self, request):
return NoResource('Nothing to see here, move along.')
@app.route('/<string:room_uri>')
def room(self, request, room_uri):
return NoResource('Nothing to see here, move along.')
@app.route('/<string:room_uri>/screensharing')
def scheensharing(self, request, room_uri):
try:
room = self.conference._rooms[room_uri]
except KeyError:
return NoResource('Room not found')
request.setHeader('Content-Type', 'text/html; charset=utf-8')
if 'image' not in request.args or not request.args.get(
'image', [''])[0].endswith('jpg'):
return ErrorPage(400, 'Bad Request', '\"image\" not provided')
images_path = os.path.join(ConferenceConfig.screensharing_images_dir,
room.uri)
image_path = os.path.basename(urllib.unquote(request.args['image'][0]))
if not os.path.isfile(os.path.join(images_path, image_path)):
return NoResource('Image not found')
image = os.path.join('screensharing_img', image_path)
width = 'width: 100%' if 'fit' in request.args else ''
return self.screensharing_template % dict(image=image, width=width)
@app.route('/<string:room_uri>/screensharing_img/<string:filename>')
def screensharing_image(self, request, room_uri, filename):
try:
room = self.conference._rooms[room_uri]
except KeyError:
return NoResource('Room not found')
images_path = os.path.join(ConferenceConfig.screensharing_images_dir,
room.uri)
return File(os.path.join(images_path, os.path.basename(filename)))