def render_POST(self, request):
response = {}
logger.info('Received a new request from the client')
try :
# process the message encoding
encoding = request.getHeader('Content-Type')
data = request.content.read()
if encoding == 'application/json' :
try:
input_json_str = json.loads(data.decode('utf-8'))
input_json = json.loads(input_json_str)
jrpc_id = input_json["id"]
response = self._process_request(input_json_str)
except AttributeError:
logger.error("Error while loading input json")
response = utility.create_error_response(
WorkorderError.UNKNOWN_ERROR,
jrpc_id,
"UNKNOWN_ERROR: Error while loading the input JSON file")
return response
else :
# JRPC response with 0 as id is returned because id can't be fecthed
# from a request with unknown encoding
response = utility.create_error_response(
WorkorderError.UNKNOWN_ERROR,
0,
"UNKNOWN_ERROR: unknown message encoding")
return response
except :
logger.exception('exception while decoding http request %s', request.path)
# JRPC response with 0 as id is returned because id can't be
# fetched from improper request
response = utility.create_error_response(
WorkorderError.UNKNOWN_ERROR,
0,
"UNKNOWN_ERROR: unable to decode incoming request")
return response
# send back the results
try :
if encoding == 'application/json' :
response = json.dumps(response)
logger.info('response[%s]: %s', encoding, response)
request.setHeader('content-type', encoding)
request.setResponseCode(http.OK)
return response.encode('utf8')
except :
logger.exception('unknown exception while processing request %s', request.path)
response = utility.create_error_response(
WorkorderError.UNKNOWN_ERROR,
jrpc_id,
"UNKNOWN_ERROR: unknown exception processing http \
request {0}".format(request.path))
return response
def render_POST(self, request):
response = ""
logger.info('Received a new request from the client')
try:
# Process the message encoding
encoding = request.getHeader('Content-Type')
data = request.content.read().decode('utf-8')
if encoding == 'text/plain; charset=utf-8':
response = self._process_request(data)
else:
response = 'UNKNOWN_ERROR: unknown message encoding'
return response
except:
logger.exception('exception while decoding http request %s',
request.path)
response = 'UNKNOWN_ERROR: unable to decode incoming request '
return response
# Send back the results
try:
logger.info('response[%s]: %s', encoding, response.encode('utf-8'))
request.setHeader('content-type', encoding)
request.setResponseCode(http.OK)
return response.encode('utf-8')
except:
logger.exception('unknown exception while processing request %s',
request.path)
response = 'UNKNOWN_ERROR: unknown exception processing ' + \
'http request {0}'.format(request.path)
return response
def got_item(ch):
if ch is not None:
request.setResponseCode(200)
file = ch.get_cover()
if file and os.path.exists(file):
self.info("got cover %s", file)
return StaticFile(file)
request.setResponseCode(404)
return static.Data(
'<html><p>cover requested not found</p></html>',
'text/html')
def render_POST(self, request):
response = {}
response['error'] = {}
response['error']['code'] = WorkorderError.UNKNOWN_ERROR
logger.info('Received a new request from the client')
try:
# process the message encoding
encoding = request.getHeader('Content-Type')
data = request.content.read()
if encoding == 'application/json':
try:
input_json = json.loads(data.decode('utf-8'))
response = self._process_request(input_json)
except AttributeError:
logger.error("Error while loading input json")
response['error'][
'message'] = 'UNKNOWN_ERROR: Error while loading the input JSON file'
return response
else:
response['error'][
'message'] = 'UNKNOWN_ERROR: unknown message encoding'
return response
except:
logger.exception('exception while decoding http request %s',
request.path)
response['error'][
'message'] = 'UNKNOWN_ERROR: unable to decode incoming request '
return response
# send back the results
try:
if encoding == 'application/json':
response = json.dumps(response)
logger.info('response[%s]: %s', encoding, response)
request.setHeader('content-type', encoding)
request.setResponseCode(http.OK)
return response.encode('utf8')
except:
logger.exception('unknown exception while processing request %s',
request.path)
response['error'][
'message'] = 'UNKNOWN_ERROR: unknown exception processing http request {0}'.format(
request.path)
return response
def render_GET(self, request):
global config
debug("Request '%s'" % request.uri.decode("utf-8"))
try:
resp = urllib.request.urlopen(
'http://%s:%d%s' %
(config['mip']['host'], int(config['mip']['port']),
fixPaths(request.uri, 'lms', 'mip').decode("utf-8"))).read()
return fixPaths(resp, 'mip', 'lms')
except urllib.error.HTTPError as e:
request.setResponseCode(e.code)
return e.read()
def got_file(ch):
print("ch", ch)
if ch is not None:
if hasattr(self.store, 'backend_import'):
response_code = self.store.backend_import(
ch, request.content)
if isinstance(response_code, defer.Deferred):
return response_code
request.setResponseCode(response_code)
return
else:
request.setResponseCode(404)
def render_GET(self, request):
self.info(f'render GET {request}')
request.setResponseCode(200)
if self.contentType is not None:
request.setHeader(b'Content-Type', self.contentType)
request.write(b'')
headers = request.getAllHeaders()
if ('connection' in headers and headers['connection'] == 'close'):
pass
self.start(request)
return server.NOT_DONE_YET
def render_GET(self, request):
self.info('render GET %r', request)
request.setResponseCode(200)
if hasattr(self, 'contentType'):
request.setHeader('Content-Type', self.contentType)
request.write('')
headers = request.getAllHeaders()
if ('connection' in headers and headers['connection'] == 'close'):
pass
self.start(request)
return server.NOT_DONE_YET
def got_stuff_to_transcode(ch):
#FIXME create a generic transcoder class and sort the details there
format = request.uri.split('/')[
-1] # request.args['transcoded'][0]
uri = ch.get_path()
try:
from coherence.transcoder import TranscoderManager
manager = TranscoderManager(self.server.coherence)
return manager.select(format, uri)
except:
self.debug(traceback.format_exc())
request.setResponseCode(404)
return static.Data(
'<html><p>the requested transcoded file was not found</p></html>',
'text/html')
def got_streams(streams):
if self.stream_id not in streams:
self.warning("stream not found for %s@%s", self.url, self.stream_id)
request.setResponseCode(http.NOT_FOUND)
request.write('')
return
request.setHeader('Content-Type', self.content_type)
request.setResponseCode(http.OK)
if request.method == 'HEAD':
request.write('')
return
d_open_stream = threads.deferToThread(streams[self.stream_id].open)
d_open_stream.addCallback(stream_opened)
def got_streams(streams):
if self.stream_id not in streams:
self.warning(f'stream not found for '
f'{self.url}@{self.stream_id}')
request.setResponseCode(http.NOT_FOUND)
request.write(b'')
return
request.setHeader(b'Content-Type',
self.content_type.encode('ascii'))
request.setResponseCode(http.OK)
if request.method == b'HEAD':
request.write(b'')
return
d_open_stream = threads.deferToThread(streams[self.stream_id].open)
d_open_stream.addCallback(stream_opened)
def render_GET(self, request):
self.info(f'render GET {request}')
request.setResponseCode(200)
if hasattr(self, 'contentType'):
request.setHeader(b'Content-Type', self.contentType)
request.write(b'')
headers = request.getAllHeaders()
if ('connection' in headers and headers['connection'] == 'close'):
pass
if self.requests:
if self.streamheader:
self.debug('writing streamheader')
for h in self.streamheader:
request.write(h.data)
self.requests.append(request)
else:
self.parse_pipeline()
self.start(request)
return server.NOT_DONE_YET
def got_attachment(ch):
try:
# FIXME same as below
if 'transcoded' in request.args:
if (
self.server.coherence.config.get(
'transcoding', 'no'
)
== 'yes'
):
format = request.args['transcoded'][0]
type = request.args['type'][0]
self.info(
f'request transcoding {format} {type}'
)
try:
from coherence.transcoder import (
TranscoderManager,
)
manager = TranscoderManager(
self.server.coherence
)
return manager.select(
format,
ch.item.attachments[
request.args['attachment'][0]
],
)
except Exception:
self.debug(traceback.format_exc())
request.setResponseCode(404)
return static.Data(
b'<html><p>the requested transcoded file '
b'was not found</p></html>',
'text/html',
)
else:
request.setResponseCode(404)
return static.Data(
b'<html><p>This MediaServer '
b'doesn\'t support transcoding</p></html>',
'text/html',
)
else:
return ch.item.attachments[
request.args['attachment'][0]
]
except Exception:
request.setResponseCode(404)
return static.Data(
b'<html><p>the requested attachment '
b'was not found</p></html>',
'text/html',
)
def got_attachment(ch):
try:
#FIXME same as below
if 'transcoded' in request.args:
if self.server.coherence.config.get(
'transcoding', 'no') == 'yes':
format = request.args['transcoded'][0]
type = request.args['type'][0]
self.info("request transcoding %r %r", format,
type)
try:
from coherence.transcoder import TranscoderManager
manager = TranscoderManager(
self.server.coherence)
return manager.select(
format, ch.item.attachments[
request.args['attachment'][0]])
except:
self.debug(traceback.format_exc())
request.setResponseCode(404)
return static.Data(
'<html><p>the requested transcoded file was not found</p></html>',
'text/html')
else:
request.setResponseCode(404)
return static.Data(
"<html><p>This MediaServer doesn't support transcoding</p></html>",
'text/html')
else:
return ch.item.attachments[
request.args['attachment'][0]]
except:
request.setResponseCode(404)
return static.Data(
'<html><p>the requested attachment was not found</p></html>',
'text/html')
def getChildWithDefault(self, path, request):
self.info(
f'{self.server.device_type} getChildWithDefault, '
f'{request.method}, {path}, {request.uri} {request.client}'
)
headers = request.getAllHeaders()
self.debug(f'\t-> headers are: {headers}')
if not isinstance(path, bytes):
path = path.encode('ascii')
if path.endswith(b'\''):
self.warning(f'\t modified wrong path from {path} to {path[:-1]}')
path = path[:-1]
self.debug(f'\t-> path is: {path} [{type(path)}]')
try:
if (
b'getcontentfeatures.dlna.org' in headers
and headers[b'getcontentfeatures.dlna.org'] != b'1'
):
request.setResponseCode(400)
return static.Data(
b'<html><p>wrong value for '
b'getcontentFeatures.dlna.org</p></html>',
'text/html',
)
except Exception as e1:
self.error(f'MSRoot.getChildWithDefault: {e1}')
if request.method == b'HEAD':
if b'getcaptioninfo.sec' in headers:
self.warning(f'requesting srt file for id {path}')
ch = self.store.get_by_id(path)
try:
location = ch.get_path()
caption = ch.caption
if caption is None:
raise KeyError
request.setResponseCode(200)
request.setHeader(b'CaptionInfo.sec', caption)
return static.Data(b'', 'text/html')
except Exception as e2:
self.error(
f'MSRoot.getChildWithDefault (method: HEAD): {e2}'
)
print(traceback.format_exc())
request.setResponseCode(404)
return static.Data(
b'<html><p>the requested srt file '
b'was not found</p></html>',
'text/html',
)
try:
request._dlna_transfermode = headers[b'transfermode.dlna.org']
except KeyError:
request._dlna_transfermode = b'Streaming'
if request.method in (b'GET', b'HEAD'):
if COVER_REQUEST_INDICATOR.match(request.uri.decode('utf-8')):
self.info(f'request cover for id {path}')
def got_item(ch):
if ch is not None:
request.setResponseCode(200)
file = ch.get_cover()
if file and os.path.exists(file):
self.info(f'got cover {file}')
return StaticFile(file)
request.setResponseCode(404)
return static.Data(
b'<html><p>cover requested not found</p></html>',
'text/html',
)
dfr = defer.maybeDeferred(self.store.get_by_id, path)
dfr.addCallback(got_item)
dfr.isLeaf = True
return dfr
if ATTACHMENT_REQUEST_INDICATOR.match(request.uri.decode('utf-8')):
self.info(f'request attachment {request.args} for id {path}')
def got_attachment(ch):
try:
# FIXME same as below
if 'transcoded' in request.args:
if (
self.server.coherence.config.get(
'transcoding', 'no'
)
== 'yes'
):
format = request.args['transcoded'][0]
type = request.args['type'][0]
self.info(
f'request transcoding {format} {type}'
)
try:
from coherence.transcoder import (
TranscoderManager,
)
manager = TranscoderManager(
self.server.coherence
)
return manager.select(
format,
ch.item.attachments[
request.args['attachment'][0]
],
)
except Exception:
self.debug(traceback.format_exc())
request.setResponseCode(404)
return static.Data(
b'<html><p>the requested transcoded file '
b'was not found</p></html>',
'text/html',
)
else:
request.setResponseCode(404)
return static.Data(
b'<html><p>This MediaServer '
b'doesn\'t support transcoding</p></html>',
'text/html',
)
else:
return ch.item.attachments[
request.args['attachment'][0]
]
except Exception:
request.setResponseCode(404)
return static.Data(
b'<html><p>the requested attachment '
b'was not found</p></html>',
'text/html',
)
dfr = defer.maybeDeferred(self.store.get_by_id, path)
dfr.addCallback(got_attachment)
dfr.isLeaf = True
return dfr
if request.method in (
b'GET',
b'HEAD',
) and TRANSCODED_REQUEST_INDICATOR.match(request.uri.decode('utf-8')):
self.info(
f'request transcoding to '
f'{request.uri.split(b"/")[-1]} for id {path}'
)
if self.server.coherence.config.get('transcoding', 'no') == 'yes':
def got_stuff_to_transcode(ch):
# FIXME create a generic transcoder class
# and sort the details there
format = request.uri.split(b'/')[
-1
] # request.args['transcoded'][0]
uri = ch.get_path()
try:
from coherence.transcoder import TranscoderManager
manager = TranscoderManager(self.server.coherence)
return manager.select(format, uri)
except Exception:
self.debug(traceback.format_exc())
request.setResponseCode(404)
return static.Data(
b'<html><p>the requested transcoded file '
b'was not found</p></html>',
'text/html',
)
dfr = defer.maybeDeferred(self.store.get_by_id, path)
dfr.addCallback(got_stuff_to_transcode)
dfr.isLeaf = True
return dfr
request.setResponseCode(404)
return static.Data(
b'<html><p>This MediaServer '
b'doesn\'t support transcoding</p></html>',
'text/html',
)
if request.method == b'POST' and request.uri.endswith(b'?import'):
d = self.import_file(path, request)
if isinstance(d, defer.Deferred):
d.addBoth(self.import_response, path)
d.isLeaf = True
return d
return self.import_response(None, path)
if (
b'user-agent' in headers
and (
headers[b'user-agent'].find(b'Xbox/') in [0, None]
or headers[b'user-agent'].startswith( # XBox # wmp11
b'''Mozilla/4.0 (compatible; UPnP/1.0; Windows'''
)
)
and path in [b'description-1.xml', b'description-2.xml']
):
self.info(
'XBox/WMP alert, we need to '
'simulate a Windows Media Connect server'
)
if b'xbox-description-1.xml' in self.children:
self.msg('returning xbox-description-1.xml')
return self.children[b'xbox-description-1.xml']
# resource http://XXXX/<deviceID>/config
# configuration for the given device
# accepted methods:
# GET, HEAD:
# returns the configuration data (in XML format)
# POST: stop the current device and restart it
# with the posted configuration data
if path in (b'config'):
backend = self.server.backend
backend_type = backend.__class__.__name__
def constructConfigData(backend):
msg = '<plugin active="yes">'
msg += '<backend>' + to_string(backend_type) + '</backend>'
for key, value in list(backend.config.items()):
msg += (
'<' + to_string(key) + '>'
+ to_string(value)
+ '</' + to_string(key) + '>'
)
msg += '</plugin>'
return to_bytes(msg)
if request.method in (b'GET', b'HEAD'):
# the client wants to retrieve the
# configuration parameters for the backend
msg = constructConfigData(backend)
request.setResponseCode(200)
return static.Data(msg, 'text/xml')
elif request.method in (b'POST'):
# the client wants to update the configuration parameters
# for the backend we relaunch the backend with the
# new configuration (after content validation)
def convert_elementtree_to_dict(root):
active = False
for name, value in list(root.items()):
if name == 'active':
if value in ('yes'):
active = True
break
if active is False:
return None
dict = {}
for element in root.getchildren():
key = element.tag
text = element.text
if key != 'backend':
dict[key] = text
return dict
new_config = None
try:
element_tree = etree.fromstring(request.content.getvalue())
new_config = convert_elementtree_to_dict(element_tree)
self.server.coherence.remove_plugin(self.server)
self.warning(
f'{backend.name} {self.server.device_type} ({backend})'
f' with id {str(self.server.uuid)[5:]} deactivated'
)
if new_config is None:
msg = '<plugin active="no"/>'
else:
new_backend = self.server.coherence.add_plugin(
backend_type, **new_config
)
if self.server.coherence.writeable_config():
self.server.coherence.store_plugin_config(
new_backend.uuid, new_config
)
msg = (
'<html><p>Device restarted. Config file '
+ 'has been modified with posted data.</p>'
+ '</html>'
) # constructConfigData(new_backend)
else:
msg = (
'<html><p>Device restarted. '
+ 'Config file not modified</p>'
+ '</html>'
) # constructConfigData(new_backend)
request.setResponseCode(202)
return static.Data(msg.encode('ascii'), 'text/html')
except SyntaxError as e:
request.setResponseCode(400)
return static.Data(
f'<html>'
f'<p>Invalid data posted:<BR>{e}</p>'
f'</html>'.encode('ascii'),
'text/html',
)
else:
# invalid method requested
request.setResponseCode(405)
return static.Data(
b'<html><p>This resource does not allow '
+ b'the requested HTTP method</p></html>',
'text/html',
)
if path in self.children:
return self.children[path]
if request.uri == b'/':
return self
return self.getChild(path, request)
def render(self, request):
logger.info('in render, request: {request}, post_path is {post_path}',
request=request,
post_path=request.postpath)
x_self_string_headers = request.requestHeaders.getRawHeaders(
'X-Self-String')
if x_self_string_headers and (self_string in x_self_string_headers):
logger.info('called by self, returning 302')
request.setResponseCode(302)
return 'ok'.encode()
# we have support for setting time for testing purposes
x_time_for_testing = request.requestHeaders.getRawHeaders(
'X-Testing-Time')
if ('True' == config.get('Testing')) and x_time_for_testing:
x_time_for_testing = float(x_time_for_testing[0])
logger.info(
'In testing and current time is being overridden with {time}',
time=x_time_for_testing)
set_current_time_for_testing(x_time_for_testing)
content_type_headers = request.requestHeaders.getRawHeaders(
'content-type')
if content_type_headers and ('application/json'
in content_type_headers):
try:
data = json.load(request.content)
except json.JSONDecodeError:
logger.error('Passed bad JSON in request: {content}',
content=request.content)
request.setResponseCode(500)
ret = {"error": "Bad JSON in request"}
return ret
else:
data = request.content.read()
logger.info('request content: {data}', data=data)
args = {
k.decode(): [item for item in v]
for k, v in request.args.items()
}
path = request.path.decode()
method = request.method.decode()
path_method = '%s:%s' % (path, method)
logger.info('{method} {path}', method=method, path=path)
if method == "OPTIONS":
request.setResponseCode(204)
request.responseHeaders.addRawHeader(b"Allow",
b"OPTIONS, GET, POST")
request.responseHeaders.addRawHeader(
b"Access-Control-Allow-Methods", b"GET, POST, OPTIONS")
request.responseHeaders.addRawHeader(b"Connection", b"Keep-Alive")
request.responseHeaders.addRawHeader(
b"Access-Control-Allow-Headers", b"Content-Type")
# The cross-origin headers were needed for some health provider portal work that isn't happening yet so commented out.
# before this gets commented back in, the origins should come from config file
# request.responseHeaders.addRawHeader(b"Access-Control-Allow-Origin", b"*")
# request.responseHeaders.addRawHeader(b"Vary", b"Origin")
return b""
else:
request.responseHeaders.addRawHeader(b"content-type",
b"application/json")
# Commented out until we need it for access to server from locally generated or third party server.
# before this gets commented back in, the origins should come from config file
# request.responseHeaders.addRawHeader(b"access-control-allow-origin", b"*")
if path_method in allowable_methods:
ret = contacts.execute_route(path, data, args)
if 'error' in ret:
request.setResponseCode(ret.get('status', 400))
ret = ret['error']
logger.error('error return is {ret}', ret=ret)
else:
# if any values functions in ret, then run then asynchronously and return None here
# if they aren't then return ret
ret = resolve_all_functions(ret, request)
logger.info('legal return is {ret}', ret=ret)
else:
request.setResponseCode(402)
ret = {"error": "no such request"}
logger.error('return is {ret}', ret=ret)
if twserver.NOT_DONE_YET != ret:
return json.dumps(ret).encode()
else:
return ret
def deferred_result_error(failure, request):
logger.failure("Logging an uncaught exception", failure=failure)
request.setResponseCode(400)
request.write(json.dumps({'error': 'internal error'}).encode())
request.finish()
return
def render_HEAD(self, request):
self.info(f'render HEAD {request}')
request.setResponseCode(200)
request.setHeader(b'Content-Type', self.contentType)
request.write(b'')
def render_HEAD(self, request):
self.info('render HEAD %r', request)
request.setResponseCode(200)
request.setHeader('Content-Type', self.contentType)
request.write('')
def getChildWithDefault(self, path, request):
self.info('%s getChildWithDefault, %s, %s, %s %s',
self.server.device_type, request.method, path, request.uri,
request.client)
headers = request.getAllHeaders()
self.msg(request.getAllHeaders())
try:
if headers['getcontentfeatures.dlna.org'] != '1':
request.setResponseCode(400)
return static.Data(
'<html><p>wrong value for getcontentFeatures.dlna.org</p></html>',
'text/html')
except:
pass
if request.method == 'HEAD':
if 'getcaptioninfo.sec' in headers:
self.warning("requesting srt file for id %s", path)
ch = self.store.get_by_id(path)
try:
location = ch.get_path()
caption = ch.caption
if caption is None:
raise KeyError
request.setResponseCode(200)
request.setHeader('CaptionInfo.sec', caption)
return static.Data('', 'text/html')
except:
print(traceback.format_exc())
request.setResponseCode(404)
return static.Data(
'<html><p>the requested srt file was not found</p></html>',
'text/html')
try:
request._dlna_transfermode = headers['transfermode.dlna.org']
except KeyError:
request._dlna_transfermode = 'Streaming'
if request.method in ('GET', 'HEAD'):
if COVER_REQUEST_INDICATOR.match(request.uri):
self.info("request cover for id %s", path)
def got_item(ch):
if ch is not None:
request.setResponseCode(200)
file = ch.get_cover()
if file and os.path.exists(file):
self.info("got cover %s", file)
return StaticFile(file)
request.setResponseCode(404)
return static.Data(
'<html><p>cover requested not found</p></html>',
'text/html')
dfr = defer.maybeDeferred(self.store.get_by_id, path)
dfr.addCallback(got_item)
dfr.isLeaf = True
return dfr
if ATTACHMENT_REQUEST_INDICATOR.match(request.uri):
self.info("request attachment %r for id %s", request.args,
path)
def got_attachment(ch):
try:
#FIXME same as below
if 'transcoded' in request.args:
if self.server.coherence.config.get(
'transcoding', 'no') == 'yes':
format = request.args['transcoded'][0]
type = request.args['type'][0]
self.info("request transcoding %r %r", format,
type)
try:
from coherence.transcoder import TranscoderManager
manager = TranscoderManager(
self.server.coherence)
return manager.select(
format, ch.item.attachments[
request.args['attachment'][0]])
except:
self.debug(traceback.format_exc())
request.setResponseCode(404)
return static.Data(
'<html><p>the requested transcoded file was not found</p></html>',
'text/html')
else:
request.setResponseCode(404)
return static.Data(
"<html><p>This MediaServer doesn't support transcoding</p></html>",
'text/html')
else:
return ch.item.attachments[
request.args['attachment'][0]]
except:
request.setResponseCode(404)
return static.Data(
'<html><p>the requested attachment was not found</p></html>',
'text/html')
dfr = defer.maybeDeferred(self.store.get_by_id, path)
dfr.addCallback(got_attachment)
dfr.isLeaf = True
return dfr
if request.method in ('GET',
'HEAD') and TRANSCODED_REQUEST_INDICATOR.match(
request.uri):
self.info("request transcoding to %s for id %s",
request.uri.split('/')[-1], path)
if self.server.coherence.config.get('transcoding', 'no') == 'yes':
def got_stuff_to_transcode(ch):
#FIXME create a generic transcoder class and sort the details there
format = request.uri.split('/')[
-1] # request.args['transcoded'][0]
uri = ch.get_path()
try:
from coherence.transcoder import TranscoderManager
manager = TranscoderManager(self.server.coherence)
return manager.select(format, uri)
except:
self.debug(traceback.format_exc())
request.setResponseCode(404)
return static.Data(
'<html><p>the requested transcoded file was not found</p></html>',
'text/html')
dfr = defer.maybeDeferred(self.store.get_by_id, path)
dfr.addCallback(got_stuff_to_transcode)
dfr.isLeaf = True
return dfr
request.setResponseCode(404)
return static.Data(
"<html><p>This MediaServer doesn't support transcoding</p></html>",
'text/html')
if request.method == 'POST' and request.uri.endswith('?import'):
d = self.import_file(path, request)
if isinstance(d, defer.Deferred):
d.addBoth(self.import_response, path)
d.isLeaf = True
return d
return self.import_response(None, path)
if ('user-agent' in headers
and (headers['user-agent'].find('Xbox/') == 0 or # XBox
headers['user-agent'].startswith(
"""Mozilla/4.0 (compatible; UPnP/1.0; Windows"""))
and # wmp11
path in ['description-1.xml', 'description-2.xml']):
self.info(
'XBox/WMP alert, we need to simulate a Windows Media Connect server'
)
if 'xbox-description-1.xml' in self.children:
self.msg('returning xbox-description-1.xml')
return self.children['xbox-description-1.xml']
# resource http://XXXX/<deviceID>/config
# configuration for the given device
# accepted methods:
# GET, HEAD: returns the configuration data (in XML format)
# POST: stop the current device and restart it with the posted configuration data
if path in ('config'):
backend = self.server.backend
backend_type = backend.__class__.__name__
def constructConfigData(backend):
msg = "<plugin active=\"yes\">"
msg += "<backend>" + backend_type + "</backend>"
for key, value in list(backend.config.items()):
msg += "<" + key + ">" + value + "</" + key + ">"
msg += "</plugin>"
return msg
if request.method in ('GET', 'HEAD'):
# the client wants to retrieve the configuration parameters for the backend
msg = constructConfigData(backend)
request.setResponseCode(200)
return static.Data(msg, 'text/xml')
elif request.method in ('POST'):
# the client wants to update the configuration parameters for the backend
# we relaunch the backend with the new configuration (after content validation)
def convert_elementtree_to_dict(root):
active = False
for name, value in list(root.items()):
if name == 'active':
if value in ('yes'):
active = True
break
if active is False:
return None
dict = {}
for element in root.getchildren():
key = element.tag
text = element.text
if key != 'backend':
dict[key] = text
return dict
new_config = None
try:
element_tree = etree.fromstring(request.content.getvalue())
new_config = convert_elementtree_to_dict(element_tree)
self.server.coherence.remove_plugin(self.server)
self.warning("%s %s (%s) with id %s desactivated",
backend.name, self.server.device_type,
backend,
str(self.server.uuid)[5:])
if new_config is None:
msg = "<plugin active=\"no\"/>"
else:
new_backend = self.server.coherence.add_plugin(
backend_type, **new_config)
if self.server.coherence.writeable_config():
self.server.coherence.store_plugin_config(
new_backend.uuid, new_config)
msg = "<html><p>Device restarted. Config file has been modified with posted data.</p></html>" # constructConfigData(new_backend)
else:
msg = "<html><p>Device restarted. Config file not modified</p></html>" # constructConfigData(new_backend)
request.setResponseCode(202)
return static.Data(msg, 'text/html') # 'text/xml')
except SyntaxError as e:
request.setResponseCode(400)
return static.Data(
"<html><p>Invalid data posted:<BR>%s</p></html>" % e,
'text/html')
else:
# invalid method requested
request.setResponseCode(405)
return static.Data(
"<html><p>This resource does not allow the requested HTTP method</p></html>",
'text/html')
if path in self.children:
return self.children[path]
if request.uri == '/':
return self
return self.getChild(path, request)
