def __init__(self, device):
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.register_event('device_client_detection_completed', )
self.device = device
self.device.bind(embedded_device_client_detection_completed=self.
embedded_device_notified) # noqa
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.wan_device = None
try:
wan_device = self.device.get_embedded_device_by_type(
'WANDevice')[0]
self.wan_device = WANDeviceClient(wan_device)
except Exception as e:
self.warning(f'Embedded WANDevice device not available, device not'
f' implemented properly according to the UPnP'
f' specification [error: {e}]')
raise
self.info(f'InternetGatewayDevice {device.get_friendly_name()}')
def __init__(self, test=False, interface=''):
'''Initialize the SSDP server.'''
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.register_event('datagram_received', 'new_device',
'removed_device', 'log')
self.known = {}
self._callbacks = {}
self.test = test
if not self.test:
self.port = reactor.listenMulticast(
SSDP_PORT,
self,
listenMultiple=True,
interface=interface,
)
self.port.joinGroup(SSDP_ADDR, interface=interface)
self.resend_notify_loop = task.LoopingCall(self.resendNotify)
self.resend_notify_loop.start(777.0, now=False)
self.check_valid_loop = task.LoopingCall(self.check_valid)
self.check_valid_loop.start(333.0, now=False)
self.active_calls = []
def __init__(self, service, dbus_device, bus):
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.service = service
self.dbus_device = dbus_device
# get the service name
self.type = self.service.service_type.split(':')[3]
bus_name = dbus.service.BusName(CDS_SERVICE, bus)
device_id = dbus_device.id
self.path = (OBJECT_PATH + '/devices/' + device_id + '/services/' +
'CDS')
dbus.service.Object.__init__(
self,
bus,
bus_name=bus_name,
object_path=self.path,
)
self.debug(f'DBusService {service} {self.type}')
if isinstance(self.service, EventDispatcher):
self.service.bind(state_variable_changed=self.variable_changed)
self.subscribeStateVariables()
def __init__(self, coherence, backend, **kwargs):
EventDispatcher.__init__(self)
self.coherence = coherence
if not hasattr(self, 'version'):
self.version = int(
kwargs.get('version', self.coherence.config.get('version', 2)))
try:
self.uuid = str(kwargs['uuid'])
if not self.uuid.startswith('uuid:'):
self.uuid = 'uuid:' + self.uuid
except KeyError:
from coherence.upnp.core.uuid import UUID
self.uuid = UUID()
urlbase = str(self.coherence.urlbase)
if urlbase[-1] != '/':
urlbase += '/'
self.urlbase = urlbase + str(self.uuid)[5:]
kwargs['urlbase'] = self.urlbase
self.icons = kwargs.get('iconlist', kwargs.get('icons', []))
if len(self.icons) == 0:
if 'icon' in kwargs:
if isinstance(kwargs['icon'], dict):
self.icons.append(kwargs['icon'])
else:
self.icons = kwargs['icon']
reactor.callLater(0.2, self.fire, backend, **kwargs)
def __init__(self, device):
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.register_event('embedded_device_client_detection_completed')
self.device = device
self.device.bind(service_notified=self.service_notified)
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.wan_ip_connection = None
self.wan_ppp_connection = None
for service in self.device.get_services():
if service.get_type() in [
'urn:schemas-upnp-org:service:WANIPConnection:1'
]:
self.wan_ip_connection = WANIPConnectionClient(service)
if service.get_type() in [
'urn:schemas-upnp-org:service:WANPPPConnection:1'
]:
self.wan_ppp_connection = WANPPPConnectionClient(service)
self.info(f'WANConnectionDevice {device.get_friendly_name()}')
if self.wan_ip_connection:
self.info('WANIPConnection service available')
if self.wan_ppp_connection:
self.info('WANPPPConnection service available')
def __init__(self, ssdp_server, test=False):
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.register_event('datagram_received')
self.ssdp_server = ssdp_server
if not test:
self.port = reactor.listenUDP(0, self)
self.double_discover_loop = task.LoopingCall(self.double_discover)
self.double_discover_loop.start(120.0)
def __init__(self, focus=None):
"""
"""
#TODO: make it a singleton
EventDispatcher.__init__(self)
self._focus = focus
self._blocking = 0
self._running = True
self.__events = []
def __init__(self, service):
resource.Resource.__init__(self)
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.register_event('event_client_message_received')
self.service = service
self.subscribers = service.get_subscribers()
try:
self.backend_name = self.service.backend.name
except AttributeError:
self.backend_name = self.service.backend
def __init__(self, *args, **kwargs):
EventDispatcher.__init__(self)
log.LogAble.__init__(self)
self.register_event(
'response_flush',
'response_event',
'response_volume',
'response_mute',
'response_repeat',
'response_browse',
)
def __init__(self, type, pattern, callback, timeout=0, oneshot=True):
EventDispatcher.__init__(self)
self.type = type
self.pattern = pattern
self.callback = callback
self.timeout = timeout
self.oneshot = oneshot
if self.type == 'uuid' and self.pattern.startswith('uuid:'):
self.pattern = self.pattern[5:]
if isinstance(self.callback, str):
# print(f'DeviceQuery: register event {self.callback}')
self.register_event(self.callback)
def __init__(self, device):
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.register_event('device_client_detection_completed', )
self.device = device
self.device.bind(device_service_notified=self.service_notified)
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.scheduled_recording = None
self.connection_manager = None
self.av_transport = None
for service in self.device.get_services():
if service.get_type() in [
'urn:schemas-upnp-org:service:ContentDirectory:1',
'urn:schemas-upnp-org:service:ContentDirectory:2'
]:
self.content_directory = ContentDirectoryClient(service)
if service.get_type() in [
'urn:schemas-upnp-org:service:ConnectionManager:1',
'urn:schemas-upnp-org:service:ConnectionManager:2'
]:
self.connection_manager = ConnectionManagerClient(service)
if service.get_type() in [
'urn:schemas-upnp-org:service:AVTransport:1',
'urn:schemas-upnp-org:service:AVTransport:2'
]:
self.av_transport = AVTransportClient(service)
if service.detection_completed:
self.service_notified(service)
self.info(f'MediaServer {device.get_friendly_name()}')
if self.content_directory:
self.info('ContentDirectory available')
else:
self.warning(
'ContentDirectory not available, device not implemented'
' properly according to the UPnP specification')
return
if self.connection_manager:
self.info('ConnectionManager available')
else:
self.warning(
'ConnectionManager not available, device not implemented'
' properly according to the UPnP specification')
return
if self.av_transport:
self.info('AVTransport (optional) available')
if self.scheduled_recording:
self.info('ScheduledRecording (optional) available')
def __init__(self, control_point):
log.LogAble.__init__(self)
resource.Resource.__init__(self)
EventDispatcher.__init__(self)
self.register_event('event_server_message_received')
self.coherence = control_point.coherence
self.control_point = control_point
self.coherence.add_web_resource('events', self)
global hostname, web_server_port
hostname = self.coherence.hostname
web_server_port = self.coherence.web_server_port
self.info('EventServer ready...')
def __init__(
self,
upnp_service,
name,
implementation,
instance,
send_events,
data_type,
allowed_values,
):
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.service = upnp_service
self.dispatch_events = [
f'state_variable_{name}_changed',
'state_variable_changed',
]
self.dispatch_targets = [self]
if isinstance(self.service, EventDispatcher):
self.dispatch_targets.append(self.service)
for target in self.dispatch_targets:
for evt in self.dispatch_events:
if evt not in target.event_dispatcher_event_callbacks:
target.register_event(evt)
self.name = name
self.implementation = implementation
self.instance = instance
self.send_events = utils.means_true(send_events)
self.never_evented = False
self.data_type = data_type
self.allowed_values = allowed_values
if self.allowed_values is None:
self.allowed_values = []
self.has_vendor_values = False
self.allowed_value_range = None
self.dependant_variable = None
self.default_value = ''
self.old_value = ''
self.value = ''
self.last_time_touched = None
self._callbacks = []
if isinstance(self.service, service.ServiceServer):
self.moderated = self.service.is_variable_moderated(name)
self.updated = False
def __init__(self, parent=None, udn=None):
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.register_event(
'device_detection_completed',
'device_remove_client',
'device_service_notified',
'device_got_client',
)
self.parent = parent
self.udn = udn
# self.uid = self.usn[:-len(self.st)-2]
self.friendly_name = ''
self.device_type = ''
self.upnp_version = 'n/a'
self.friendly_device_type = '[unknown]'
self.device_type_version = 0
def __init__(self, server, *args, **kwargs):
'''
Args:
server (object): This usually should be an instance of our main
class :class:`~coherence.base.Coherence` (the UPnP device
that's hosting our backend).
*args (list): A list with extra arguments for the backend. This,
must be implemented into the subclass (if needed).
**kwargs (dict): An unpacked dictionary with the backend's
configuration.
'''
self.config = kwargs
self.server = server
EventDispatcher.__init__(self)
log.LogAble.__init__(self)
Plugin.__init__(self)
self.register_event('backend_init_completed', 'backend_init_failed')
def __init__(self, device):
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.register_event(
'embedded_device_client_detection_completed',
)
self.device = device
self.device.bind(
embedded_device_client_detection_completed=self.embedded_device_notified, # noqa
service_notified=self.service_notified
)
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.wan_connection_device = None
self.wan_common_interface_connection = None
try:
wan_connection_device = \
self.device.get_embedded_device_by_type(
'WANConnectionDevice')[0]
self.wan_connection_device = WANConnectionDeviceClient(
wan_connection_device)
except Exception as er:
self.warning(
f'Embedded WANConnectionDevice device not available, device '
f'not implemented properly according to the UPnP '
f'specification [ERROR: {er}]')
raise
for service in self.device.get_services():
if service.get_type() in [
'urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1']:
self.wan_common_interface_connection = \
WANCommonInterfaceConfigClient(service)
self.info(f'WANDevice {device.get_friendly_name()}')
def __init__(self, coherence, auto_client=None):
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.register_event('control_point_client_detected',
'control_point_client_removed')
if not auto_client:
auto_client = ['MediaServer', 'MediaRenderer']
self.coherence = coherence
self.auto_client = auto_client
self.coherence.bind(
coherence_device_detection_completed=self.check_device,
coherence_device_removed=self.remove_client,
)
self.info('Coherence UPnP ControlPoint starting...')
self.event_server = EventServer(self)
self.coherence.add_web_resource('RPC2', XMLRPC(self))
for device in self.get_devices():
self.info(f'ControlPoint [check device]: {device}')
self.check_device(device)
def __init__(self, config=None):
# initialize only once
if self.__initialized:
return
self.__initialized = True
# supers
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.register_event(
'coherence_device_detection_completed',
'coherence_device_removed',
'coherence_root_device_removed',
)
self.config = config or {}
self.available_plugins = None
self.external_address = None
self.urlbase = None
self.web_server_port = int(config.get('serverport', 8080))
self.setup_logger()
self.setup_hostname()
if self.hostname.startswith('127.'):
# use interface detection via routing table as last resort
def catch_result(hostname):
self.hostname = hostname
self.setup_part2()
d = defer.maybeDeferred(get_host_address)
d.addCallback(catch_result)
else:
self.setup_part2()
def __init__(self, config=None):
# initialize only once
if self.__initialized:
return
self.__initialized = True
# supers
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.register_event(
'coherence_device_detection_completed',
'coherence_device_removed',
'coherence_root_device_removed',
)
self.config = config or {}
self.available_plugins = None
self.external_address = None
self.urlbase = None
self.web_server_port = int(config.get('serverport', 8080))
# initializes log's system, a COHEN_DEBUG environment
# variable overwrites all level settings here.
try:
logmode = config.get('logging').get('level', 'warning')
except (KeyError, AttributeError):
logmode = config.get('logmode', 'warning')
try:
subsystems = config.get('logging')['subsystem']
if isinstance(subsystems, dict):
subsystems = [subsystems]
for subsystem in subsystems:
try:
if subsystem['active'] == 'no':
continue
except (KeyError, TypeError):
pass
self.info(f'setting log-level for subsystem '
f'{subsystem["name"]} to {subsystem["level"]}')
logging.getLogger(subsystem['name'].lower()).setLevel(
subsystem['level'].upper())
except (KeyError, TypeError):
subsystem_log = config.get('subsystem_log', {})
for subsystem, level in list(subsystem_log.items()):
logging.getLogger(subsystem.lower()).setLevel(level.upper())
try:
logfile = config.get('logging').get('logfile', None)
if logfile is not None:
logfile = str(logfile)
except (KeyError, AttributeError, TypeError):
logfile = config.get('logfile', None)
log.init(logfile, logmode.upper())
self.warning(f'Coherence UPnP framework version {__version__} '
f'starting [log level: {logmode}]...')
network_if = config.get('interface')
if network_if:
self.hostname = get_ip_address(f'{network_if}')
else:
try:
self.hostname = socket.gethostbyname(socket.gethostname())
except socket.gaierror:
self.warning('hostname can\'t be resolved, '
'maybe a system misconfiguration?')
self.hostname = '127.0.0.1'
if self.hostname.startswith('127.'):
# use interface detection via routing table as last resort
def catch_result(hostname):
self.hostname = hostname
self.setup_part2()
d = defer.maybeDeferred(get_host_address)
d.addCallback(catch_result)
else:
self.setup_part2()
def __init__(self, device):
log.LogAble.__init__(self)
EventDispatcher.__init__(self)
self.register_event('device_client_detection_completed', )
self.device = device
self.device.bind(device_service_notified=self.service_notified)
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.rendering_control = None
self.connection_manager = None
self.av_transport = None
for service in self.device.get_services():
if service.get_type() in [
'urn:schemas-upnp-org:service:RenderingControl:1',
'urn:schemas-upnp-org:service:RenderingControl:2'
]:
self.rendering_control = RenderingControlClient(service)
if service.get_type() in [
'urn:schemas-upnp-org:service:ConnectionManager:1',
'urn:schemas-upnp-org:service:ConnectionManager:2'
]:
self.connection_manager = ConnectionManagerClient(service)
if service.get_type() in [
'urn:schemas-upnp-org:service:AVTransport:1',
'urn:schemas-upnp-org:service:AVTransport:2'
]:
self.av_transport = AVTransportClient(service)
if service.detection_completed:
self.service_notified(service)
self.info(f'MediaRenderer {device.get_friendly_name()}')
if self.rendering_control:
self.info('RenderingControl available')
'''
actions = self.rendering_control.service.get_actions()
print actions
for action in actions:
print 'Action:', action
for arg in actions[action].get_arguments_list():
print ' ', arg
'''
# self.rendering_control.list_presets()
# self.rendering_control.get_mute()
# self.rendering_control.get_volume()
# self.rendering_control.set_mute(desired_mute=1)
else:
self.warning(
'RenderingControl not available, device not implemented'
' properly according to the UPnP specification')
return
if self.connection_manager:
self.info('ConnectionManager available')
# self.connection_manager.get_protocol_info()
else:
self.warning(
'ConnectionManager not available, device not implemented'
' properly according to the UPnP specification')
return
if self.av_transport:
self.info('AVTransport (optional) available')
def __init__(self, *args, **kwargs):
EventDispatcher.__init__(self)
log.LogAble.__init__(self)
def __init__(self, *args, **kwargs):
EventDispatcher.__init__(self)
self.register_event('control_client_command_received')
