class TestCoherence(unittest.TestCase):
def setUp(self):
louie.reset()
self.coherence = Coherence({'unittest':'yes','logmode':'error'})
def tearDown(self):
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_singleton(self):
d = Deferred()
c1 = Coherence({'unittest':'no','logmode':'error'})
c2 = Coherence({'unittest':'no','logmode':'error'})
c3 = Coherence({'unittest':'no','logmode':'error'})
def shutdown(r,instance):
return instance.shutdown()
d.addCallback(shutdown,c1)
d.addCallback(shutdown,c2)
d.addCallback(shutdown,c3)
reactor.callLater(3, d.callback, None)
return d
class TestCoherence(unittest.TestCase):
def setUp(self):
self.coherence = Coherence({'unittest': 'yes', 'logmode': 'error'})
def tearDown(self):
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_singleton(self):
d = Deferred()
c1 = Coherence({'unittest': 'no', 'logmode': 'error'})
c2 = Coherence({'unittest': 'no', 'logmode': 'error'})
c3 = Coherence({'unittest': 'no', 'logmode': 'error'})
def shutdown(r, instance):
return instance.shutdown()
d.addCallback(shutdown, c1)
d.addCallback(shutdown, c2)
d.addCallback(shutdown, c3)
reactor.callLater(3, d.callback, None)
return d
class TestCoherence(unittest.TestCase):
def setUp(self):
self.log_level = 'error'
self.coherence = Coherence(
{
'unittest': 'yes',
'logmode': self.log_level
}, )
def tearDown(self):
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_singleton(self):
d = Deferred()
c1 = Coherence({'unittest': 'no', 'logmode': 'error'})
c2 = Coherence({'unittest': 'no', 'logmode': 'error'})
c3 = Coherence({'unittest': 'no', 'logmode': 'error'})
def shutdown(r, instance):
return instance.shutdown()
d.addCallback(shutdown, c1)
d.addCallback(shutdown, c2)
d.addCallback(shutdown, c3)
reactor.callLater(3, d.callback, None)
return d
def test_log_level(self):
self.assertEqual(self.coherence.log_level, self.log_level.upper())
def test_log_file(self):
self.assertEqual(self.coherence.log_file, None)
# now set a config file and test it
fake_file = '/fake_dir/fake_file.log'
self.coherence.config['logging'] = {'logfile': fake_file}
self.assertEqual(self.coherence.log_file, fake_file)
@mock.patch('coherence.base.get_ip_address')
def test_setup_hostname(self, mock_get_ip):
fake_ip = '192.168.1.24'
mock_get_ip.return_value = fake_ip
self.coherence.config['interface'] = fake_ip
# we expect to have an real ip address assigned by the router
self.assertNotEqual(self.coherence.hostname, '127.0.0.1')
# proceed to set a fake ip address and test the result
self.coherence.setup_hostname()
self.assertEqual(self.coherence.hostname, fake_ip)
mock_get_ip.assert_called_once_with(fake_ip)
class TestSwitchPowerClient(unittest.TestCase):
def setUp(self):
louie.reset()
self.coherence = Coherence({'unittest':'yes','logmode':'error','subsystem_log':{'controlpoint':'error'},'controlpoint':'yes'})
self.uuid = UUID()
p = self.coherence.add_plugin('SimpleLight', name='test-light-%d'%os.getpid(),uuid=str(self.uuid))
def tearDown(self):
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_get_state(self):
""" tries to find the activated SimpleLight backend
and queries its state.
The state is expected to be "off"
"""
d = Deferred()
def the_result(r):
#print "the_result", r
self.assertEqual(str(self.uuid), r.udn)
call = r.client.switch_power.get_status()
def got_answer(r):
self.assertEqual(int(r['ResultStatus']), 0)
d.callback(None)
call.addCallback(got_answer)
self.coherence.ctrl.add_query(DeviceQuery('uuid', str(self.uuid), the_result, timeout=10, oneshot=True))
return d
class TestContentDirectoryServer(unittest.TestCase):
def setUp(self):
self.tmp_content = FilePath(self.mktemp())
f = self.tmp_content.child('content')
audio = f.child('audio')
f.child('images').makedirs()
f.child('video').makedirs()
album = audio.child('album-1')
album.makedirs()
album.child('track-1.mp3').touch()
album.child('track-2.mp3').touch()
album = audio.child('album-2')
album.makedirs()
album.child('track-1.ogg').touch()
album.child('track-2.ogg').touch()
self.coherence = Coherence({
'unittest': 'yes',
'logmode': 'critical',
'no-subsystem_log': {
'controlpoint': 'error',
'action': 'info',
'soap': 'error'
},
'controlpoint': 'yes'
})
self.uuid = str(UUID())
self.coherence.add_plugin('FSStore',
name='MediaServer-%d' % os.getpid(),
content=self.tmp_content.path,
uuid=self.uuid,
enable_inotify=False)
def tearDown(self):
self.tmp_content.remove()
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_Browse(self):
""" tries to find the activated FSStore backend
and browses its root.
"""
d = Deferred()
@wrapped(d)
def the_result(mediaserver):
cdc = mediaserver.client.content_directory
self.assertEqual(self.uuid, mediaserver.udn)
call = cdc.browse(process_result=False)
call.addCallback(got_first_answer, cdc)
@wrapped(d)
def got_first_answer(r, cdc):
self.assertEqual(int(r['TotalMatches']), 1)
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
self.assertEqual(item.childCount, 3)
call = cdc.browse(object_id=item.id, process_result=False)
call.addCallback(got_second_answer, item.childCount)
@wrapped(d)
def got_second_answer(r, childcount):
self.assertEqual(int(r['TotalMatches']), childcount)
d.callback(None)
self.coherence.ctrl.add_query(
DeviceQuery('uuid',
self.uuid,
the_result,
timeout=10,
oneshot=True))
return d
def test_Browse_Non_Existing_Object(self):
d = Deferred()
@wrapped(d)
def the_result(mediaserver):
cdc = mediaserver.client.content_directory
self.assertEqual(self.uuid, mediaserver.udn)
call = cdc.browse(object_id='9999.nothing', process_result=False)
call.addCallback(got_first_answer)
@wrapped(d)
def got_first_answer(r):
self.assertIs(r, None)
d.callback(None)
self.coherence.ctrl.add_query(
DeviceQuery('uuid',
self.uuid,
the_result,
timeout=10,
oneshot=True))
return d
def test_Browse_Metadata(self):
""" tries to find the activated FSStore backend
and requests metadata for ObjectID 0.
"""
d = Deferred()
@wrapped(d)
def the_result(mediaserver):
self.assertEqual(self.uuid, mediaserver.udn)
cdc = mediaserver.client.content_directory
call = cdc.browse(object_id='0',
browse_flag='BrowseMetadata',
process_result=False)
call.addCallback(got_first_answer)
@wrapped(d)
def got_first_answer(r):
self.assertEqual(int(r['TotalMatches']), 1)
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
self.assertEqual(item.title, 'root')
d.callback(None)
self.coherence.ctrl.add_query(
DeviceQuery('uuid',
self.uuid,
the_result,
timeout=10,
oneshot=True))
return d
def test_XBOX_Browse(self):
""" tries to find the activated FSStore backend
and browses all audio files.
"""
d = Deferred()
@wrapped(d)
def the_result(mediaserver):
mediaserver.client.overlay_headers = {
'user-agent': 'Xbox/Coherence emulation'
}
cdc = mediaserver.client.content_directory
self.assertEqual(self.uuid, mediaserver.udn)
call = cdc.browse(object_id='4', process_result=False)
call.addCallback(got_first_answer)
@wrapped(d)
def got_first_answer(r):
""" we expect four audio files here """
self.assertEqual(int(r['TotalMatches']), 4)
d.callback(None)
d = Deferred()
self.coherence.ctrl.add_query(
DeviceQuery('uuid',
self.uuid,
the_result,
timeout=10,
oneshot=True))
return d
def test_XBOX_Browse_Metadata(self):
""" tries to find the activated FSStore backend
and requests metadata for ObjectID 0.
"""
d = Deferred()
@wrapped(d)
def the_result(mediaserver):
mediaserver.client.overlay_headers = {
'user-agent': 'Xbox/Coherence emulation'
}
cdc = mediaserver.client.content_directory
self.assertEqual(self.uuid, mediaserver.udn)
call = cdc.browse(object_id='0',
browse_flag='BrowseMetadata',
process_result=False)
call.addCallback(got_first_answer)
@wrapped(d)
def got_first_answer(r):
""" we expect one item here """
self.assertEqual(int(r['TotalMatches']), 1)
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
self.assertEqual(item.title, 'root')
d.callback(None)
self.coherence.ctrl.add_query(
DeviceQuery('uuid',
self.uuid,
the_result,
timeout=10,
oneshot=True))
return d
def test_XBOX_Search(self):
""" tries to find the activated FSStore backend
and searches for all its audio files.
"""
d = Deferred()
@wrapped(d)
def the_result(mediaserver):
mediaserver.client.overlay_headers = {
'user-agent': 'Xbox/Coherence emulation'
}
cdc = mediaserver.client.content_directory
self.assertEqual(self.uuid, mediaserver.udn)
call = cdc.search(container_id='4', criteria='')
call.addCallback(got_first_answer)
@wrapped(d)
def got_first_answer(r):
""" we expect four audio files here """
self.assertEqual(len(r), 4)
d.callback(None)
self.coherence.ctrl.add_query(
DeviceQuery('uuid',
self.uuid,
the_result,
timeout=10,
oneshot=True))
return d
class MirabeauController(object):
coherence_started_cb = lambda: None
def start(self):
# TODO: select correct window class depending on platform
main_window = MainWindow(self)
main_window.show_all()
def load_config(self):
self.first_run = False
if not os.path.exists(BASEDIR):
os.makedirs(BASEDIR)
if not os.path.exists(CONFIG_PATH):
self.first_run = True
default_account = ''
vars = locals()
vars["MR_UUID"] = MR_UUID
cfg = DEFAULT_CONFIG % vars
fd = open(CONFIG_PATH, "w")
fd.write(cfg)
fd.close()
self.config = Config(CONFIG_PATH,
root='config',
element2attr_mappings={'active': 'active'})
def reload_config(self):
self.config.save()
self.load_config()
def enable_mirabeau(self):
self.config.set("enable_mirabeau", "yes")
self.reload_config()
def disable_mirabeau(self):
self.config.set("enable_mirabeau", "no")
self.reload_config()
def platform_media_directories(self):
candidates = [
"~/MyDocs/.images",
"~/MyDocs/.sounds",
"~/MyDocs/.videos",
"~/MyDocs/DCIM",
"~/MyDocs/Music",
"~/MyDocs/Videos",
]
expanded = [os.path.expanduser(c) for c in candidates]
dirs = [c for c in expanded if os.path.isdir(c)]
return dirs
def enable_media_server(self, nickname=None):
nickname = nickname or "N900"
name_template = _("%(nickname)s Media Files")
def generate_cfg(nickname):
directories = self.platform_media_directories()
name = name_template % locals()
opts = dict(uuid=MS_UUID,
name=name,
content=",".join(directories),
backend="FSStore",
active="yes")
return XmlDictObject(initdict=opts)
plugins = self.config.get("plugin")
if not plugins:
self.config.set("plugin", generate_cfg())
else:
if isinstance(plugins, XmlDictObject):
plugins = [
plugins,
]
already_in_config = False
for plugin in plugins:
if plugin.get("uuid") == MS_UUID:
plugin.active = "yes"
plugin.name = name_template % locals()
already_in_config = True
break
if not already_in_config:
plugins.append(generate_cfg(nickname))
self.config.set("plugin", plugins)
self.reload_config()
def disable_media_server(self):
plugins = self.config.get("plugin")
if plugins:
if isinstance(plugins, XmlDictObject):
plugins = [
plugins,
]
for plugin in plugins:
if plugin.get("uuid") == MS_UUID:
plugin.active = "no"
break
self.config.set("plugin", plugins)
self.reload_config()
def media_server_enabled(self):
plugins = self.config.get("plugin")
if plugins:
if isinstance(plugins, XmlDictObject):
plugins = [
plugins,
]
for plugin in plugins:
if plugin.get("uuid") == MS_UUID and \
plugin.active == "yes":
return True
return False
def set_media_renderer_name(self, nickname=None):
nickname = nickname or "N900"
name_template = _("%(nickname)s Media Renderer")
plugins = self.config.get("plugin")
if plugins:
if isinstance(plugins, XmlDictObject):
plugins = [
plugins,
]
for plugin in plugins:
if plugin.get("uuid") == MR_UUID:
plugin.name = name_template % locals()
break
self.config.set("plugin", plugins)
self.reload_config()
def start_coherence(self, restart=False):
def start():
if self.config.get("mirabeau").get("account"):
self.enable_mirabeau()
else:
self.disable_mirabeau()
self.coherence_instance = Coherence(self.config.config)
if restart:
if self.coherence_instance:
dfr = self.stop_coherence()
dfr.addCallback(lambda result: start())
return dfr
else:
start()
else:
start()
if self.coherence_instance:
self.coherence_started_cb()
def stop_coherence(self):
def stopped(result):
if self.coherence_instance:
self.coherence_instance.clear()
self.coherence_instance = None
dfr = self.coherence_instance.shutdown(force=True)
dfr.addBoth(stopped)
return dfr
def toggle_coherence(self):
if self.coherence_instance:
self.stop_coherence()
else:
self.start_coherence()
def update_settings(self, chatroom, conf_server, account, account_nickname,
media_server_enabled):
mirabeau_section = self.config.get("mirabeau")
mirabeau_section.set("chatroom", chatroom)
mirabeau_section.set("conference-server", conf_server)
mirabeau_section.set("account", account)
self.config.set("mirabeau", mirabeau_section)
self.reload_config()
nickname = account_nickname
self.set_media_renderer_name(nickname)
if media_server_enabled:
self.enable_media_server(nickname=nickname)
else:
self.disable_media_server()
self.start_coherence(restart=True)
class TestContentDirectoryServer(unittest.TestCase):
def setUp(self):
self.tmp_content = FilePath('tmp_content_coherence-%d' % os.getpid())
f = self.tmp_content.child('content')
audio = f.child('audio')
f.child('images').makedirs()
f.child('video').makedirs()
album = audio.child('album-1')
album.makedirs()
album.child('track-1.mp3').touch()
album.child('track-2.mp3').touch()
album = audio.child('album-2')
album.makedirs()
album.child('track-1.ogg').touch()
album.child('track-2.ogg').touch()
louie.reset()
self.coherence = Coherence({
'unittest': 'yes',
'logmode': 'debug',
'subsystem_log': {
'controlpoint': 'error',
'action': 'error',
'soap': 'error'
},
'controlpoint': 'yes'
})
self.uuid = UUID()
p = self.coherence.add_plugin('FSStore',
name='MediaServer-%d' % os.getpid(),
content=self.tmp_content.path,
uuid=str(self.uuid))
def tearDown(self):
self.tmp_content.remove()
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_Browse(self):
""" tries to find the activated FSStore backend
and browses its root.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_second_answer(r, childcount):
try:
self.assertEqual(int(r['TotalMatches']), childcount)
d.callback(None)
except:
d.errback()
def got_first_answer(r):
try:
self.assertEqual(int(r['TotalMatches']), 1)
except:
d.errback()
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
try:
self.assertEqual(item.childCount, 3)
except:
d.errback()
call = mediaserver.client.content_directory.browse(
object_id=item.id, process_result=False)
call.addCallback(got_second_answer, item.childCount)
return call
call = mediaserver.client.content_directory.browse(
process_result=False)
call.addCallback(got_first_answer)
self.coherence.ctrl.add_query(
DeviceQuery('uuid',
str(self.uuid),
the_result,
timeout=10,
oneshot=True))
return d
def test_Browse_Metadata(self):
""" tries to find the activated FSStore backend
and requests metadata for ObjectID 0.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_first_answer(r):
try:
self.assertEqual(int(r['TotalMatches']), 1)
except:
d.errback()
return
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
try:
self.assertEqual(item.title, 'root')
except:
d.errback()
return
d.callback(None)
call = mediaserver.client.content_directory.browse(
object_id='0',
browse_flag='BrowseMetadata',
process_result=False)
call.addCallback(got_first_answer)
call.addErrback(lambda x: d.errback(None))
self.coherence.ctrl.add_query(
DeviceQuery('uuid',
str(self.uuid),
the_result,
timeout=10,
oneshot=True))
return d
def test_XBOX_Browse(self):
""" tries to find the activated FSStore backend
and browses all audio files.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_first_answer(r):
""" we expect four audio files here """
try:
self.assertEqual(int(r['TotalMatches']), 4)
except:
d.errback()
return
d.callback(None)
def my_browse(*args, **kwargs):
kwargs['ContainerID'] = kwargs['ObjectID']
del kwargs['ObjectID']
del kwargs['BrowseFlag']
kwargs['SearchCriteria'] = ''
return 'Search', kwargs
#mediaserver.client.overlay_actions = {'Browse':my_browse}
mediaserver.client.overlay_headers = {
'user-agent': 'Xbox/Coherence emulation'
}
call = mediaserver.client.content_directory.browse(
object_id='4', process_result=False)
call.addCallback(got_first_answer)
call.addErrback(lambda x: d.errback(None))
self.coherence.ctrl.add_query(
DeviceQuery('uuid',
str(self.uuid),
the_result,
timeout=10,
oneshot=True))
return d
def test_XBOX_Browse_Metadata(self):
""" tries to find the activated FSStore backend
and requests metadata for ObjectID 0.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_first_answer(r):
""" we expect one item here """
try:
self.assertEqual(int(r['TotalMatches']), 1)
except:
d.errback()
return
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
try:
self.assertEqual(item.title, 'root')
except:
d.errback()
return
d.callback(None)
mediaserver.client.overlay_headers = {
'user-agent': 'Xbox/Coherence emulation'
}
call = mediaserver.client.content_directory.browse(
object_id='0',
browse_flag='BrowseMetadata',
process_result=False)
call.addCallback(got_first_answer)
call.addErrback(lambda x: d.errback(None))
self.coherence.ctrl.add_query(
DeviceQuery('uuid',
str(self.uuid),
the_result,
timeout=10,
oneshot=True))
return d
def test_XBOX_Search(self):
""" tries to find the activated FSStore backend
and searches for all its audio files.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_first_answer(r):
""" we expect four audio files here """
try:
self.assertEqual(len(r), 4)
except:
d.errback()
d.callback(None)
mediaserver.client.overlay_headers = {
'user-agent': 'Xbox/Coherence emulation'
}
call = mediaserver.client.content_directory.search(
container_id='4', criteria='')
call.addCallback(got_first_answer)
call.addErrback(lambda x: d.errback(None))
self.coherence.ctrl.add_query(
DeviceQuery('uuid',
str(self.uuid),
the_result,
timeout=10,
oneshot=True))
return d
class TestContentDirectoryServer(unittest.TestCase):
def setUp(self):
self.tmp_content = FilePath('tmp_content_coherence-%d'%os.getpid())
f = self.tmp_content.get_child()('content')
audio = f.get_child()('audio')
f.get_child()('images').makedirs()
f.get_child()('video').makedirs()
album = audio.get_child()('album-1')
album.makedirs()
album.get_child()('track-1.mp3').touch()
album.get_child()('track-2.mp3').touch()
album = audio.get_child()('album-2')
album.makedirs()
album.get_child()('track-1.ogg').touch()
album.get_child()('track-2.ogg').touch()
louie.reset()
self.coherence = Coherence({'unittest':'yes','logmode':'debug','subsystem_log':{'controlpoint':'error',
'action':'error',
'soap':'error'},'controlpoint':'yes'})
self.uuid = UUID()
p = self.coherence.add_plugin('FSStore',
name='MediaServer-%d'%os.getpid(),
content=self.tmp_content.path,
uuid=str(self.uuid))
def tearDown(self):
self.tmp_content.remove()
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_Browse(self):
""" tries to find the activated FSStore backend
and browses its root.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_second_answer(r,childcount):
try:
self.assertEqual(int(r['TotalMatches']), childcount)
d.callback(None)
except:
d.errback()
def got_first_answer(r):
try:
self.assertEqual(int(r['TotalMatches']), 1)
except:
d.errback()
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
try:
self.assertEqual(item.childCount, 3)
except:
d.errback()
call = mediaserver.client.content_directory.browse(object_id=item.id,
process_result=False)
call.addCallback(got_second_answer,item.childCount)
return call
call = mediaserver.client.content_directory.browse(process_result=False)
call.addCallback(got_first_answer)
self.coherence.ctrl.add_query(DeviceQuery('uuid', str(self.uuid), the_result, timeout=10, oneshot=True))
return d
def test_Browse_Metadata(self):
""" tries to find the activated FSStore backend
and requests metadata for ObjectID 0.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_first_answer(r):
try:
self.assertEqual(int(r['TotalMatches']), 1)
except:
d.errback()
return
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
try:
self.assertEqual(item.title, 'root')
except:
d.errback()
return
d.callback(None)
call = mediaserver.client.content_directory.browse(object_id='0',browse_flag='BrowseMetadata',process_result=False)
call.addCallback(got_first_answer)
call.addErrback(lambda x: d.errback(None))
self.coherence.ctrl.add_query(DeviceQuery('uuid', str(self.uuid), the_result, timeout=10, oneshot=True))
return d
def test_XBOX_Browse(self):
""" tries to find the activated FSStore backend
and browses all audio files.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_first_answer(r):
""" we expect four audio files here """
try:
self.assertEqual(int(r['TotalMatches']), 4)
except:
d.errback()
return
d.callback(None)
def my_browse(*args,**kwargs):
kwargs['ContainerID'] = kwargs['ObjectID']
del kwargs['ObjectID']
del kwargs['BrowseFlag']
kwargs['SearchCriteria'] = ''
return 'Search',kwargs
#mediaserver.client.overlay_actions = {'Browse':my_browse}
mediaserver.client.overlay_headers = {'user-agent':'Xbox/Coherence emulation'}
call = mediaserver.client.content_directory.browse(object_id='4',process_result=False)
call.addCallback(got_first_answer)
call.addErrback(lambda x: d.errback(None))
self.coherence.ctrl.add_query(DeviceQuery('uuid', str(self.uuid), the_result, timeout=10, oneshot=True))
return d
def test_XBOX_Browse_Metadata(self):
""" tries to find the activated FSStore backend
and requests metadata for ObjectID 0.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_first_answer(r):
""" we expect one item here """
try:
self.assertEqual(int(r['TotalMatches']), 1)
except:
d.errback()
return
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
try:
self.assertEqual(item.title, 'root')
except:
d.errback()
return
d.callback(None)
mediaserver.client.overlay_headers = {'user-agent':'Xbox/Coherence emulation'}
call = mediaserver.client.content_directory.browse(object_id='0',browse_flag='BrowseMetadata',process_result=False)
call.addCallback(got_first_answer)
call.addErrback(lambda x: d.errback(None))
self.coherence.ctrl.add_query(DeviceQuery('uuid', str(self.uuid), the_result, timeout=10, oneshot=True))
return d
def test_XBOX_Search(self):
""" tries to find the activated FSStore backend
and searches for all its audio files.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_first_answer(r):
""" we expect four audio files here """
try:
self.assertEqual(len(r), 4)
except:
d.errback()
d.callback(None)
mediaserver.client.overlay_headers = {'user-agent':'Xbox/Coherence emulation'}
call = mediaserver.client.content_directory.search(container_id='4',
criteria='')
call.addCallback(got_first_answer)
call.addErrback(lambda x: d.errback(None))
self.coherence.ctrl.add_query(DeviceQuery('uuid', str(self.uuid), the_result, timeout=10, oneshot=True))
return d
class TestDBUS(unittest.TestCase):
if not dbus:
skip = "Python dbus-bindings not available."
elif gireactor is None:
skip = "Python dbus-bindings not available, we need" \
"a twisted.internet.gireactor.GIReactor"
def setUp(self):
self.coherence = Coherence({
'unittest': 'yes',
'logmode': 'error',
'use_dbus': 'yes',
'controlpoint': 'yes'
})
self.bus = dbus.SessionBus()
self.coherence_service = self.bus.get_object(BUS_NAME, OBJECT_PATH)
self.uuid = str(uuid.UUID())
def tearDown(self):
def cleaner(r):
self.coherence.clear()
if "twisted.internet.reactor" in sys.modules:
del sys.modules["twisted.internet.reactor"]
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
@get_the_gireactor
def test_dbus_version(self):
""" tests the version number request via dbus
"""
d = Deferred()
@wrapped(d)
def handle_version_reply(version):
self.assertEqual(version, __version__)
d.callback(version)
self.coherence_service.version(dbus_interface=BUS_NAME,
reply_handler=handle_version_reply,
error_handler=d.errback)
return d
@get_the_gireactor
def test_dbus_plugin_add_and_remove(self):
""" tests creation and removal of a backend via dbus
"""
d = Deferred()
@wrapped(d)
def add_it(uuid):
self.coherence_service.add_plugin(
'YouTubeStore', {
'name': 'dbus-test-youtube-%d' % os.getpid(),
'uuid': uuid
},
dbus_interface=BUS_NAME,
reply_handler=handle_add_plugin_reply,
error_handler=d.errback)
@wrapped(d)
def handle_add_plugin_reply(uuid):
self.assertEqual(self.uuid, uuid)
reactor.callLater(2, remove_it, uuid)
@wrapped(d)
def remove_it(uuid):
self.coherence_service.remove_plugin(
uuid,
dbus_interface=BUS_NAME,
reply_handler=handle_remove_plugin_reply,
error_handler=d.errback)
@wrapped(d)
def handle_remove_plugin_reply(uuid):
self.assertEqual(self.uuid, uuid)
d.callback(uuid)
add_it(self.uuid)
return d
class MirabeauController(object):
coherence_started_cb = lambda: None
def start(self):
# TODO: select correct window class depending on platform
main_window = MainWindow(self)
main_window.show_all()
def load_config(self):
self.first_run = False
if not os.path.exists(BASEDIR):
os.makedirs(BASEDIR)
if not os.path.exists(CONFIG_PATH):
self.first_run = True
default_account = ''
vars = locals()
vars["MR_UUID"] = MR_UUID
cfg = DEFAULT_CONFIG % vars
fd = open(CONFIG_PATH, "w")
fd.write(cfg)
fd.close()
self.config = Config(CONFIG_PATH, root='config', element2attr_mappings={'active':'active'})
def reload_config(self):
self.config.save()
self.load_config()
def enable_mirabeau(self):
self.config.set("enable_mirabeau", "yes")
self.reload_config()
def disable_mirabeau(self):
self.config.set("enable_mirabeau", "no")
self.reload_config()
def platform_media_directories(self):
candidates = ["~/MyDocs/.images", "~/MyDocs/.sounds", "~/MyDocs/.videos",
"~/MyDocs/DCIM", "~/MyDocs/Music", "~/MyDocs/Videos",
]
expanded = [os.path.expanduser(c) for c in candidates]
dirs = [c for c in expanded if os.path.isdir(c)]
return dirs
def enable_media_server(self, nickname=None):
nickname = nickname or "N900"
name_template = _("%(nickname)s Media Files")
def generate_cfg(nickname):
directories = self.platform_media_directories()
name = name_template % locals()
opts = dict(uuid=MS_UUID, name=name, content=",".join(directories),
backend="FSStore", active="yes")
return XmlDictObject(initdict=opts)
plugins = self.config.get("plugin")
if not plugins:
self.config.set("plugin", generate_cfg())
else:
if isinstance(plugins, XmlDictObject):
plugins = [plugins,]
already_in_config = False
for plugin in plugins:
if plugin.get("uuid") == MS_UUID:
plugin.active = "yes"
plugin.name = name_template % locals()
already_in_config = True
break
if not already_in_config:
plugins.append(generate_cfg(nickname))
self.config.set("plugin", plugins)
self.reload_config()
def disable_media_server(self):
plugins = self.config.get("plugin")
if plugins:
if isinstance(plugins, XmlDictObject):
plugins = [plugins,]
for plugin in plugins:
if plugin.get("uuid") == MS_UUID:
plugin.active = "no"
break
self.config.set("plugin", plugins)
self.reload_config()
def media_server_enabled(self):
plugins = self.config.get("plugin")
if plugins:
if isinstance(plugins, XmlDictObject):
plugins = [plugins,]
for plugin in plugins:
if plugin.get("uuid") == MS_UUID and \
plugin.active == "yes":
return True
return False
def set_media_renderer_name(self, nickname=None):
nickname = nickname or "N900"
name_template = _("%(nickname)s Media Renderer")
plugins = self.config.get("plugin")
if plugins:
if isinstance(plugins, XmlDictObject):
plugins = [plugins,]
for plugin in plugins:
if plugin.get("uuid") == MR_UUID:
plugin.name = name_template % locals()
break
self.config.set("plugin", plugins)
self.reload_config()
def start_coherence(self, restart=False):
def start():
if self.config.get("mirabeau").get("account"):
self.enable_mirabeau()
else:
self.disable_mirabeau()
self.coherence_instance = Coherence(self.config.config)
if restart:
if self.coherence_instance:
dfr = self.stop_coherence()
dfr.addCallback(lambda result: start())
return dfr
else:
start()
else:
start()
if self.coherence_instance:
self.coherence_started_cb()
def stop_coherence(self):
def stopped(result):
if self.coherence_instance:
self.coherence_instance.clear()
self.coherence_instance = None
dfr = self.coherence_instance.shutdown(force=True)
dfr.addBoth(stopped)
return dfr
def toggle_coherence(self):
if self.coherence_instance:
self.stop_coherence()
else:
self.start_coherence()
def update_settings(self, chatroom, conf_server, account, account_nickname,
media_server_enabled):
mirabeau_section = self.config.get("mirabeau")
mirabeau_section.set("chatroom", chatroom)
mirabeau_section.set("conference-server", conf_server)
mirabeau_section.set("account", account)
self.config.set("mirabeau", mirabeau_section)
self.reload_config()
nickname = account_nickname
self.set_media_renderer_name(nickname)
if media_server_enabled:
self.enable_media_server(nickname=nickname)
else:
self.disable_media_server()
self.start_coherence(restart=True)
class TestDBUS(unittest.TestCase):
def setUp(self):
louie.reset()
self.coherence = Coherence({'unittest':'yes','logmode':'error','use_dbus':'yes','controlpoint':'yes'})
self.bus = dbus.SessionBus()
self.coherence_service = self.bus.get_object(BUS_NAME,OBJECT_PATH)
self.uuid = UUID()
def tearDown(self):
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_dbus_version(self):
""" tests the version number request via dbus
"""
d = Deferred()
def handle_version_reply(version):
self.assertEqual(version,__version__)
d.callback(version)
def handle_error(err):
d.errback(err)
self.coherence_service.version(dbus_interface=BUS_NAME,
reply_handler=handle_version_reply,
error_handler=handle_error)
return d
def test_dbus_plugin_add_and_remove(self):
""" tests creation and removal of a backend via dbus
"""
d = Deferred()
def handle_error(err):
d.errback(err)
def handle_add_plugin_reply(uuid):
uuid = str(uuid)
self.assertEqual(str(self.uuid),uuid)
def remove_it(uuid):
def handle_remove_plugin_reply(uuid):
self.assertEqual(str(self.uuid),uuid)
d.callback(uuid)
self.coherence_service.remove_plugin(uuid,
dbus_interface=BUS_NAME,
reply_handler=handle_remove_plugin_reply,
error_handler=handle_error)
reactor.callLater(2,remove_it,uuid)
self.coherence_service.add_plugin('SimpleLight',{'name':'dbus-test-light-%d'%os.getpid(),'uuid':str(self.uuid)},
dbus_interface=BUS_NAME,
reply_handler=handle_add_plugin_reply,
error_handler=handle_error)
return d
class TestContentDirectoryServer(unittest.TestCase):
def setUp(self):
self.tmp_content = FilePath(self.mktemp())
f = self.tmp_content.child('content')
audio = f.child('audio')
f.child('images').makedirs()
f.child('video').makedirs()
album = audio.child('album-1')
album.makedirs()
album.child('track-1.mp3').touch()
album.child('track-2.mp3').touch()
album = audio.child('album-2')
album.makedirs()
album.child('track-1.ogg').touch()
album.child('track-2.ogg').touch()
louie.reset()
self.coherence = Coherence(
{'unittest': 'yes',
'logmode': 'critical',
'no-subsystem_log': {'controlpoint': 'error',
'action': 'info',
'soap': 'error'},
'controlpoint': 'yes'})
self.uuid = str(UUID())
self.coherence.add_plugin('FSStore',
name='MediaServer-%d' % os.getpid(),
content=self.tmp_content.path,
uuid=self.uuid,
enable_inotify=False)
def tearDown(self):
self.tmp_content.remove()
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_Browse(self):
""" tries to find the activated FSStore backend
and browses its root.
"""
d = Deferred()
@wrapped(d)
def the_result(mediaserver):
cdc = mediaserver.client.content_directory
self.assertEqual(self.uuid, mediaserver.udn)
call = cdc.browse(process_result=False)
call.addCallback(got_first_answer, cdc)
@wrapped(d)
def got_first_answer(r, cdc):
self.assertEqual(int(r['TotalMatches']), 1)
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
self.assertEqual(item.childCount, 3)
call = cdc.browse(object_id=item.id, process_result=False)
call.addCallback(got_second_answer, item.childCount)
@wrapped(d)
def got_second_answer(r, childcount):
self.assertEqual(int(r['TotalMatches']), childcount)
d.callback(None)
self.coherence.ctrl.add_query(
DeviceQuery('uuid', self.uuid,
the_result, timeout=10, oneshot=True))
return d
def test_Browse_Non_Existing_Object(self):
d = Deferred()
@wrapped(d)
def the_result(mediaserver):
cdc = mediaserver.client.content_directory
self.assertEqual(self.uuid, mediaserver.udn)
call = cdc.browse(object_id='9999.nothing', process_result=False)
call.addCallback(got_first_answer)
@wrapped(d)
def got_first_answer(r):
self.assertIs(r, None)
d.callback(None)
self.coherence.ctrl.add_query(
DeviceQuery('uuid', self.uuid, the_result,
timeout=10, oneshot=True))
return d
def test_Browse_Metadata(self):
""" tries to find the activated FSStore backend
and requests metadata for ObjectID 0.
"""
d = Deferred()
@wrapped(d)
def the_result(mediaserver):
self.assertEqual(self.uuid, mediaserver.udn)
cdc = mediaserver.client.content_directory
call = cdc.browse(object_id='0', browse_flag='BrowseMetadata',
process_result=False)
call.addCallback(got_first_answer)
@wrapped(d)
def got_first_answer(r):
self.assertEqual(int(r['TotalMatches']), 1)
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
self.assertEqual(item.title, 'root')
d.callback(None)
self.coherence.ctrl.add_query(
DeviceQuery('uuid', self.uuid,
the_result, timeout=10, oneshot=True))
return d
def test_XBOX_Browse(self):
""" tries to find the activated FSStore backend
and browses all audio files.
"""
d = Deferred()
@wrapped(d)
def the_result(mediaserver):
mediaserver.client.overlay_headers = {'user-agent': 'Xbox/Coherence emulation'}
cdc = mediaserver.client.content_directory
self.assertEqual(self.uuid, mediaserver.udn)
call = cdc.browse(object_id='4', process_result=False)
call.addCallback(got_first_answer)
@wrapped(d)
def got_first_answer(r):
""" we expect four audio files here """
self.assertEqual(int(r['TotalMatches']), 4)
d.callback(None)
d = Deferred()
self.coherence.ctrl.add_query(
DeviceQuery('uuid', self.uuid, the_result,
timeout=10, oneshot=True))
return d
def test_XBOX_Browse_Metadata(self):
""" tries to find the activated FSStore backend
and requests metadata for ObjectID 0.
"""
d = Deferred()
@wrapped(d)
def the_result(mediaserver):
mediaserver.client.overlay_headers = {
'user-agent': 'Xbox/Coherence emulation'}
cdc = mediaserver.client.content_directory
self.assertEqual(self.uuid, mediaserver.udn)
call = cdc.browse(object_id='0', browse_flag='BrowseMetadata',
process_result=False)
call.addCallback(got_first_answer)
@wrapped(d)
def got_first_answer(r):
""" we expect one item here """
self.assertEqual(int(r['TotalMatches']), 1)
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
self.assertEqual(item.title, 'root')
d.callback(None)
self.coherence.ctrl.add_query(
DeviceQuery('uuid', self.uuid, the_result,
timeout=10, oneshot=True))
return d
def test_XBOX_Search(self):
""" tries to find the activated FSStore backend
and searches for all its audio files.
"""
d = Deferred()
@wrapped(d)
def the_result(mediaserver):
mediaserver.client.overlay_headers = {
'user-agent': 'Xbox/Coherence emulation'}
cdc = mediaserver.client.content_directory
self.assertEqual(self.uuid, mediaserver.udn)
call = cdc.search(container_id='4', criteria='')
call.addCallback(got_first_answer)
@wrapped(d)
def got_first_answer(r):
""" we expect four audio files here """
self.assertEqual(len(r), 4)
d.callback(None)
self.coherence.ctrl.add_query(
DeviceQuery('uuid', self.uuid, the_result,
timeout=10, oneshot=True))
return d
class TestDBUS(unittest.TestCase):
if not dbus:
skip = "Python dbus-bindings not available."
elif reactor.__class__.__name__ != 'Glib2Reactor':
skip = ("This test needs a Glib2Reactor, please start trial "
"with the '-r glib2' option.")
def setUp(self):
louie.reset()
self.coherence = Coherence({'unittest': 'yes', 'logmode': 'error', 'use_dbus': 'yes', 'controlpoint': 'yes'})
self.bus = dbus.SessionBus()
self.coherence_service = self.bus.get_object(BUS_NAME, OBJECT_PATH)
self.uuid = str(uuid.UUID())
def tearDown(self):
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_dbus_version(self):
""" tests the version number request via dbus
"""
d = Deferred()
@wrapped(d)
def handle_version_reply(version):
self.assertEqual(version, __version__)
d.callback(version)
self.coherence_service.version(dbus_interface=BUS_NAME,
reply_handler=handle_version_reply,
error_handler=d.errback)
return d
def test_dbus_plugin_add_and_remove(self):
""" tests creation and removal of a backend via dbus
"""
d = Deferred()
@wrapped(d)
def add_it(uuid):
self.coherence_service.add_plugin(
'SimpleLight', {'name': 'dbus-test-light-%d' % os.getpid(), 'uuid': uuid},
dbus_interface=BUS_NAME,
reply_handler=handle_add_plugin_reply,
error_handler=d.errback)
@wrapped(d)
def handle_add_plugin_reply(uuid):
self.assertEqual(self.uuid, uuid)
reactor.callLater(2, remove_it, uuid)
@wrapped(d)
def remove_it(uuid):
self.coherence_service.remove_plugin(
uuid,
dbus_interface=BUS_NAME,
reply_handler=handle_remove_plugin_reply,
error_handler=d.errback)
@wrapped(d)
def handle_remove_plugin_reply(uuid):
self.assertEqual(self.uuid, uuid)
d.callback(uuid)
add_it(self.uuid)
return d
