def _start_ssdp(): ssdp = SSDPServer() thread_ssdp = threading.Thread(target=ssdp.run, args=()) thread_ssdp.daemon = True # Daemonize thread thread_ssdp.start() ssdp.register( 'local', 'uuid:{}::upnp:rootdevice'.format(discoverData['DeviceID']), 'upnp:rootdevice', 'http://{}:{}/device.xml'.format(config['tvhProxyHost'], config['tvhProxyPort']), 'SSDP Server for tvhProxy')
def startssdp(dvbtype): discover = getdeviceinfo.discoverdata(dvbtype) device_uuid = discover['DeviceUUID'] if config.hrtunerproxy.debug.value: logger.info('Starting SSDP for %s, device_uuid: %s' % (dvbtype,device_uuid)) local_ip_address = getIP() ssdp = SSDPServer() ssdp.register('local', 'uuid:{}::upnp:rootdevice'.format(device_uuid), 'upnp:rootdevice', 'http://{}:{}/device.xml'.format(local_ip_address,tunerports[dvbtype])) thread_ssdp = threading.Thread(target=ssdp.run, args=()) thread_ssdp.daemon = True # Daemonize thread thread_ssdp.start()
def startssdp(dvbtype): discover = getdeviceinfo.deviceinfo(dvbtype) device_uuid = discover[dvbtype]['DeviceUUID'] print '[Plex DVR API] Starting SSDP for %s, device_uuid: %s' % ( dvbtype, device_uuid) local_ip_address = getIP() ssdp = SSDPServer() ssdp.register( 'local', 'uuid:{}::upnp:rootdevice'.format(device_uuid), 'upnp:rootdevice', 'http://{}:{}/device.xml'.format(local_ip_address, tunerports[dvbtype])) thread_ssdp = threading.Thread(target=ssdp.run, args=()) thread_ssdp.daemon = True # Daemonize thread thread_ssdp.start()
def __getattr__(self, attr): if attr is 'ssdp': from ssdp import SSDPServer self.ssdp = SSDPServer(self) return self.ssdp elif attr is 'http': from http import HTTPServer self.http = HTTPServer(self) return self.http elif attr is 'https': from http import HTTPServer self.https = HTTPServer(self, True) return self.https else: raise AttributeError("'%s' has no attribute %r" % (self.__class__.__name__, attr))
def main(): device_uuid = uuid.uuid4() local_ip_address = get_ip_address() web_server_port = 8088 http_server = UPNPHTTPServer(web_server_port, friendly_name="Xeleum Xi-Fi Gateway", manufacturer="Xeleum Lighting", manufacturer_url='http://www.xeleum.com/', model_description='Xi-Fi Gateway', model_name="Xi-F Gateway", model_number="XRF001", model_url="http://www.xeleum.com", serial_number="XRF1234", uuid=device_uuid, presentation_url="index.html") http_server.start() ssdp_server = SSDPServer() ssdp_server.register( 'local', 'uuid:{}::upnp:rootdevice'.format(device_uuid), 'upnp:rootdevice', 'http://{}:{}/description.xml'.format(local_ip_address, web_server_port)) ssdp_server.start() XrfAPI.getInstance().start() app.run(debug=True, host='0.0.0.0', port=port, use_reloader=False)
def __init__(self, connection_type, mqtt_port): self.network_interface = connection_type self.device_uuid = uuid.uuid4() self.local_ip_address = self.__get_network_interface_ip_address( self.network_interface) self.http_server = UPNPHTTPServer( 8088, friendly_name="Camera Test", manufacturer="L-IoT-ning", manufacturer_url='http://liotningshop.azurewebsites.net/', model_description='Pi Camera Test', model_name="PiCamera", model_number="3000", model_url="", serial_number="JBN425133", uuid=self.device_uuid, presentation_url=("tcp://{}:" + mqtt_port).format( self.local_ip_address)) self.ssdp = SSDPServer() self.ssdp.register( 'local', 'uuid:{}::upnp:rootdevice'.format(self.device_uuid), 'upnp:rootdevice', 'http://{}:8088/jambon-3000.xml'.format(self.local_ip_address))
class SSDPGenerator: def __init__(self, connection_type, mqtt_port): self.network_interface = connection_type self.device_uuid = uuid.uuid4() self.local_ip_address = self.__get_network_interface_ip_address( self.network_interface) self.http_server = UPNPHTTPServer( 8088, friendly_name="Camera Test", manufacturer="L-IoT-ning", manufacturer_url='http://liotningshop.azurewebsites.net/', model_description='Pi Camera Test', model_name="PiCamera", model_number="3000", model_url="", serial_number="JBN425133", uuid=self.device_uuid, presentation_url=("tcp://{}:" + mqtt_port).format( self.local_ip_address)) self.ssdp = SSDPServer() self.ssdp.register( 'local', 'uuid:{}::upnp:rootdevice'.format(self.device_uuid), 'upnp:rootdevice', 'http://{}:8088/jambon-3000.xml'.format(self.local_ip_address)) def __get_network_interface_ip_address(self, interface='eth0'): """ Get the first IP address of a network interface. :param interface: The name of the interface. :return: The IP address. """ while True: if interface not in ni.interfaces(): print('Could not find interface %s.' % (interface, )) exit(1) interface = ni.ifaddresses(interface) if (2 not in interface) or (len(interface[2]) == 0): print('Could not find IP of interface %s. Sleeping.' % (interface, )) sleep(60) continue return interface[2][0]['addr'] def server_start(self): thread.start_new_thread(self.http_server.start, ()) thread.start_new_thread(self.ssdp.run, ()) def server_close(self): self.http_server.shutdown() self.ssdp.shutdown() self.ssdp.unregister('uuid:{}::upnp:rootdevice'.format( self.device_uuid))
def __getattr__(self, attr): if attr is "ssdp": from ssdp import SSDPServer self.ssdp = SSDPServer(self) return self.ssdp elif attr is "http": from http import HTTPServer self.http = HTTPServer(self) return self.http elif attr is "https": from http import HTTPServer self.https = HTTPServer(self, True) return self.https else: raise AttributeError("'%s' has no attribute %r" % (self.__class__.__name__, attr))
from ssdp import SSDPServer from upnp_http_server import UPNPHTTPServer import uuid import logging logger = logging.getLogger() logger.setLevel(logging.DEBUG) device_uuid = uuid.uuid4() http_server = UPNPHTTPServer( 8088, friendly_name="Bigfoot device", manufacturer="Yeti SL", manufacturer_url='https://getyeti.co/', model_description='Yeti Python appliance V1', model_name="Python", model_number="1", model_url="https://github.com/netbeast/bigfoot/python", serial_number="v1", uuid=device_uuid, presentation_url="http://localhost:5000/") http_server.start() ssdp = SSDPServer() ssdp.register('local', 'uuid:{}::upnp:rootdevice'.format(device_uuid), 'bigfoot:all', 'http://localhost:8088/python-v1.xml') ssdp.run()
class Upnpy(object): """A upnpy controller working either as a control-point or as devices root list Can be used to search remote device (get, search) Can be used to declare new devices devices['example']=Device(...) """ def __init__(self, server_address=""): """Initialize Upnpy server_address (tring) : an optionnal address to bind connection to""" self.server_address = server_address import weakref self._subscriptions = weakref.WeakValueDictionary() self.devices = _RootList(self) self._stop = False import atexit atexit.register(self.clean) def __getattr__(self, attr): if attr is "ssdp": from ssdp import SSDPServer self.ssdp = SSDPServer(self) return self.ssdp elif attr is "http": from http import HTTPServer self.http = HTTPServer(self) return self.http elif attr is "https": from http import HTTPServer self.https = HTTPServer(self, True) return self.https else: raise AttributeError("'%s' has no attribute %r" % (self.__class__.__name__, attr)) def search(self, target, timeout=2.0): """search for devices/services Returns a list of device/service when at least one matching is found Args: target (string) : a UPnP defined search target : - ssdp:all (or *) : for all devices and services - upnp:rootdevice : for all root devices - uuid:[uuid] : for a particular device - [urn:domain:]{device,service}:type[:version] : for a device or service with the given type domain default to schemas-upnp-org, version to 1 timeout (number, optionnal) : timeout for search (default to 5 seconds)""" from control import SearchHandler h = SearchHandler(self, target, timeout) self.add_handler(h) if not len(h.matches) and timeout: gevent.sleep(timeout) return h.matches def get(self, target, timeout=2.0): """search a device/service Returns when at least one matching devices is found target (string) : a UPnP defined search target or "*" for ssdp:all timeout (number) : an optionnal timeout (default to 5 seconds)""" matches = self.search(target, timeout / 2) if len(matches): return matches[0] else: raise KeyError("UPnP '%s' not found" % target) def serve_forever(self): gevent.wait() def add_handler(self, handler): self.ssdp.add_handler(handler) def stop(self): self.clean() self._stop = True def clean(self): for i in self.devices.keys(): del self.devices[i] for s in self._subscriptions.values(): s.unsubscribe() self.ssdp.clean()
model_number="HPA250B", model_url="https://www.honeywellpluggedin.com/air-purifiers/shop/honeywell-air-purifier-bluetooth-smart-controls", serial_number="N/A", uuid=device_uuid, presentation_url="http://{}:5000/".format(local_ip_address)) http_server.start() print "Server started" ssdp = SSDPServer() print "SSDP started" ssdp.register('local', 'uuid:{}::urn:schemas-upnp-org:device:hpa250b:1'.format(device_uuid), 'urn:schemas-upnp-org:device:hpa250b:1', 'http://{}:8090/hpa250b.xml'.format(local_ip_address)) print "SSDP registered" ssdp.run()
class Upnpy(object): """A upnpy controller working either as a control-point or as devices root list Can be used to search remote device (get, search) Can be used to declare new devices devices['example']=Device(...) """ def __init__(self, server_address=''): """Initialize Upnpy server_address (tring) : an optionnal address to bind connection to""" self.server_address = server_address import weakref self._subscriptions = weakref.WeakValueDictionary() self.devices = _RootList(self) self._stop = False import atexit atexit.register(self.clean) def __getattr__(self, attr): if attr is 'ssdp': from ssdp import SSDPServer self.ssdp = SSDPServer(self) return self.ssdp elif attr is 'http': from http import HTTPServer self.http = HTTPServer(self) return self.http elif attr is 'https': from http import HTTPServer self.https = HTTPServer(self, True) return self.https else: raise AttributeError("'%s' has no attribute %r" % (self.__class__.__name__, attr)) def search(self, target, timeout=2.0): """search for devices/services Returns a list of device/service when at least one matching is found Args: target (string) : a UPnP defined search target : - ssdp:all (or *) : for all devices and services - upnp:rootdevice : for all root devices - uuid:[uuid] : for a particular device - [urn:domain:]{device,service}:type[:version] : for a device or service with the given type domain default to schemas-upnp-org, version to 1 timeout (number, optionnal) : timeout for search (default to 5 seconds)""" from control import SearchHandler h = SearchHandler(self, target, timeout) self.add_handler(h) if not len(h.matches) and timeout: gevent.sleep(timeout) return h.matches def get(self, target, timeout=2.0): """search a device/service Returns when at least one matching devices is found target (string) : a UPnP defined search target or "*" for ssdp:all timeout (number) : an optionnal timeout (default to 5 seconds)""" matches = self.search(target, timeout / 2) if len(matches): return matches[0] else: raise KeyError("UPnP '%s' not found" % target) def serve_forever(self): gevent.wait() def add_handler(self, handler): self.ssdp.add_handler(handler) def stop(self): self.clean() self._stop = True def clean(self): for i in self.devices.keys(): del self.devices[i] for s in self._subscriptions.values(): s.unsubscribe() self.ssdp.clean()
http_server = UPNPHTTPServer( 8090, friendly_name="Air Mentor Pro 2", manufacturer="Air Mentor", manufacturer_url='https://www.air-mentor.com/web2017/?lang=en', model_description='Air Mentor Pro 2', model_name="Air Mentor", model_number="Air Mentor Pro 2", model_url="https://www.air-mentor.com/web2017/product/air_mentor_8096ap", serial_number="N/A", uuid=device_uuid, presentation_url="http://{}:5000/".format(local_ip_address)) http_server.start() print "Server started" ssdp = SSDPServer() print "SSDP started" ssdp.register( 'local', 'uuid:{}::urn:schemas-upnp-org:device:AirMentorPro2:1'.format(device_uuid), 'urn:schemas-upnp-org:device:AirMentorPro2:1', 'http://{}:8090/airmentorpro2.xml'.format(local_ip_address)) print "SSDP registered" ssdp.run()