예제 #1
0
 def startService(self):
     '''
     '''
     self.location = "http://%s:" % get_default_v4_address() + str(
         self.getPort())
     for device in self.devices:
         device.location = "http://%s:" + str(self.getPort())
         device.icons = [
             DeviceIcon(
                 'image/png', 32, 32, 24,
                 device.getLocation(get_default_v4_address()) +
                 '/pictures/icon.png')
         ]
     log.msg('UPnP Service Started', loglevel=logging.INFO)
     self.started = True
예제 #2
0
    def send_NOTIFY(self, nt, uuid=None, nts='ssdp:alive'):
        if self.ssdp.device.bootID is None:
            self.ssdp.device.bootID = int(time.time())

        location = self.ssdp.device.getLocation(get_default_v4_address())

        if uuid is None:
            uuid = self.ssdp.device.uuid

        usn, nt = build_notification_type(uuid, nt)

        log.msg("send_NOTIFY %s:%s" % (nts, usn))

        headers = {
            # max-age is notifySequenceInterval + 10 minutes
            'CACHE-CONTROL':
            'max-age = %d' % (self.notifySequenceInterval + (10 * 60)),
            'LOCATION':
            location,
            'SERVER':
            self.ssdp.device.server,
            'NT':
            nt,
            'NTS':
            nts,
            'USN':
            usn,
            'BOOTID.UPNP.ORG':
            self.ssdp.device.bootID,
            'CONFIGID.UPNP.ORG':
            self.ssdp.device.configID
        }

        self.send('NOTIFY', headers, (SSDP_ADDR_V4, SSDP_PORT))
예제 #3
0
파일: upnp.py 프로젝트: bverdu/onDemand
 def startService(self):
     '''
     '''
     self.location = "http://%s:" % get_default_v4_address() + str(
         self.getPort())
     for device in self.devices:
         device.location = "http://%s:" + str(self.getPort())
         device.icons = [
             DeviceIcon(
                 'image/png',
                 32, 32, 24,
                 device.getLocation(
                     get_default_v4_address(
                     )) + '/pictures/icon.png')]
     log.msg('UPnP Service Started', loglevel=logging.INFO)
     self.started = True
예제 #4
0
파일: ssdp.py 프로젝트: bverdu/onDemand
    def send_NOTIFY(self, nt, uuid=None, nts="ssdp:alive"):
        if self.ssdp.device.bootID is None:
            self.ssdp.device.bootID = int(time.time())

        location = self.ssdp.device.getLocation(get_default_v4_address())

        if uuid is None:
            uuid = self.ssdp.device.uuid

        usn, nt = build_notification_type(uuid, nt)

        log.msg("send_NOTIFY %s:%s" % (nts, usn))

        headers = {
            # max-age is notifySequenceInterval + 10 minutes
            "CACHE-CONTROL": "max-age = %d" % (self.notifySequenceInterval + (10 * 60)),
            "LOCATION": location,
            "SERVER": self.ssdp.device.server,
            "NT": nt,
            "NTS": nts,
            "USN": usn,
            "BOOTID.UPNP.ORG": self.ssdp.device.bootID,
            "CONFIGID.UPNP.ORG": self.ssdp.device.configID,
        }

        self.send("NOTIFY", headers, (SSDP_ADDR_V4, SSDP_PORT))
예제 #5
0
 def model(self, ignored):
     log.err('Model from Product')
     return (self.modelName, self.modelDescription, self.manufacturerURL,
             ''.join((
                 self.getLocation(get_default_v4_address()),
                 '/pictures/',
                 self.modelName,
                 '.png',
             )))
예제 #6
0
 def manufacturer(self, ignored):
     log.err('Manufacturer from Product')
     return (
         self.manufacturer,
         self.manufacturerInfo,
         self.manufacturerURL,
         ''.join((self.getLocation(get_default_v4_address()),
                  '/pictures/icon.png')),
     )
예제 #7
0
 def wait_connection(self):
     try:
         addr = self.getLocation(get_default_v4_address())
         setattr(self, 'manufacturerimageurl', addr + '/pictures/icon.png')
         self.oh_product_event('manufacturerimageurl',
                               self.manufacturerimageurl)
         setattr(self, 'modelimageurl', ''.join(
             (addr, '/pictures/', self.modelname, '.png')))
         self.oh_product_event('modelimageurl', self.modelimageurl)
     except:
         reactor.callLater(1, self.wait_connection)  # @UndefinedVariable
예제 #8
0
파일: ohdevice.py 프로젝트: bverdu/onDemand
 def wait_connection(self):
     try:
         addr = self.getLocation(get_default_v4_address())
         setattr(
             self, 'manufacturerimageurl', addr + '/pictures/icon.png')
         self.oh_product_event(
             'manufacturerimageurl', self.manufacturerimageurl)
         setattr(self,
                 'modelimageurl',
                 ''.join((addr, '/pictures/', self.modelname, '.png')))
         self.oh_product_event('modelimageurl', self.modelimageurl)
     except:
         reactor.callLater(1, self.wait_connection)  # @UndefinedVariable
예제 #9
0
 def add_device(self, device):
     self.devices.append(device)
     device.parent = self
     if self.started:
         device.location = "http://%s:" + str(self.getPort())
         device.icons = [
             DeviceIcon(
                 'image/png', 32, 32, 24,
                 device.getLocation(get_default_v4_address()) +
                 '/pictures/icon.png')
         ]
     for service in device.services:
         service.control_resource = TwistedWebResource(service.app)
         service.event_resource = ServiceEventResource(service)
         service.resource = ServiceResource(service)
     self.upnp.addDevice(device)
예제 #10
0
파일: utils.py 프로젝트: bverdu/onDemand
def mpd_decode(dic):
    d = {}
    if isinstance(dic, list):
        log.error('bad info: {dic}', dic=dic)
        return d
    for k in dic.keys():
        if k == 'albumArtURI':
            d.update({k: dic[k]})
        if k == 'Time':
            hrs = int(dic[k]) / 3600
            mn = (int(dic[k]) - hrs * 3600) / 60
            sec = (int(dic[k]) - mn * 60)
            t = ':'.join(['{:0>2}'.format(str(hrs)),
                          '{:0>2}'.format(str(mn)),
                          '{:0>2}'.format(str(sec))])
            d.update({'duration': t})
        elif k in ('Title', 'Date', 'Genre', 'Artist',
                   'Album', 'Composer', 'Id', 'Pos'):
            d.update({k.lower(): dic[k]})  # .decode('utf-8')
        elif k in ('Url', 'file'):
            d.update({'url': dic[k]})   # .decode('utf-8')
            c = dic[k].split('.')[-1]
            if len(c) < 5:
                d.update({'codec': dic[k].split('.')[-1]})
            if dic[k].split('/')[0] in ('http:', 'http'):
                try:
                    d.update(
                        {'protocolInfo': dic[k].split(':')[0] +
                         '-get:*:' +
                         guess_type(dic[k])[0] +
                         ':*'})
                except:
                    pass
            else:
                try:
                    d.update(
                        {'protocolInfo': 'internal:' +
                         get_default_v4_address() +
                         ':' +
                         guess_type(dic[k])[0] +
                         ':local'})
                except:
                    pass
    if 'duration' not in d.keys():
        d.update({'duration': '00:00:00.000'})
    return d
예제 #11
0
파일: upnp.py 프로젝트: bverdu/onDemand
 def add_device(self, device):
     self.devices.append(device)
     device.parent = self
     if self.started:
         device.location = "http://%s:" + str(self.getPort())
         device.icons = [
             DeviceIcon(
                 'image/png',
                 32, 32, 24,
                 device.getLocation(
                     get_default_v4_address(
                     )) + '/pictures/icon.png')]
     for service in device.services:
         service.control_resource = TwistedWebResource(service.app)
         service.event_resource = ServiceEventResource(service)
         service.resource = ServiceResource(service)
     self.upnp.addDevice(device)
예제 #12
0
def mpd_decode(dic):
    d = {}
    if isinstance(dic, list):
        log.error('bad info: {dic}', dic=dic)
        return d
    for k in dic.keys():
        if k == 'albumArtURI':
            d.update({k: dic[k]})
        if k == 'Time':
            hrs = int(dic[k]) / 3600
            mn = (int(dic[k]) - hrs * 3600) / 60
            sec = (int(dic[k]) - mn * 60)
            t = ':'.join([
                '{:0>2}'.format(str(hrs)), '{:0>2}'.format(str(mn)),
                '{:0>2}'.format(str(sec))
            ])
            d.update({'duration': t})
        elif k in ('Title', 'Date', 'Genre', 'Artist', 'Album', 'Composer',
                   'Id', 'Pos'):
            d.update({k.lower(): dic[k]})  # .decode('utf-8')
        elif k in ('Url', 'file'):
            d.update({'url': dic[k]})  # .decode('utf-8')
            c = dic[k].split('.')[-1]
            if len(c) < 5:
                d.update({'codec': dic[k].split('.')[-1]})
            if dic[k].split('/')[0] in ('http:', 'http'):
                try:
                    d.update({
                        'protocolInfo':
                        dic[k].split(':')[0] + '-get:*:' +
                        guess_type(dic[k])[0] + ':*'
                    })
                except:
                    pass
            else:
                try:
                    d.update({
                        'protocolInfo':
                        'internal:' + get_default_v4_address() + ':' +
                        guess_type(dic[k])[0] + ':local'
                    })
                except:
                    pass
    if 'duration' not in d.keys():
        d.update({'duration': '00:00:00.000'})
    return d
예제 #13
0
파일: ssdp.py 프로젝트: bverdu/onDemand
 def __init__(self, device):
     self.services = []
     """
     Initialization of SSDP server
     """
     self.device = device
     if self.device.uuid is None:
         raise ValueError()
     self.targets.append("uuid:" + self.device.uuid)
     self.targets.append(self.device.deviceType)
     for service in self.device.services:
         self.targets.append(service.serviceType)
     if not self.listener:
         self.listener = SSDP_Listener(self)
         self.ssdp = internet.MulticastServer(  # @UndefinedVariable
             SSDP_PORT, self.listener, listenMultiple=True, interface=SSDP_ADDR_V4
         )
         self.ssdp.setServiceParent(self)
         self.client = SSDP_Client(self, get_default_v4_address())
         self.ssdp_client = internet.UDPServer(0, self.client, self.client.interface)  # @UndefinedVariable
         self.ssdp_client.setServiceParent(self)
예제 #14
0
 def __init__(self, device):
     self.services = []
     '''
     Initialization of SSDP server
     '''
     self.device = device
     if self.device.uuid is None:
         raise ValueError()
     self.targets.append('uuid:' + self.device.uuid)
     self.targets.append(self.device.deviceType)
     for service in self.device.services:
         self.targets.append(service.serviceType)
     if not self.listener:
         self.listener = SSDP_Listener(self)
         self.ssdp = internet.MulticastServer(  # @UndefinedVariable
             SSDP_PORT,
             self.listener,
             listenMultiple=True,
             interface=SSDP_ADDR_V4)
         self.ssdp.setServiceParent(self)
         self.client = SSDP_Client(self, get_default_v4_address())
         self.ssdp_client = internet.UDPServer(  # @UndefinedVariable
             0, self.client, self.client.interface)
         self.ssdp_client.setServiceParent(self)
예제 #15
0
파일: ohdevice.py 프로젝트: bverdu/onDemand
 def manufacturer(self, ignored):
     log.err('Manufacturer from Product')
     return (self.manufacturer, self.manufacturerInfo, self.manufacturerURL,
             ''.join((
                 self.getLocation(get_default_v4_address()),
                 '/pictures/icon.png')),)
예제 #16
0
 def register_art_url(self, url, cloud=False):
     if cloud:
         return None
     newurl = hashlib.md5(url).hexdigest() + url[-4:]
     self.resource.putChild(newurl, static.File(url))
     return self.webserver.weburl % get_default_v4_address() + '/' + newurl
예제 #17
0
파일: ssdp.py 프로젝트: bverdu/onDemand
        try:
            self.transport.write(msg, (address, port))
        except socket.error, e:
            log.err("socket.error: %s" % e)

    def respond_MSEARCH(self, st, (address, port)):
        log.msg("respond_MSEARCH to %s:%s, headers=%s" % (address, port, st))

        if self.ssdp.device.bootID is None:
            self.ssdp.device.bootID = int(time.time())

        if address == "127.0.0.1":
            location = self.ssdp.device.getLocation("127.0.0.1")
        else:
            location = self.ssdp.device.getLocation(get_default_v4_address())

        usn, st = build_notification_type(self.ssdp.device.uuid, st)

        headers = {
            "CACHE-CONTROL": "max-age = %d" % self.responseExpire,
            "EXT": "",
            "LOCATION": location,
            "SERVER": self.ssdp.device.server,
            "ST": st,
            "USN": usn,
            "OPT": '"http://schemas.upnp.org/upnp/1/0/"; ns=01',
            "01-NLS": self.ssdp.device.bootID,
            "BOOTID.UPNP.ORG": self.ssdp.device.bootID,
            "CONFIGID.UPNP.ORG": self.ssdp.device.configID,
        }
예제 #18
0
    def __init__(
            self, parent=None, searchables=None, xmldir=None,
            network='lan', cloud_user=None, cloud_servers=[],
            logger=None, uid=None, messager=None):
        self.connected = False
        self.messager = messager
        self.app_paused = False
        self.fail_count = 0
        if not logger:
            self.log = Logger()
        else:
            self.log = logger
        self.log.debug('UPnP controller starts')
        self.xmldir = xmldir
        self.devices = {}
        self._services = {}
        self.parent = parent
#         self.amp = ControllerAmp(self)
        if uid:
            self.uuid = uid
        else:
            self.uuid = str(
                uuid.uuid5(
                    uuid.NAMESPACE_DNS,
                    socket.gethostname() + 'onDemand_Controller'))
        if searchables:
            for typ in searchables:
                self.searchables.update({typ[0]: typ[1]})
#                 print(self.searchables)
        else:
            self.searchables = {'upnp:rootdevice': self.log.debug}
        if network in ('lan', 'both'):
            self.log.debug('UPnP classic enabled')
            self.lan = True
            self.listener = ssdp.SSDP_Listener(self)
            self.mcast = internet.MulticastServer(  # @UndefinedVariable
                SSDP_PORT,
                self.listener,
                listenMultiple=True,
                interface=SSDP_ADDR_V4)
            self.mcast.setServiceParent(self)
            self.ssdp_cli = ssdp.SSDP_Client(
                self, get_default_v4_address(), device=False)
            self.ucast = internet.UDPServer(  # @UndefinedVariable
                0, self.ssdp_cli, self.ssdp_cli.interface)
            self.ucast.setServiceParent(self)
#             self.agent = Agent(reactor)
        if network in ('cloud', 'both'):
            if cloud_user:
                self.log.debug('UPnP Cloud enabled')
                self.cloud = True
                self._jid, secret = cloud_user
                self.users = {self._jid: {'state': True}}
                for user in cloud_servers:
                    self.users.update({user: {'state': False}})
                self.hosts = {}
                self.resourcepart = ''.join((
                    'urn:schemas-upnp-org:cloud-1-0:ControlPoint:1:uuid:',
                    self.uuid))
                full_jid = ''.join(
                    (self._jid, '/', self.resourcepart))
                self.jid = jid = JID(full_jid)
                self.reactor = reactor
                f = client.XMPPClientFactory(jid, secret)
                f.addBootstrap(
                    xmlstream.STREAM_CONNECTED_EVENT, self.cloud_connected)
                f.addBootstrap(
                    xmlstream.STREAM_END_EVENT, self.cloud_disconnected)
                f.addBootstrap(
                    xmlstream.STREAM_AUTHD_EVENT, self.authenticated)
                f.addBootstrap(
                    xmlstream.INIT_FAILED_EVENT, self.cloud_failed)
                self.connector = endpoints.HostnameEndpoint(
                    reactor, jid.host, 5222)
                self.factory = f
예제 #19
0
    def subscribe_classic(
            self, device, svc, var, callback_fct=None,
            callback_args=()):
        if not callback_fct:
            callback_fct = self.log.debug
        name = device.keys()[0]
        dev = device[name]

        def subscribe_failed(err, name):
            self.parent.remove_device(name.split('_')[0])

        def subscribed(req, raddr, host, name):
            try:
                uuid = req.headers.getRawHeaders('sid')[0]
                print('subscription uuid = %s' % uuid)
                if name in self.subscriptions:
                    if host in self.subscriptions[name]:
                        self.subscriptions[name][host].update({uuid: raddr})
                    else:
                        self.subscriptions[name].update({host: {uuid: raddr}})
                else:
                    self.subscriptions.update({name: {host: {uuid: raddr}}})
                reactor.callLater(  # @UndefinedVariable
                    20, self.renew_subscription, uuid)
                return name
            except TypeError:
                return subscribe_failed(None, name)

        if self.event_catcher is None:
            self.event_catcher = EventServer()
            self.event_catcher.setServiceParent(self)
        subscription_id = '_'.join((name, svc.split(':')[-2]))
        childpath = '_'.join((subscription_id, 'event',))
#         log.error(childpath)
        if childpath in self.event_catcher.catcher.childs:
            self.event_catcher.catcher.childs[childpath].update(
                {var: (callback_fct, callback_args,)})
        else:
            self.event_catcher.catcher.childs.update(
                {childpath: {var: (callback_fct, callback_args,)}})
#         log.error(self.event_catcher.catcher.childs)
        if subscription_id in self.subscriptions:
            for k, value in self.event_catcher.catcher.unfiltered.items():
                if k == var:
                    if value == 'False':
                        value = False
                    elif value == 'True':
                        value = True
                    if isinstance(callback_args, str)\
                            or isinstance(callback_args, bool):
                        callback_fct(value, callback_args)
                    else:
                        callback_fct(value, *callback_args)
                    del self.event_catcher.catcher.unfiltered[k]
            return defer.succeed(None)
        else:
            self.subscriptions.update({subscription_id: {}})
        clbk = '<' + 'http://' + get_default_v4_address() + ':' +\
            str(self.event_catcher.getPort()) + '/' + childpath + '>'
#             print(clbk)
        headers = {'HOST': [get_default_v4_address() + ':' +
                            str(self.event_catcher.getPort())],
                   'CALLBACK': [clbk],
                   'NT': ['upnp:event'],
                   'TIMEOUT': ['Second-25']}
        if svc in dev['services']:
            self.log.error(svc)
            addr = dev['services'][svc]['eventSubURL']
            self.log.error(addr)
            d = self.agent.request(
                'SUBSCRIBE',
                addr,
                Headers(headers))
            d.addCallbacks(
                subscribed,
                subscribe_failed,
                callbackArgs=(addr, headers['HOST'][0], subscription_id),
                errbackArgs=(subscription_id,))
            return d
#         log.error(dev['services'])
        return defer.fail(Exception('Service unknow'))
예제 #20
0
파일: ohdevice.py 프로젝트: bverdu/onDemand
 def model(self, ignored):
     log.err('Model from Product')
     return (self.modelName, self.modelDescription, self.manufacturerURL,
             ''.join((self.getLocation(get_default_v4_address()),
                      '/pictures/', self.modelName, '.png',)))
예제 #21
0
        try:
            self.transport.write(msg, (address, port))
        except socket.error, e:
            log.err("socket.error: %s" % e)

    def respond_MSEARCH(self, st, (address, port)):
        log.msg("respond_MSEARCH to %s:%s, headers=%s" % (address, port, st))

        if self.ssdp.device.bootID is None:
            self.ssdp.device.bootID = int(time.time())

        if address == '127.0.0.1':
            location = self.ssdp.device.getLocation('127.0.0.1')
        else:
            location = self.ssdp.device.getLocation(get_default_v4_address())

        usn, st = build_notification_type(self.ssdp.device.uuid, st)

        headers = {
            'CACHE-CONTROL': 'max-age = %d' % self.responseExpire,
            'EXT': '',
            'LOCATION': location,
            'SERVER': self.ssdp.device.server,
            'ST': st,
            'USN': usn,
            'OPT': '"http://schemas.upnp.org/upnp/1/0/"; ns=01',
            '01-NLS': self.ssdp.device.bootID,
            'BOOTID.UPNP.ORG': self.ssdp.device.bootID,
            'CONFIGID.UPNP.ORG': self.ssdp.device.configID,
        }