Merge ~jocave/checkbox-support:snapd-api-rework into checkbox-support:master

[Jonathan Cave]

As part of de-duplication of snapd REST API code, this MR moves creates Snapd class that is easily importable in to other scripts. Other snapd code in this package are reworked on top of this.

Follow up MRs for providers demonstrate usage and were used to test the changes. Also tested that configure scripts in checkbox snaps still work as previously.

[Sylvain Pineau (sylvain-pineau)]

just a question, see below. I'll test it later

review: Needs Information

[Jonathan Cave (jocave)]

Good spot, removed the debug cruft

[Sylvain Pineau (sylvain-pineau)]

+1

review: Approve

diff --git a/checkbox_support/scripts/snap_configuration.py b/checkbox_support/scripts/snap_configuration.py
deleted file mode 100644
index 4167913..0000000
--- a/checkbox_support/scripts/snap_configuration.py
+++ /dev/null
@@ -1,55 +0,0 @@
-#!/usr/bin/env python3
-# Copyright 2017 Canonical Ltd.
-# All rights reserved.
-#
-# Written by:
-#    Authors: Jonathan Cave <[e-mail]>
-
-import argparse
-import sys
-
-from checkbox_support.snap_utils.config import (get_configuration,
-                                                set_configuration)
-
-
-def main():
-    desc = 'Query snapd for configuration details of an installed snap'
-    parser = argparse.ArgumentParser(description=desc)
-
-    subparsers = parser.add_subparsers(dest='action')
-    subparsers.required = True
-
-    parser_get = subparsers.add_parser('get', help='Get configuration item')
-    parser_get.add_argument('snap', type=str, help='snap name')
-    parser_get.add_argument('key', type=str, help='configuration item key')
-
-    parser_set = subparsers.add_parser('set', help='Set configuration item')
-    parser_set.add_argument('snap', type=str, help='snap name')
-    parser_set.add_argument('key', type=str, help='configuration item key')
-    parser_set.add_argument('value', type=str, help='new value')
-
-    parser_test = subparsers.add_parser(
-        'test', help='Test configuration item is set to the expected value')
-    parser_test.add_argument('snap', type=str, help='snap name')
-    parser_test.add_argument('key', type=str, help='configuration item key')
-    parser_test.add_argument('expected_value', type=str,
-                             help='the expected value')
-
-    args = parser.parse_args()
-    if args.action == 'get':
-        value = get_configuration(args.snap, args.key)
-        print(value)
-    if args.action == 'set':
-        result = set_configuration(args.snap, args.key, args.value)
-        print(result)
-    if args.action == 'test':
-        print('Expected value: {}'.format(args.expected_value))
-        value = get_configuration(args.snap, args.key)
-        print('Value found on the {} snap: {}'.format(args.snap, value))
-        if args.expected_value != value:
-            return 1
-    return 0
-
-
-if __name__ == '__main__':
-    sys.exit(main())
diff --git a/checkbox_support/scripts/snap_connect.py b/checkbox_support/scripts/snap_connect.py
index 7e8fac0..72dc379 100644
--- a/checkbox_support/scripts/snap_connect.py
+++ b/checkbox_support/scripts/snap_connect.py
@@ -29,22 +29,29 @@ is equivalent to:
 """
 
 import argparse
-import json
 import logging
-import requests_unixsocket
 import os
-import sys
-import time
 from collections import namedtuple
 
+from checkbox_support.snap_utils.snapd import Snapd
+import requests
 
 Connection = namedtuple(
     'Connection',
     ['target_snap', 'target_slot', 'plug_snap', 'plug_plug'])
 
 
-class BadRequest(Exception):
-    pass
+def get_connections():
+    data = Snapd().interfaces()
+    connections = []
+    if 'plugs' in data:
+        for plug in data['plugs']:
+            if 'connections' in plug:
+                for con in plug['connections']:
+                    connections.append(Connection(
+                        con['snap'], con['slot'],
+                        plug['snap'], plug['plug']))
+    return connections
 
 
 def main():
@@ -53,77 +60,23 @@ def main():
         'connections', nargs='+', default=[],
         metavar='plug:target_snap:target_slot')
     args = parser.parse_args()
-    api = SnapdAPI()
 
     for conn in [spec.split(':') for spec in args.connections]:
         if len(conn) != 3:
             raise SystemExit("Bad connection description")
         assert os.environ['SNAP_NAME']
         snap = os.environ['SNAP_NAME']
-        existing_connections = api.get_connections()
+        existing_connections = get_connections()
         new_connection = Connection(
             target_snap=conn[1], target_slot=conn[2],
             plug_snap=snap, plug_plug=conn[0])
         if new_connection not in existing_connections:
             try:
-                api.connect(new_connection)
-            except BadRequest as exc:
+                Snapd().connect(*new_connection)
+            except requests.HTTPError as exc:
                 logging.warning("Failed to connect %s to %s. %s" % (
                     conn[0], conn[1], exc))
 
 
-class SnapdAPI():
-    """Based on https://github.com/snapcore/snapd/wiki/REST-API"""
-    SNAPD_BASE_URL = 'http+unix://%2Frun%2Fsnapd.socket'
-
-    def __init__(self):
-        self.session = requests_unixsocket.Session()
-
-    def get_connections(self):
-        data = self._get('/v2/interfaces')
-        connections = []
-        if 'plugs' in data:
-            for plug in data['plugs']:
-                if 'connections' in plug:
-                    for con in plug['connections']:
-                        connections.append(Connection(
-                            con['snap'], con['slot'],
-                            plug['snap'], plug['plug']))
-        return connections
-
-    def connect(self, con):
-        json_data = json.dumps({
-            'action': 'connect',
-            'slots': [{'snap': con.target_snap, 'slot': con.target_slot}],
-            'plugs': [{'snap': con.plug_snap, 'plug': con.plug_plug}]
-        })
-        res = self._post('/v2/interfaces', json_data)
-        ready = False
-        while not ready:
-            # busy wait until snapd reports connection job as finised
-            time.sleep(0.5)
-            con_res = self._get('/v2/changes/{}'.format(res['change']))
-            ready = con_res['ready']
-
-    def _get(self, path):
-        res = self.session.get(self.SNAPD_BASE_URL + path)
-        if not res.ok:
-            logging.error("Got error %i attempting to access %s",
-                          res.status_code, path)
-            sys.exit(1)
-        return res.json()['result']
-
-    def _post(self, path, data=None):
-        res = self.session.post(self.SNAPD_BASE_URL + path, data=data)
-        if not res.ok:
-            full_res = json.loads(res.text)
-            if res.status_code == 400:
-                raise BadRequest(full_res['result']['message'])
-            logging.error("Got error %i attempting to access %s",
-                          res.status_code, path)
-            sys.exit(1)
-        return res.json()
-
-
 if __name__ == '__main__':
     main()
diff --git a/checkbox_support/snap_utils/config.py b/checkbox_support/snap_utils/config.py
index c33bafc..98083be 100644
--- a/checkbox_support/snap_utils/config.py
+++ b/checkbox_support/snap_utils/config.py
@@ -12,52 +12,6 @@ import re
 import subprocess
 import sys
 
-import requests
-import requests_unixsocket
-
-SNAPD_BASE_URL = 'http+unix://%2Frun%2Fsnapd.socket'
-
-
-class SnapdQuery():
-
-    def __init__(self):
-        self._session = requests_unixsocket.Session()
-
-    def get(self, path, params=None):
-        r = self._session.get(SNAPD_BASE_URL + path, params=params)
-        if r.status_code != requests.codes.ok:
-            raise SystemExit('Got error {} attempting to access {}\n'.format(
-                r.status_code, path))
-        return r
-
-    def post(self, path, data=None):
-        res = self._session.post(SNAPD_BASE_URL + path, data=data)
-        if not res.ok:
-            raise SystemExit('Got error {} attempting to post to {}\n'.format(
-                res.status_code, path))
-        return res.json()
-
-    def put(self, path, data=None):
-        res = self._session.put(SNAPD_BASE_URL + path, data=data)
-        if not res.ok:
-            raise SystemExit('Got error {} attempting to put to {}\n'.format(
-                res.status_code, path))
-        return res.json()
-
-
-def get_configuration(snap, key):
-    path = '/v2/snaps/{}/conf'.format(snap)
-    params = 'keys={}'.format(key)
-    query = SnapdQuery()
-    return query.get(path, params).json()['result'][key]
-
-
-def set_configuration(snap, key, value):
-    path = '/v2/snaps/{}/conf'.format(snap)
-    json_data = json.dumps({key: value})
-    query = SnapdQuery()
-    return query.put(path, json_data)['status']
-
 
 def get_snapctl_config(keys):
     """Query snapctl for given keys."""
@@ -95,8 +49,8 @@ def get_configuration_set():
             k = k.replace('_', '-').lower()
             config_set[k] = v
     except FileNotFoundError:
-            # silently ignore missing config_vars
-            pass
+        # silently ignore missing config_vars
+        pass
     return config_set
 
 
diff --git a/checkbox_support/snap_utils/snapd.py b/checkbox_support/snap_utils/snapd.py
new file mode 100644
index 0000000..6987a29
--- /dev/null
+++ b/checkbox_support/snap_utils/snapd.py
@@ -0,0 +1,146 @@
+# Copyright 2019 Canonical Ltd.
+# All rights reserved.
+#
+# Written by:
+#    Jonathan Cave <[e-mail]>
+
+import json
+import time
+
+import requests_unixsocket
+
+
+class AsyncException(Exception):
+
+    def __init__(self, message):
+        self.message = message
+
+
+class Snapd():
+
+    _url = 'http+unix://%2Frun%2Fsnapd.socket'
+
+    _snaps = '/v2/snaps'
+    _find = '/v2/find'
+    _changes = '/v2/changes'
+    _system_info = '/v2/system-info'
+    _interfaces = '/v2/interfaces'
+    _assertions = '/v2/assertions'
+
+    def __init__(self):
+        self._session = requests_unixsocket.Session()
+
+    def _get(self, path, params=None, decode=True):
+        r = self._session.get(self._url + path, params=params)
+        r.raise_for_status()
+        if decode:
+            return r.json()
+        return r
+
+    def _post(self, path, data=None, decode=True):
+        r = self._session.post(self._url + path, data=data)
+        r.raise_for_status()
+        if decode:
+            return r.json()
+        return r
+
+    def _put(self, path, data=None, decode=True):
+        r = self._session.put(self._url + path, data=data)
+        r.raise_for_status()
+        if decode:
+            return r.json()
+        return r
+
+    def _poll_change(self, change_id, timeout=30):
+        for _ in range(30):
+            status = self.change(change_id)
+            if status == 'Done':
+                return True
+            time.sleep(1)
+        raise AsyncException(status)
+
+    def list(self, snap=None):
+        path = self._snaps
+        if snap is not None:
+            path += '/' + snap
+        return self._get(path)['result']
+
+    def install(self, snap, channel='stable', revision=None):
+        path = self._snaps + '/' + snap
+        data = {'action': 'install', 'channel': channel}
+        if revision is not None:
+            data['revision'] = revision
+        r = self._post(path, json.dumps(data))
+        if r['type'] == 'async' and r['status'] == 'Accepted':
+            self._poll_change(r['change'])
+
+    def remove(self, snap, revision=None):
+        path = self._snaps + '/' + snap
+        data = {'action': 'remove'}
+        if revision is not None:
+            data['revision'] = revision
+        r = self._post(path, json.dumps(data))
+        if r['type'] == 'async' and r['status'] == 'Accepted':
+            self._poll_change(r['change'])
+
+    def find(self, search, exact=False):
+        if exact:
+            p = 'name={}'.format(search)
+        else:
+            p = 'q={}'.format(search)
+        return self._get(self._find, params=p)['result']
+
+    def info(self, snap):
+        return self.find(snap, exact=True)[0]
+
+    def refresh(self, snap, channel='stable', revision=None):
+        path = self._snaps + '/' + snap
+        data = {'action': 'refresh', 'channel': channel}
+        if revision is not None:
+            data['revision'] = revision
+        r = self._post(path, json.dumps(data))
+        if r['type'] == 'async' and r['status'] == 'Accepted':
+            self._poll_change(r['change'])
+
+    def change(self, change_id):
+        path = self._changes + '/' + change_id
+        r = self._get(path)
+        return r['result']['status']
+
+    def revert(self, snap, channel='stable', revision=None):
+        path = self._snaps + '/' + snap
+        data = {'action': 'revert', 'channel': channel}
+        if revision is not None:
+            data['revision'] = revision
+        r = self._post(path, json.dumps(data))
+        if r['type'] == 'async' and r['status'] == 'Accepted':
+            self._poll_change(r['change'])
+
+    def get_configuration(self, snap, key):
+        path = self._snaps + '/' + snap + '/conf'
+        p = 'keys={}'.format(key)
+        return self._get(path, params=p)['result'][key]
+
+    def set_configuration(self, snap, key, value):
+        path = self._snaps + '/' + snap + '/conf'
+        data = {key: value}
+        r = self._post(path, json.dumps(data))
+        if r['type'] == 'async' and r['status'] == 'Accepted':
+            self._poll_change(r['change'])
+
+    def interfaces(self):
+        return self._get(self._interfaces)['result']
+
+    def connect(self, slot_snap, slot_slot, plug_snap, plug_plug):
+        data = {
+            'action': 'connect',
+            'slots': [{'snap': slot_snap, 'slot': slot_slot}],
+            'plugs': [{'snap': plug_snap, 'plug': plug_plug}]
+        }
+        r = self._post(self._interfaces, json.dumps(data))
+        if r['type'] == 'async' and r['status'] == 'Accepted':
+            self._poll_change(r['change'])
+
+    def get_assertions(self, assertion_type):
+        path = self._assertions + '/' + assertion_type
+        return self._get(path, decode=False)
diff --git a/setup.py b/setup.py
index dd2ed8c..3c3ac85 100755
--- a/setup.py
+++ b/setup.py
@@ -82,8 +82,6 @@ setup(
                 "checkbox_support.scripts.fwts_test:main"),
             ("checkbox-support-usb_read_write="
                 "checkbox_support.scripts.usb_read_write:run_read_write_test"),
-            ("checkbox-support-snap_configuration="
-                "checkbox_support.scripts.snap_configuration:main"),
             ("checkbox-support-nmea_test="
                 "checkbox_support.scripts.nmea_test:main"),
             ("checkbox-support-snap_connect="