def test_is_loading_one_process_from_config(self):
coherence = self.CoherenceStump(transcoder=self.process_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
transcoder = self.manager.select('megaprocess', 'http://another/uri')
self.assertTrue(isinstance(transcoder, ExternalProcessPipeline))
self._check_transcoder_attrs(transcoder, 'uiui%suiui',
'http://another/uri')
def test_is_loading_one_gst_from_config(self):
coherence = self.CoherenceStump(transcoder=self.gst_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
my_pipe = self.manager.select('supertest', 'http://my_uri')
self.assertTrue(isinstance(my_pipe, GStreamerTranscoder))
self._check_transcoder_attrs(my_pipe,
pipeline='pp%spppl',
uri="http://my_uri")
def test_badname_in_config(self):
# this pipeline does not contain the '%s' placeholder and because
# of that should not be created
coherence = self.CoherenceStump(transcoder=self.bad_name_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
self.assertRaises(KeyError, self.manager.select, u'so bäd',
'http://another/uri')
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_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 test_is_loading_one_gst_from_config(self):
coherence = self.CoherenceStump(transcoder=self.gst_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
my_pipe = self.manager.select('supertest', 'http://my_uri')
self.assertTrue(isinstance(my_pipe, GStreamerTranscoder))
self._check_transcoder_attrs(my_pipe,
pipeline='pp%spppl', uri="http://my_uri")
def test_placeholdercheck_in_config(self):
# this pipeline does not contain the '%s' placeholder and because
# of that should not be created
coherence = self.CoherenceStump(transcoder=self.failing_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
self.assertRaises(KeyError, self.manager.select, 'failing',
'http://another/uri')
def test_is_loading_one_process_from_config(self):
coherence = self.CoherenceStump(transcoder=self.process_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
transcoder = self.manager.select('megaprocess', 'http://another/uri')
self.assertTrue(isinstance(transcoder, ExternalProcessPipeline))
self._check_transcoder_attrs(transcoder, 'uiui%suiui',
'http://another/uri')
def test_loaded_gst_always_new_instance(self):
coherence = self.CoherenceStump(transcoder=self.gst_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
transcoder_a = self.manager.select('supertest', 'http://my_uri')
self.assertTrue(isinstance(transcoder_a, GStreamerTranscoder))
self._check_transcoder_attrs(transcoder_a,
pipeline='pp%spppl',
uri="http://my_uri")
transcoder_b = self.manager.select('supertest', 'http://another/uri')
self.assertTrue(isinstance(transcoder_b, GStreamerTranscoder))
self._check_transcoder_attrs(transcoder_b,
pipeline='pp%spppl',
uri="http://another/uri")
self.assertNotEquals(transcoder_a, transcoder_b)
self.assertNotEquals(id(transcoder_a), id(transcoder_b))
def test_is_loading_multiple_from_config(self):
coherence = self.CoherenceStump(
transcoder=[self.gst_config, self.process_config])
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
# check the megaprocess
transcoder = self.manager.select('megaprocess', 'http://another/uri')
self.assertTrue(isinstance(transcoder, ExternalProcessPipeline))
self._check_transcoder_attrs(transcoder, 'uiui%suiui',
'http://another/uri')
# check the gstreamer transcoder
transcoder = self.manager.select('supertest', 'http://another/uri2')
self.assertTrue(isinstance(transcoder, GStreamerTranscoder))
self._check_transcoder_attrs(transcoder, 'pp%spppl',
'http://another/uri2')
def setup_part2(self):
'''Initializes the basic and optional services/devices and the enabled
plugins (backends).'''
self.setup_ssdp_server()
if not self.ssdp_server:
raise Exception('Unable to initialize an ssdp server')
self.msearch = MSearch(self.ssdp_server, test=self.is_unittest)
reactor.addSystemEventTrigger(
'before',
'shutdown',
self.shutdown,
force=True,
)
self.setup_web_server()
if not self.urlbase:
raise Exception('Unable to initialize an web server')
self.setup_plugins()
# Control Point Initialization
if (self.config.get('controlpoint', 'no') == 'yes'
or self.config.get('json', 'no') == 'yes'):
self.ctrl = ControlPoint(self)
# Json Interface Initialization
if self.config.get('json', 'no') == 'yes':
from coherence.json_service import JsonInterface
self.json = JsonInterface(self.ctrl)
# Transcoder Initialization
if self.config.get('transcoding', 'no') == 'yes':
from coherence.transcoder import TranscoderManager
self.transcoder_manager = TranscoderManager(self)
# DBus Initialization
if self.config.get('use_dbus', 'no') == 'yes':
try:
from coherence import dbus_service
if self.ctrl is None:
self.ctrl = ControlPoint(self)
self.ctrl.auto_client_append('InternetGatewayDevice')
self.dbus = dbus_service.DBusPontoon(self.ctrl)
except Exception as msg:
self.warning(f'Unable to activate dbus sub-system: {msg}')
self.debug(traceback.format_exc())
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 test_loaded_gst_always_new_instance(self):
coherence = self.CoherenceStump(transcoder=self.gst_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
transcoder_a = self.manager.select('supertest', 'http://my_uri')
self.assertTrue(isinstance(transcoder_a, GStreamerTranscoder))
self._check_transcoder_attrs(transcoder_a,
pipeline='pp%spppl', uri="http://my_uri")
transcoder_b = self.manager.select('supertest', 'http://another/uri')
self.assertTrue(isinstance(transcoder_b, GStreamerTranscoder))
self._check_transcoder_attrs(transcoder_b,
pipeline='pp%spppl', uri="http://another/uri")
self.assertNotEquals(transcoder_a, transcoder_b)
self.assertNotEquals(id(transcoder_a), id(transcoder_b))
def test_is_loading_multiple_from_config(self):
coherence = self.CoherenceStump(transcoder=[self.gst_config,
self.process_config])
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
# check the megaprocess
transcoder = self.manager.select('megaprocess', 'http://another/uri')
self.assertTrue(isinstance(transcoder, ExternalProcessPipeline))
self._check_transcoder_attrs(transcoder, 'uiui%suiui',
'http://another/uri')
# check the gstreamer transcoder
transcoder = self.manager.select('supertest', 'http://another/uri2')
self.assertTrue(isinstance(transcoder, GStreamerTranscoder))
self._check_transcoder_attrs(transcoder, 'pp%spppl',
'http://another/uri2')
def test_is_loading_no_config(self):
coherence = self.CoherenceStump()
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
def test_is_loading_all_known_transcoders(self):
self.manager = TranscoderManager()
self._check_for_transcoders(known_transcoders)
class TestTranscoderAutoloading(TranscoderTestMixin, TestCase):
class CoherenceStump(object):
def __init__(self, **kwargs):
self.config = kwargs
failing_config = {
'name': 'failing',
'pipeline': 'wrong',
'type': 'process',
'target': 'yay'
}
gst_config = {
'name': 'supertest',
'pipeline': 'pp%spppl',
'type': 'gstreamer',
'target': 'yay'
}
process_config = {
'name': 'megaprocess',
'pipeline': 'uiui%suiui',
'type': 'process',
'target': 'yay'
}
bad_name_config = {
'name': u'so bäd',
'pipeline': 'fake %s',
'type': 'process',
'target': 'norway'
}
def setUp(self):
self.manager = None
def test_is_loading_all_known_transcoders(self):
self.manager = TranscoderManager()
self._check_for_transcoders(known_transcoders)
def _check_for_transcoders(self, transcoders):
for klass in transcoders:
loaded_transcoder = self.manager.transcoders[get_transcoder_name(
klass)]
self.assertEquals(loaded_transcoder, klass)
def test_is_loading_no_config(self):
coherence = self.CoherenceStump()
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
def test_is_loading_one_gst_from_config(self):
coherence = self.CoherenceStump(transcoder=self.gst_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
my_pipe = self.manager.select('supertest', 'http://my_uri')
self.assertTrue(isinstance(my_pipe, GStreamerTranscoder))
self._check_transcoder_attrs(my_pipe,
pipeline='pp%spppl',
uri="http://my_uri")
def _check_transcoder_attrs(self, transcoder, pipeline=None, uri=None):
# bahh... relying on implementation details of the basetranscoder here
self.assertEquals(transcoder.pipeline_description, pipeline)
self.assertEquals(transcoder.uri, uri)
def test_is_loading_one_process_from_config(self):
coherence = self.CoherenceStump(transcoder=self.process_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
transcoder = self.manager.select('megaprocess', 'http://another/uri')
self.assertTrue(isinstance(transcoder, ExternalProcessPipeline))
self._check_transcoder_attrs(transcoder, 'uiui%suiui',
'http://another/uri')
def test_placeholdercheck_in_config(self):
# this pipeline does not contain the '%s' placeholder and because
# of that should not be created
coherence = self.CoherenceStump(transcoder=self.failing_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
self.assertRaises(KeyError, self.manager.select, 'failing',
'http://another/uri')
def test_badname_in_config(self):
# this pipeline does not contain the '%s' placeholder and because
# of that should not be created
coherence = self.CoherenceStump(transcoder=self.bad_name_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
self.assertRaises(KeyError, self.manager.select, u'so bäd',
'http://another/uri')
def test_is_loading_multiple_from_config(self):
coherence = self.CoherenceStump(
transcoder=[self.gst_config, self.process_config])
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
# check the megaprocess
transcoder = self.manager.select('megaprocess', 'http://another/uri')
self.assertTrue(isinstance(transcoder, ExternalProcessPipeline))
self._check_transcoder_attrs(transcoder, 'uiui%suiui',
'http://another/uri')
# check the gstreamer transcoder
transcoder = self.manager.select('supertest', 'http://another/uri2')
self.assertTrue(isinstance(transcoder, GStreamerTranscoder))
self._check_transcoder_attrs(transcoder, 'pp%spppl',
'http://another/uri2')
def test_loaded_gst_always_new_instance(self):
coherence = self.CoherenceStump(transcoder=self.gst_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
transcoder_a = self.manager.select('supertest', 'http://my_uri')
self.assertTrue(isinstance(transcoder_a, GStreamerTranscoder))
self._check_transcoder_attrs(transcoder_a,
pipeline='pp%spppl',
uri="http://my_uri")
transcoder_b = self.manager.select('supertest', 'http://another/uri')
self.assertTrue(isinstance(transcoder_b, GStreamerTranscoder))
self._check_transcoder_attrs(transcoder_b,
pipeline='pp%spppl',
uri="http://another/uri")
self.assertNotEquals(transcoder_a, transcoder_b)
self.assertNotEquals(id(transcoder_a), id(transcoder_b))
def test_is_really_singleton(self):
#FIXME: singleton tests should be outsourced some when
old_id = id(self.manager)
new_manager = TranscoderManager()
self.assertEquals(old_id, id(new_manager))
def setUp(self):
self.manager = TranscoderManager()
def test_is_loading_no_config(self):
coherence = self.CoherenceStump()
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
def setup_part2(self):
self.info('running on host: %s', self.hostname)
if self.hostname.startswith('127.'):
self.warning('detection of own ip failed, using %s as own address, functionality will be limited', self.hostname)
unittest = self.config.get('unittest', 'no')
unittest = False if unittest == 'no' else True
""" SSDP Server Initialization
"""
try:
# TODO: add ip/interface bind
self.ssdp_server = SSDPServer(test=unittest)
except CannotListenError as err:
self.error("Error starting the SSDP-server: %s", err)
self.debug("Error starting the SSDP-server", exc_info=True)
reactor.stop()
return
louie.connect(self.create_device, 'Coherence.UPnP.SSDP.new_device', louie.Any)
louie.connect(self.remove_device, 'Coherence.UPnP.SSDP.removed_device', louie.Any)
louie.connect(self.add_device, 'Coherence.UPnP.RootDevice.detection_completed', louie.Any)
# louie.connect( self.receiver, 'Coherence.UPnP.Service.detection_completed', louie.Any)
self.ssdp_server.subscribe("new_device", self.add_device)
self.ssdp_server.subscribe("removed_device", self.remove_device)
self.msearch = MSearch(self.ssdp_server, test=unittest)
reactor.addSystemEventTrigger('before', 'shutdown', self.shutdown, force=True)
""" Web Server Initialization
"""
try:
# TODO: add ip/interface bind
self.web_server = WebServer(self.config.get('web-ui', None), self.web_server_port, self)
except CannotListenError:
self.warning('port %r already in use, aborting!', self.web_server_port)
reactor.stop()
return
self.urlbase = 'http://%s:%d/' % (self.hostname, self.web_server_port)
# self.renew_service_subscription_loop = task.LoopingCall(self.check_devices)
# self.renew_service_subscription_loop.start(20.0, now=False)
try:
plugins = self.config['plugin']
if isinstance(plugins, dict):
plugins = [plugins]
except:
plugins = None
if plugins is None:
plugins = self.config.get('plugins', None)
if plugins is None:
self.info("No plugin defined!")
else:
if isinstance(plugins, dict):
for plugin, arguments in list(plugins.items()):
try:
if not isinstance(arguments, dict):
arguments = {}
self.add_plugin(plugin, **arguments)
except Exception as msg:
self.warning("Can't enable plugin, %s: %s!", plugin, msg)
self.info(traceback.format_exc())
else:
for plugin in plugins:
try:
if plugin['active'] == 'no':
continue
except (KeyError, TypeError):
pass
try:
backend = plugin['backend']
arguments = copy.copy(plugin)
del arguments['backend']
backend = self.add_plugin(backend, **arguments)
if self.writeable_config():
if 'uuid' not in plugin:
plugin['uuid'] = str(backend.uuid)[5:]
self.config.save()
except Exception as msg:
self.warning("Can't enable plugin, %s: %s!", plugin, msg)
self.info(traceback.format_exc())
self.external_address = ':'.join((self.hostname, str(self.web_server_port)))
""" Control Point Initialization
"""
if self.config.get('controlpoint', 'no') == 'yes' or self.config.get('json', 'no') == 'yes':
self.ctrl = ControlPoint(self)
""" Json Interface Initialization
"""
if self.config.get('json', 'no') == 'yes':
from coherence.json_service import JsonInterface
self.json = JsonInterface(self.ctrl)
""" Transcoder Initialization
"""
if self.config.get('transcoding', 'no') == 'yes':
from coherence.transcoder import TranscoderManager
self.transcoder_manager = TranscoderManager(self)
""" DBus Initialization
"""
if self.config.get('use_dbus', 'no') == 'yes':
try:
from coherence import dbus_service
if self.ctrl is None:
self.ctrl = ControlPoint(self)
self.ctrl.auto_client_append('InternetGatewayDevice')
self.dbus = dbus_service.DBusPontoon(self.ctrl)
except Exception as msg:
self.warning("Unable to activate dbus sub-system: %r", msg)
self.debug(traceback.format_exc())
class TestTranscoderAutoloading(TranscoderTestMixin, TestCase):
class CoherenceStump(object):
def __init__(self, **kwargs):
self.config = kwargs
failing_config = {'name': 'failing', 'pipeline': 'wrong',
'type': 'process', 'target': 'yay'}
gst_config = {'name': 'supertest', 'pipeline': 'pp%spppl',
'type': 'gstreamer', 'target': 'yay'}
process_config = {'name': 'megaprocess', 'pipeline': 'uiui%suiui',
'type': 'process', 'target': 'yay'}
bad_name_config = {'name': u'so bäd', 'pipeline': 'fake %s',
'type': 'process', 'target': 'norway'}
def setUp(self):
self.manager = None
def test_is_loading_all_known_transcoders(self):
self.manager = TranscoderManager()
self._check_for_transcoders(known_transcoders)
def _check_for_transcoders(self, transcoders):
for klass in transcoders:
loaded_transcoder = self.manager.transcoders[get_transcoder_name(klass)]
self.assertEquals(loaded_transcoder, klass)
def test_is_loading_no_config(self):
coherence = self.CoherenceStump()
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
def test_is_loading_one_gst_from_config(self):
coherence = self.CoherenceStump(transcoder=self.gst_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
my_pipe = self.manager.select('supertest', 'http://my_uri')
self.assertTrue(isinstance(my_pipe, GStreamerTranscoder))
self._check_transcoder_attrs(my_pipe,
pipeline='pp%spppl', uri="http://my_uri")
def _check_transcoder_attrs(self, transcoder, pipeline=None, uri=None):
# bahh... relying on implementation details of the basetranscoder here
self.assertEquals(transcoder.pipeline_description, pipeline)
self.assertEquals(transcoder.uri, uri)
def test_is_loading_one_process_from_config(self):
coherence = self.CoherenceStump(transcoder=self.process_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
transcoder = self.manager.select('megaprocess', 'http://another/uri')
self.assertTrue(isinstance(transcoder, ExternalProcessPipeline))
self._check_transcoder_attrs(transcoder, 'uiui%suiui',
'http://another/uri')
def test_placeholdercheck_in_config(self):
# this pipeline does not contain the '%s' placeholder and because
# of that should not be created
coherence = self.CoherenceStump(transcoder=self.failing_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
self.assertRaises(KeyError, self.manager.select, 'failing',
'http://another/uri')
def test_badname_in_config(self):
# this pipeline does not contain the '%s' placeholder and because
# of that should not be created
coherence = self.CoherenceStump(transcoder=self.bad_name_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
self.assertRaises(KeyError, self.manager.select, u'so bäd',
'http://another/uri')
def test_is_loading_multiple_from_config(self):
coherence = self.CoherenceStump(transcoder=[self.gst_config,
self.process_config])
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
# check the megaprocess
transcoder = self.manager.select('megaprocess', 'http://another/uri')
self.assertTrue(isinstance(transcoder, ExternalProcessPipeline))
self._check_transcoder_attrs(transcoder, 'uiui%suiui',
'http://another/uri')
# check the gstreamer transcoder
transcoder = self.manager.select('supertest', 'http://another/uri2')
self.assertTrue(isinstance(transcoder, GStreamerTranscoder))
self._check_transcoder_attrs(transcoder, 'pp%spppl',
'http://another/uri2')
def test_loaded_gst_always_new_instance(self):
coherence = self.CoherenceStump(transcoder=self.gst_config)
self.manager = TranscoderManager(coherence)
self._check_for_transcoders(known_transcoders)
transcoder_a = self.manager.select('supertest', 'http://my_uri')
self.assertTrue(isinstance(transcoder_a, GStreamerTranscoder))
self._check_transcoder_attrs(transcoder_a,
pipeline='pp%spppl', uri="http://my_uri")
transcoder_b = self.manager.select('supertest', 'http://another/uri')
self.assertTrue(isinstance(transcoder_b, GStreamerTranscoder))
self._check_transcoder_attrs(transcoder_b,
pipeline='pp%spppl', uri="http://another/uri")
self.assertNotEquals(transcoder_a, transcoder_b)
self.assertNotEquals(id(transcoder_a), id(transcoder_b))
def setup_part2(self):
'''Initializes the basic and optional services/devices and the enabled
plugins (backends).'''
self.info(f'running on host: {self.hostname}')
if self.hostname.startswith('127.'):
self.warning(f'detection of own ip failed, using {self.hostname} '
f'as own address, functionality will be limited')
unittest = self.config.get('unittest', 'no')
unittest = False if unittest == 'no' else True
try:
# TODO: add ip/interface bind
self.ssdp_server = SSDPServer(test=unittest)
except CannotListenError as err:
self.error(f'Error starting the SSDP-server: {err}')
self.debug('Error starting the SSDP-server', exc_info=True)
reactor.stop()
return
# maybe some devices are already notified, so we enforce
# to create the device, if it is not already added...and
# then we connect the signals for new detections.
for st, usn in self.ssdp_server.root_devices:
self.create_device(st, usn)
self.ssdp_server.bind(new_device=self.create_device)
self.ssdp_server.bind(removed_device=self.remove_device)
self.ssdp_server.subscribe('new_device', self.add_device)
self.ssdp_server.subscribe('removed_device', self.remove_device)
self.msearch = MSearch(self.ssdp_server, test=unittest)
reactor.addSystemEventTrigger('before',
'shutdown',
self.shutdown,
force=True)
# Web Server Initialization
try:
# TODO: add ip/interface bind
if self.config.get('web-ui', 'no') != 'yes':
self.web_server = WebServer(None, self.web_server_port, self)
else:
self.web_server = WebServerUi(self.web_server_port,
self,
unittests=unittest)
except CannotListenError:
self.error(
f'port {self.web_server_port} already in use, aborting!')
reactor.stop()
return
self.urlbase = f'http://{self.hostname}:{self.web_server_port:d}/'
# self.renew_service_subscription_loop = \
# task.LoopingCall(self.check_devices)
# self.renew_service_subscription_loop.start(20.0, now=False)
# Plugins Initialization
try:
plugins = self.config['plugin']
if isinstance(plugins, dict):
plugins = [plugins]
except Exception:
plugins = None
if plugins is None:
plugins = self.config.get('plugins', None)
if plugins is None:
self.info('No plugin defined!')
else:
if isinstance(plugins, dict):
for plugin, arguments in list(plugins.items()):
try:
if not isinstance(arguments, dict):
arguments = {}
self.add_plugin(plugin, **arguments)
except Exception as msg:
self.warning(f'Can\'t enable plugin, {plugin}: {msg}!')
self.info(traceback.format_exc())
else:
for plugin in plugins:
try:
if plugin['active'] == 'no':
continue
except (KeyError, TypeError):
pass
try:
backend = plugin['backend']
arguments = copy.copy(plugin)
del arguments['backend']
backend = self.add_plugin(backend, **arguments)
if self.writeable_config():
if 'uuid' not in plugin:
plugin['uuid'] = str(backend.uuid)[5:]
self.config.save()
except Exception as msg:
self.warning(f'Can\'t enable plugin, {plugin}: {msg}!')
self.info(traceback.format_exc())
self.external_address = ':'.join(
(self.hostname, str(self.web_server_port)))
# Control Point Initialization
if self.config.get('controlpoint', 'no') == 'yes' or self.config.get(
'json', 'no') == 'yes':
self.ctrl = ControlPoint(self)
# Json Interface Initialization
if self.config.get('json', 'no') == 'yes':
from coherence.json_service import JsonInterface
self.json = JsonInterface(self.ctrl)
# Transcoder Initialization
if self.config.get('transcoding', 'no') == 'yes':
from coherence.transcoder import TranscoderManager
self.transcoder_manager = TranscoderManager(self)
# DBus Initialization
if self.config.get('use_dbus', 'no') == 'yes':
try:
from coherence import dbus_service
if self.ctrl is None:
self.ctrl = ControlPoint(self)
self.ctrl.auto_client_append('InternetGatewayDevice')
self.dbus = dbus_service.DBusPontoon(self.ctrl)
except Exception as msg:
self.warning(f'Unable to activate dbus sub-system: {msg}')
self.debug(traceback.format_exc())
def test_is_loading_all_known_transcoders(self):
self.manager = TranscoderManager()
self._check_for_transcoders(known_transcoders)
