Update API to agent v2

Signed-off-by: Jonathas-Conceicao <[email protected]>

Author: Jonathas-Conceicao

examples/api.py

@@ -24,6 +24,10 @@ def main():
     print(api.probe("http://www.example.com:8080"))
     print("")
     print(api.abort_download())
+    print("")
+    print(api.local_install("/tmp/update.uhu"))
+    print("")
+    print(api.remote_install("https://foo.bar/update.uhu"))
 
 
 if __name__ == '__main__':

examples/state_change_listener.py

@@ -4,11 +4,8 @@
 "enter download" state.
 """
 
-from __future__ import print_function
-
 import signal
 import sys
-import time
 
 import updatehub.listener
 
@@ -21,11 +18,11 @@ def signal_handler(*args):  # pylint: disable=unused-argument
     sys.exit(0)
 
 
-def callback(action, state, command):
+def download_callback(state, command):
     """
     Callback that will be called after the "enter download" is received.
     """
-    print("CALLBACK: " + action + " " + state)
+    print("CALLBACK: " + state)
     print("Canceling the command...")
     command.cancel()
     print("Done!")
@@ -41,6 +38,16 @@ def error_callback(error_message, command):
     print("Done!")
 
 
+def rebooting_callback(state, _command):
+    """
+    Callback that will be called after the "enter download" is received.
+    """
+    print("CALLBACK: " + state)
+    print("Stopping listener...")
+    SCL.stop()
+    sys.exit(0)
+
+
 def main():
     """
     Main method. Instantiates a StateChangeListener, adds callbacks to the
@@ -49,15 +56,13 @@ def main():
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGQUIT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
-    SCL.on_state_change(updatehub.listener.Action.ENTER,
-                        updatehub.listener.State.DOWNLOADING,
-                        callback)
+    SCL.on_state_change(updatehub.listener.State.DOWNLOADING,
+                        download_callback)
+    SCL.on_state_change(updatehub.listener.State.REBOOTING,
+                        rebooting_callback)
     SCL.on_error(error_callback)
 
     SCL.start()
 
-    while True:
-        time.sleep(1)
-
 if __name__ == '__main__':
     main()

updatehub/api.py

@@ -39,6 +39,14 @@ class Api:
     """
     Path to trigger a new probe for updates.
     """
+    LOCAL_INSTALL_PATH = "/local_install"
+    """
+    Path to trigger the installation of a local package.
+    """
+    REMOTE_INSTALL_PATH = "/remote_install"
+    """
+    Path to trigger the installation of a package from a direct URL.
+    """
     SERVER_URL = "http://localhost:8080"
     """
     URL to the agent API.
@@ -74,37 +82,46 @@ def get_log(self):
         """
         return self._request('GET', self.__class__.LOG_PATH)
 
-    def probe(self, host=None, ignore_probe_asap=False):
+    def probe(self, host=None):
         """
         Initiate a probe looking for a new update.
         """
-        data = {}
+        data = None
         if host is not None:
-            data["server-address"] = host
-        if ignore_probe_asap is not False:
-            data["ignore-probe-asap"] = ignore_probe_asap
+            data = {"custom_server": host}
         return self._request('POST', self.__class__.PROBE_PATH, data)
 
+    def local_install(self, path):
+        """
+        Requests the agent to install a local package.
+        """
+        data = {"file": path}
+        return self._request('POST', self.__class__.LOCAL_INSTALL_PATH, data)
+
+    def remote_install(self, url):
+        """
+        Requests the agent to install a local package.
+        """
+        data = {"url": url}
+        return self._request('POST', self.__class__.REMOTE_INSTALL_PATH, data)
+
     def _get_uri(self, path):
         uri = urlparse(self.__class__.SERVER_URL)
         uri = uri._replace(path=path)
         return uri.geturl()
 
     def _request(self, method, path, data=None):
         uri = self._get_uri(path)
-
-        if method == 'POST':
-            if data is None:
-                data = {}
-            request_body = json.dumps(data)
+        headers = {}
+        if data is not None:
+            data = json.dumps(data)
             try:
-                request_body = request_body.encode('utf-8')
-                request = Request(uri, data=request_body)
+                data = data.encode('utf-8')
             except TypeError:
-                request = Request(uri, data=request_body)
-        else:
-            request = Request(uri)
-        request.add_header("Content-Type", "application/json")
+                pass
+            headers = {"Content-Type": "application/json"}
+
+        request = Request(uri, data=data, method=method, headers=headers)
         try:
             response = urlopen(request)
         except HTTPError as exception:

updatehub/listener.py

@@ -3,30 +3,16 @@
 Use this package to be notified of changes on the current state of the
 updatehub agent by registering callbacks.
 """
-from __future__ import print_function
 
 import io
 import os
-import sys
 import socket
 import threading
 
 from enum import Enum
 from enum import unique
 
 
-@unique  # pylint: disable=too-few-public-methods
-class Action(Enum):
-    """
-    A enum class that contains both actions for each updatehub agent state.
-
-    :ENTER: action event triggered when the updatehub agent enters a state.
-    :LEAVE: action event triggered when the updatehub agent leaves a state.
-    """
-    ENTER = "enter"
-    LEAVE = "leave"
-
-
 @unique  # pylint: disable=too-few-public-methods
 class State(Enum):
     """
@@ -152,10 +138,10 @@ def _get_state(cls, line):
         if parts[0] == "error":
             raise StateError(" ".join(parts[1:]))
 
-        if len(parts) < 2:
+        if len(parts) < 1:
             raise MalformedState()
 
-        return parts[0], parts[1]
+        return parts[0]
 
     @classmethod
     def _readline(cls, conn):
@@ -177,16 +163,15 @@ def __init__(self):
         self.running = False
         self.thread = threading.Thread(target=self._loop)
 
-    def on_state_change(self, action, state, callback):
+    def on_state_change(self, state, callback):
         """
-        Adds a new callback method to a state change action.
+        Adds a new callback method to a state change.
 
-        :action: the monitored Action for this callback.
         :state: the monitored state for this callback.
         :callback: the method that will be called once a message containing the
-        action and the state is received by the listener.
+        state being entered is received by the listener.
         """
-        key = action.value + "_" + state.value
+        key = state.value
         if self.listeners.get(key) is None:
             self.listeners[key] = []
         self.listeners[key].append(callback)
@@ -207,8 +192,8 @@ def start(self):
         path (see the SDK_TRIGGER_FILENAME constante above).
         """
         if not os.path.isfile(StateChangeListener.SDK_TRIGGER_FILENAME):
-            print("updatehub-sdk-statechange-trigger not found!")
-            sys.exit()
+            print("WARNING: updatehub-sdk-statechange-trigger not found on",
+                  StateChangeListener.SDK_TRIGGER_FILENAME)
 
         self.running = True
         self.thread.start()
@@ -219,8 +204,11 @@ def stop(self):
         close the Unix socket and wait for the thread to finish execution.
         """
         self.running = False
+        socket_path = os.getenv("UH_LISTENER_TEST",
+                                default=StateChangeListener.SOCKET_PATH)
+
         client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        client.connect(StateChangeListener.SOCKET_PATH)
+        client.connect(socket_path)
         client.close()
         if threading.current_thread() != self.thread:
             self.thread.join()
@@ -245,27 +233,29 @@ def _wait_for_state(self):
                 if not self.running:
                     break
                 line = self._readline(conn)
-                action, state = self._get_state(line)
-                self._emit(action, state, conn)
+                state = self._get_state(line)
+                self._emit(state, conn)
             except StateError as exception:
                 self._throw_error(exception, conn)
             finally:
                 if conn is not None:
                     conn.close()
 
     def _connect(self):
-        if os.path.exists(StateChangeListener.SOCKET_PATH):
-            os.remove(StateChangeListener.SOCKET_PATH)
+        socket_path = os.getenv("UH_LISTENER_TEST",
+                                default=StateChangeListener.SOCKET_PATH)
+
+        if os.path.exists(socket_path):
+            os.remove(socket_path)
 
         self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        self.sock.bind(StateChangeListener.SOCKET_PATH)
+        self.sock.bind(socket_path)
         self.sock.listen(1)
 
-    def _emit(self, action, state, connection):
-        key = action + "_" + state
-        for callback in self.listeners.get(key) or []:
+    def _emit(self, state, connection):
+        for callback in self.listeners.get(state) or []:
             command = StateCommand(connection)
-            callback(action, state, command)
+            callback(state, command)
 
     def _throw_error(self, exception, connection):
         for callback in self.error_handlers: