Initial commit of bindings.

Author: Mike Stegeman

.gitignore

@@ -0,0 +1,8 @@
+*.egg
+*.egg-info/
+*.py[cod]
+*.swp
+*~
+__pycache__/
+build/
+dist/

LICENSE LICENSE.txtLICENSE renamed to LICENSE.txt

@@ -0,0 +1 @@
+include LICENSE.txt

MANIFEST.in

@@ -0,0 +1,4 @@
+gateway_addon
+=============
+
+Python bindings for developing Python add-ons for Mozilla IoT Gateway.

README.md

@@ -0,0 +1,7 @@
+"""This module provides a high-level interface for creating Gateway add-ons."""
+# flake8: noqa
+from .adapter import Adapter
+from .addon_manager_proxy import AddonManagerProxy
+from .device import Device
+from .ipc import IpcClient
+from .property import Property

README.rst

@@ -0,0 +1,159 @@
+"""High-level Adapter base class implementation."""
+
+from .addon_manager_proxy import AddonManagerProxy
+from .ipc import IpcClient
+
+
+class Adapter:
+    """An Adapter represents a way of communicating with a set of devices."""
+
+    def __init__(self, _id, package_name, verbose=False):
+        """
+        Initialize the object.
+
+        As part of initialization, a connection is established between the
+        adapter and the Gateway via nanomsg IPC.
+
+        _id -- the adapter's individual ID
+        package_name -- the adapter's package name
+        verbose -- whether or not to enable verbose logging
+        """
+        self.id = _id
+        self.package_name = package_name
+        self.devices = {}
+        self.actions = {}
+
+        # We assume that the adapter is ready right away. If, for some reason,
+        # a particular adapter needs some time, then it should set ready to
+        # False in it's constructor.
+        self.ready = True
+
+        self.ipc_client = IpcClient(self.id, verbose=verbose)
+        self.manager_proxy = AddonManagerProxy(self.ipc_client.plugin_socket,
+                                               self.id,
+                                               verbose=verbose)
+        self.manager_proxy.add_adapter(self)
+
+    def dump(self):
+        """Dump the state of the adapter to the log."""
+        print('Adapter:', self.name, '- dump() not implemented')
+
+    def get_id(self):
+        """
+        Get the ID of the adapter.
+
+        Returns the ID as a string.
+        """
+        return self.id
+
+    def get_package_name(self):
+        """
+        Get the package name of the adapter.
+
+        Returns the package name as a string.
+        """
+        return self.package_name
+
+    def get_device(self, device_id):
+        """
+        Get the device with the given ID.
+
+        device_id -- ID of device to retrieve
+
+        Returns a Device object, if found, else None.
+        """
+        return self.devices.get(device_id, None)
+
+    def get_devices(self):
+        """
+        Get all the devices managed by this adapter.
+
+        Returns a dictionary of device_id -> Device.
+        """
+        return self.devices
+
+    def get_name(self):
+        """
+        Get the name of this adapter.
+
+        Returns the name as a string.
+        """
+        return self.name
+
+    def is_ready(self):
+        """
+        Get the ready state of this adapter.
+
+        Returns the ready state as a boolean.
+        """
+        return self.ready
+
+    def as_dict(self):
+        """
+        Get the adapter state as a dictionary.
+
+        Returns the state as a dictionary.
+        """
+        return {
+            'id': self.id,
+            'name': self.name,
+            'ready': self.ready,
+        }
+
+    def handle_device_added(self, device):
+        """
+        Notify the Gateway that a new device is being managed by this adapter.
+
+        device -- Device object
+        """
+        self.devices[device.id] = device
+        self.manager_proxy.handle_device_added(device)
+
+    def handle_device_removed(self, device):
+        """
+        Notify the Gateway that a device has been removed.
+
+        device -- Device object
+        """
+        if device.id in self.devices:
+            del self.devices[device.id]
+
+        self.manager_proxy.handle_device_removed(device)
+
+    def start_pairing(self, timeout):
+        """
+        Start the pairing process.
+
+        timeout -- Timeout in seconds at which to quit pairing
+        """
+        print('Adapter:', self.name, 'id', self.id, 'pairing started')
+
+    def cancel_pairing(self):
+        """Cancel the pairing process."""
+        print('Adapter:', self.name, 'id', self.id, 'pairing cancelled')
+
+    def remove_thing(self, device_id):
+        """
+        Unpair a device with the adapter.
+
+        device_id -- ID of device to unpair
+        """
+        device = self.get_device(device_id)
+        if device:
+            print('Adapter:', self.name, 'id', self.id,
+                  'remove_thing(' + device.id + ')')
+
+    def cancel_remove_thing(self, device_id):
+        """
+        Cancel unpairing of a device.
+
+        device_id -- ID of device to cancel unpairing with
+        """
+        device = self.get_device(device_id)
+        if device:
+            print('Adapter:', self.name, 'id', self.id,
+                  'cancel_remove_thing(' + device.id + ')')
+
+    def unload(self):
+        """Perform any necessary cleanup before adapter is shut down."""
+        print('Adapter:', self.name, 'unloaded')

gateway_addon/__init__.py

@@ -0,0 +1,169 @@
+"""Proxy for sending messages between the Gateway and an add-on."""
+
+import json
+import threading
+
+
+class AddonManagerProxy:
+    """
+    Proxy for communicating with the Gateway's AddonManager.
+
+    This proxy interprets all of the required incoming message types that need
+    to be handled by add-ons and sends back responses as appropriate.
+    """
+
+    def __init__(self, socket, plugin_id, verbose=False):
+        """
+        Initialize the object.
+
+        socket -- the IPC socket
+        plugin_id -- ID of this plugin
+        verbose -- whether or not to enable verbose logging
+        """
+        self.adapter = None
+        self.socket = socket
+        self.plugin_id = plugin_id
+        self.verbose = verbose
+        self.running = True
+        self.thread = threading.Thread(target=self.recv)
+        self.thread.start()
+
+    def add_adapter(self, adapter):
+        """
+        Send a notification that an adapter has been added.
+
+        adapter -- the Adapter that was added
+        """
+        if self.verbose:
+            print('AddonManagerProxy: add_adapter:', adapter.id)
+
+        self.adapter = adapter
+        self.send('addAdapter', {
+            'adapterId': adapter.id,
+            'name': adapter.name
+        })
+
+    def handle_device_added(self, device):
+        """
+        Send a notification that a new device has been added.
+
+        device -- the Device that was added
+        """
+        if self.verbose:
+            print('AddonManagerProxy: handle_device_added:', device.id)
+
+        device_dict = device.as_dict()
+        device_dict['adapterId'] = device.adapter.id
+        self.send('handleDeviceAdded', device_dict)
+
+    def handle_device_removed(self, device):
+        """
+        Send a notification that a managed device was removed.
+
+        device -- the Device that was removed
+        """
+        if self.verbose:
+            print('AddonManagerProxy: handle_device_removed:', device.id)
+
+        self.send('handleDeviceRemoved', {
+            'adapterId': device.adapter.id,
+            'id': device.id,
+        })
+
+    def send_property_changed_notification(self, prop):
+        """
+        Send a notification that a device property changed.
+
+        prop -- the Property that changed
+        """
+        self.send('propertyChanged', {
+            'adapterId': prop.device.adapter.id,
+            'deviceId': prop.device.id,
+            'property': prop.as_dict(),
+        })
+
+    def send(self, msg_type, data):
+        """
+        Send a message through the IPC socket.
+
+        msg_type -- the message type
+        data -- the data to send, as a dictionary
+        """
+        if data is None:
+            data = {}
+
+        data['pluginId'] = self.plugin_id
+
+        self.socket.send(json.dumps({
+            'messageType': msg_type,
+            'data': data,
+        }))
+
+    def recv(self):
+        """Read a message from the IPC socket."""
+        while self.running:
+            msg = self.socket.recv()
+
+            if self.verbose:
+                print('AddonMangerProxy: recv:', msg)
+
+            if not msg:
+                break
+
+            if not self.adapter:
+                print('AddonManagerProxy: No adapter added yet, ignoring '
+                      'message.')
+                continue
+
+            try:
+                msg = json.loads(msg)
+            except ValueError:
+                print('AddonManagerProxy: Error parsing message as JSON')
+                continue
+
+            if 'messageType' not in msg:
+                print('AddonManagerProxy: Invalid message')
+                continue
+
+            msg_type = msg['messageType']
+
+            # High-level adapter messages
+            if msg_type == 'startPairing':
+                self.adapter.start_pairing(msg['data']['timeout'])
+                continue
+
+            if msg_type == 'cancelPairing':
+                self.adapter.cancel_pairing()
+                continue
+
+            if msg_type == 'unloadAdapter':
+                self.adapter.unload()
+                self.send('adapterUnloaded', {'adapterId', self.adapter.id})
+                continue
+
+            if msg_type == 'unloadPlugin':
+                self.send('pluginUnloaded', {})
+                continue
+
+            # All messages from here on are assumed to require a valid deviceId
+            if 'data' not in msg or 'deviceId' not in msg['data']:
+                print('AddonManagerProxy: No deviceId present in message, '
+                      'ignoring.')
+                continue
+
+            device_id = msg['data']['device_id']
+            if msg_type == 'removeThing':
+                self.adapter.remove_thing(device_id)
+                continue
+
+            if msg_type == 'cancelRemoveThing':
+                self.adapter.cancel_remove_thing(device_id)
+                continue
+
+            if msg_type == 'setProperty':
+                dev = self.adapter.get_device(device_id)
+                if dev:
+                    prop = dev.get_property(msg['data']['propertyName'])
+                    if prop:
+                        prop.set_value(msg['data']['propertyValue'])
+                        continue