Merge ~cjwatson/snapstore-client:rename-to-snapstore-client into snapstore-client:master

[Colin Watson]

Rename to snapstore-client

siab-client is a pretty opaque name if you aren't familiar with all our
acronyms. snapstore-client is much clearer.

[Ricardo Kirkner (ricardokirkner)]

LGTM

review: Approve

diff --git a/Makefile b/Makefile
index ce817d7..173d2db 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-SERVICE_PACKAGE = siab_client
+SERVICE_PACKAGE = snapstore_client
 ENV = $(CURDIR)/env
 PYTHON3 = $(ENV)/bin/python3
 PIP = $(PYTHON3) -m pip
diff --git a/serve-snaps.py b/serve-snaps.py
index 7ab8f5d..09aeed6 100755
--- a/serve-snaps.py
+++ b/serve-snaps.py
@@ -14,9 +14,9 @@ from urllib.parse import (
 )
 from urllib.request import urlopen
 
-from siab_client import get_storage_root
-from siab_client.cli import configure_logging
-from siab_client.config import read_config
+from snapstore_client import get_storage_root
+from snapstore_client.cli import configure_logging
+from snapstore_client.config import read_config
 
 
 logger = logging.getLogger(__name__)
diff --git a/siab_client/__init__.py b/siab_client/__init__.py
deleted file mode 100644
index e69df82..0000000
--- a/siab_client/__init__.py
+++ /dev/null
@@ -1,18 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2017 Canonical Ltd.
-
-import os
-
-
-SUPPORTED_ARCHITECTURES = (
-    'amd64', 'arm64', 'armhf', 'i386', 'powerpc', 'ppc64el', 's390x')
-
-
-def get_storage_root():
-    return os.path.abspath(
-        os.path.join(
-            os.path.dirname(__file__),
-            '..',
-            'snap_storage'
-        )
-    )
diff --git a/siab_client/cli.py b/siab_client/cli.py
deleted file mode 100644
index 0ee6e66..0000000
--- a/siab_client/cli.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# Copyright 2017 Canonical Ltd.
-
-"""Command-line interface niceties for this service."""
-
-import logging
-import os
-import sys
-
-
-class _StdoutFilter(logging.Filter):
-
-    def filter(self, record):
-        return record.levelno <= logging.WARNING
-
-
-class _StderrFilter(logging.Filter):
-
-    def filter(self, record):
-        return record.levelno >= logging.ERROR
-
-
-def _is_dumb_terminal():
-    """Return True if on a dumb terminal."""
-    is_stdout_tty = os.isatty(sys.stdout.fileno())
-    is_term_dumb = os.environ.get('TERM', '') == 'dumb'
-    return not is_stdout_tty or is_term_dumb
-
-
-class _ColouredFormatter(logging.Formatter):
-
-    _reset = '\033[0m'
-    _level_colours = {
-        'ERROR': '\033[0;31m',  # Dark red
-    }
-
-    def format(self, record):
-        colour = self._level_colours.get(record.levelname)
-        log_message = super().format(record)
-        if colour is not None:
-            return colour + log_message + self._reset
-        else:
-            return log_message
-
-
-def configure_logging(logger_name=None, log_level=logging.INFO):
-    stdout_handler = logging.StreamHandler(stream=sys.stdout)
-    stdout_handler.addFilter(_StdoutFilter())
-    stderr_handler = logging.StreamHandler(stream=sys.stderr)
-    stderr_handler.addFilter(_StderrFilter())
-    handlers = [stdout_handler, stderr_handler]
-    if _is_dumb_terminal():
-        formatter = logging.Formatter(style='{')
-    else:
-        formatter = _ColouredFormatter(style='{')
-    logger = logging.getLogger(logger_name)
-    for handler in handlers:
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-    logger.setLevel(log_level)
-
-    # The requests library is too noisy at INFO level.
-    if log_level == logging.DEBUG:
-        logging.getLogger('requests').setLevel(log_level)
-    else:
-        logging.getLogger('requests').setLevel(
-            max(logging.WARNING, log_level))
diff --git a/siab_client/config.py b/siab_client/config.py
deleted file mode 100644
index eacf0b3..0000000
--- a/siab_client/config.py
+++ /dev/null
@@ -1,94 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2017 Canonical Ltd.
-
-"""Configuration provider for this service."""
-
-import configparser
-import os
-
-
-ROOT = os.path.abspath(
-    os.path.join(
-        os.path.dirname(__file__),
-        '..'
-    )
-)
-
-
-DEFAULT_TEST_CONFIG = {
-    'services': {
-        'storage': 'http://localhost:8005/'
-    }
-}
-
-
-def _production_read_config():
-    root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
-    config = configparser.ConfigParser(dict(ROOT=root))
-    default_path = os.path.join(root, 'service.conf')
-    config.read(default_path)
-    return {sec: dict(config.items(sec)) for sec in config.sections()}
-
-
-class ConfigProvider(object):
-
-    """Provide a single entry point for reading config that can be altered.
-
-    This class allows production code to call 'read_config' and get a copy of
-    test configuration during test runs, but production config during normal
-    operations.
-    """
-
-    def __init__(self, default_test_config):
-        self._test_override = []
-        self._default_test_config = default_test_config
-
-    def __call__(self):
-        if self._test_override:
-            return self._test_override[-1]
-        else:
-            return _production_read_config()
-
-    def merge_config(self, config, new_config):
-        merged_config = config.copy()
-        for key in new_config.keys():
-            if key in config.keys():
-                if isinstance(config[key], dict) and \
-                   isinstance(new_config[key], dict):
-                    merged_config[key] = self.merge_config(
-                        config[key], new_config[key])
-                else:
-                    merged_config[key] = new_config[key]
-            else:
-                merged_config[key] = new_config[key]
-        return merged_config
-
-    def override_for_test(self, new_config):
-        """Override configuration for a test.
-
-        In a test, if you wanted to set a value, you can do this::
-
-            from snapdevicegw.config import read_config
-
-            def test_something(self):
-                new_config = {
-                    'worker': {
-                        'some_setting': 'some_value'
-                    }
-                }
-                self.addCleanup(read_config.override_for_test(new_config))
-
-        The configuration provided is merged on top of DEFAULT_TEST_CONFIG
-        (see above), so there's no need to specify values that are in the
-        default config.
-        """
-        if self._test_override:
-            source = self._test_override[-1]
-        else:
-            source = self._default_test_config.copy()
-        config = self.merge_config(source, new_config)
-        self._test_override.append(config)
-        return self._test_override.pop
-
-
-read_config = ConfigProvider(DEFAULT_TEST_CONFIG)
diff --git a/siab_client/logic/__init__.py b/siab_client/logic/__init__.py
deleted file mode 100644
index d115bb8..0000000
--- a/siab_client/logic/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2017 Canonical Ltd.
diff --git a/siab_client/logic/dump.py b/siab_client/logic/dump.py
deleted file mode 100644
index 554ced5..0000000
--- a/siab_client/logic/dump.py
+++ /dev/null
@@ -1,193 +0,0 @@
-# Copyright 2017 Canonical Ltd.
-
-import base64
-import codecs
-import csv
-import itertools
-import json
-import logging
-import os.path
-
-import yaml
-
-from siab_client import (
-    SUPPORTED_ARCHITECTURES,
-    config,
-)
-from siab_client import webservices as ws
-
-
-logger = logging.getLogger(__name__)
-
-
-RISK_ORDER = ['stable', 'candidate', 'beta', 'edge']
-
-
-def parse_channel(channel):
-    segments = channel.split('/')
-    if len(segments) == 1:
-        return None, segments[0], None
-    if len(segments) == 2:
-        return segments[0], segments[1], None
-    return segments
-
-
-def import_dump(args):
-    logger.info('Importing from %s.', args.root)
-    for snap_id in args.snap_id:
-        snap_root = os.path.join(args.root, snap_id)
-        _import_snap(snap_root)
-
-
-def _import_snap(dir):
-    with open(os.path.join(dir, 'snap.json')) as f:
-        snap_meta = json.loads(f.read())
-    logger.info(' %s -> %s', snap_meta['snap_id'], snap_meta['name'])
-
-    # XXX: Series and authority hardcoded.
-    error = ws.register_snap_name_and_blob(
-        snap_id=snap_meta['snap_id'],
-        snap_name=snap_meta['name'],
-        snap_blob=snap_meta['_cpi_data'],
-        private=snap_meta['private'],
-        series='16',
-        publisher_id=snap_meta['publisher_id'],
-        authority='canonical',
-        published=snap_meta['status'] == 'Published',
-        stores=snap_meta['stores'],
-        country_whitelist=snap_meta['country_whitelist'] or None,
-        country_blacklist=snap_meta['country_blacklist'] or None,
-        )
-    if error:
-        return
-
-    with open(os.path.join(dir, 'channelmap.json')) as f:
-        channelmaps = json.loads(f.read())
-
-    # Collect metadata for the interesting revisions. We currently only
-    # import those that are visible in channels now.
-    rev_metas = {}
-    for cm in channelmaps:
-        path = os.path.join(
-            dir, 'revisions', '{:d}.json'.format(cm['revision']))
-        if not os.path.exists(path):
-            continue
-        with open(path) as f:
-            rev_meta = json.loads(f.read())
-            assert rev_meta['revision'] == cm['revision']
-            rev_metas[cm['revision']] = rev_meta
-
-    # Collect the interesting revisions' SHA3-384s, translating them
-    # from hex to the snappy-style URL-safe base64.
-    sha3_384s = [
-        base64.urlsafe_b64encode(
-            codecs.decode(rev_meta['binary_sha3_384'], 'hex')).decode('ascii')
-        for rev_meta in rev_metas.values()]
-
-    # Ensure we have all relevant assertions locally before exposing new
-    # revisions to clients.
-    _sync_snap_assertions(
-        'https://assertions.ubuntu.com/v1/', snap_meta['snap_id'], '16',
-        sha3_384s)
-
-    seen_archs = set()
-    seen_tracks = set()
-    seen_track_risk_archs = set()
-    rev_created = []
-    for cm in channelmaps:
-        rev_meta = rev_metas.get(cm['revision'])
-        if rev_meta is None:
-            continue
-        if cm['revision'] not in rev_created:
-            ws.create_revision(
-                snap_meta['snap_id'], cm['revision'],
-                rev_meta['architectures'],
-                '/remotes/ubuntu/{}'.format(rev_meta['binary_path']),
-                rev_meta['binary_filesize'], rev_meta['binary_sha512'],
-                rev_meta['binary_sha3_384'], rev_meta['version'],
-                rev_meta['confinement'], rev_meta['snap_yaml_raw'])
-            rev_created.append(cm['revision'])
-        track, risk, branch = parse_channel(cm['channel'])
-        exploded_architectures = set(rev_meta['architectures'])
-        seen_archs.update(exploded_architectures)
-        seen_tracks.add(track)
-        seen_track_risk_archs.update(
-            (track, risk, arch) for arch in exploded_architectures)
-        if 'all' in exploded_architectures:
-            exploded_architectures.remove('all')
-            exploded_architectures.update(SUPPORTED_ARCHITECTURES)
-        ws.release_revision(
-            snap_meta['snap_id'], snap_meta['name'], cm['series'],
-            [track, risk, branch], exploded_architectures, cm['revision'])
-
-    # Fill in tracking.
-    all_track_risk_archs = set(
-        itertools.product(seen_tracks, RISK_ORDER[1:], seen_archs))
-    for track, risk, arch in all_track_risk_archs - seen_track_risk_archs:
-        ws.release_revision(
-            snap_meta['snap_id'], snap_meta['name'], cm['series'],
-            [track, risk, None], [arch],
-            redirect_channel=[
-                track, RISK_ORDER[RISK_ORDER.index(risk) - 1], None],
-            permanent_redirect=False)
-
-
-def import_snapsection_dump(args):
-    """Import snapsection tsv dump.
-
-    Assumes tsv takes form:
-    snap_id\tfeatured\tscore\tsection_name
-    """
-    logger.info('Importing snapsections from %s.', args.tsv_file)
-
-    sections = {}
-    with open(args.tsv_file, 'r') as tsvin:
-        tsv = csv.reader(tsvin, delimiter='\t')
-        for snap_id, featured, score, section_name in tsv:
-            if section_name not in sections:
-                sections[section_name] = []
-            sections[section_name].append({
-                'snap_id': snap_id,
-                'featured': bool(featured),
-                'score': int(score),
-                'series': '16',
-            })
-    payload = {'sections': []}
-    for section in sections:
-        payload['sections'].append({
-            'section_name': section,
-            'snaps': sections[section]
-        })
-    ws.create_snapsections(payload)
-
-
-def _parse_assertion(assertion):
-    return yaml.safe_load(assertion.split(b'\n\n')[0])
-
-
-def _sync_snap_assertions(remote, snap_id, series, sha3_384s):
-    local = config.read_config()['services']['assertions']
-
-    # Collect the snap-declaration and snap-revisions.
-    decl_raw = ws.get_assertion(remote, 'snap-declaration', (series, snap_id))
-    rev_raws = [
-        ws.get_assertion(remote, 'snap-revision', (sha3_384,))
-        for sha3_384 in sha3_384s
-        if ws.get_assertion(local, 'snap-revision', (sha3_384,)) is None]
-
-    # Collect dependencies (currently just accounts).
-    accounts = set()
-    accounts.add(_parse_assertion(decl_raw)['publisher-id'])
-    accounts.update(
-        _parse_assertion(rev_raw)['developer-id'] for rev_raw in rev_raws)
-
-    # Import dependencies that don't exist.
-    for account in accounts:
-        if ws.get_assertion(local, 'account', (account,)) is not None:
-            continue
-        ws.save_assertion(ws.get_assertion(remote, 'account', (account,)))
-
-    # Now save the main assertions.
-    ws.save_assertion(decl_raw)
-    for rev_raw in rev_raws:
-        ws.save_assertion(rev_raw)
diff --git a/siab_client/logic/upload.py b/siab_client/logic/upload.py
deleted file mode 100644
index 86264c0..0000000
--- a/siab_client/logic/upload.py
+++ /dev/null
@@ -1,200 +0,0 @@
-# Copyright 2017 Canonical Ltd.
-
-import hashlib
-import logging
-import os
-import random
-import shutil
-import string
-import subprocess
-import sys
-import tempfile
-
-import yaml
-
-from siab_client import (
-    SUPPORTED_ARCHITECTURES,
-    get_storage_root,
-)
-from siab_client import webservices as ws
-
-if sys.version < '3.6':
-    import sha3  # noqa
-
-
-logger = logging.getLogger(__name__)
-
-
-def upload_snap(args):
-    snap_path = args.snap
-    with tempfile.TemporaryDirectory() as workdir:
-        snap_yaml = _parse_snap_yaml(workdir, snap_path)
-
-        name = snap_yaml['name']
-        version = str(snap_yaml['version'])
-        summary = snap_yaml['summary']
-        description = snap_yaml['description']
-        confinement = snap_yaml['confinement']
-        architectures = snap_yaml['architectures']
-        sha3_384 = _extract_sha3_384(snap_path)
-        sha512 = _extract_sha512(snap_path)
-        binary_filesize = os.path.getsize(snap_path)
-
-        snap_yaml = _read_snap_yaml(workdir, snap_path)
-
-        logger.info("Name: %s", name)
-        logger.info("Version: %s", version)
-        logger.info("Summary: %s", summary)
-        logger.info("Description: %s", description)
-        logger.info("Confinement: %s", confinement)
-        logger.info("Architectures: %s", ', '.join(architectures))
-        logger.info("Sha3_384: %s", sha3_384)
-        logger.info("Sha512: %s", sha512)
-        logger.info("Binary filesize: %d", binary_filesize)
-
-        series = '16'
-
-        snap_id = ws.get_snap_id_for_name(name, series)
-        if snap_id is None:
-            snap_id = _generate_new_snap_id()
-
-        snap_blob = _create_snap_blob(
-            name,
-            description,
-            summary,
-        )
-        ws.register_snap_name_and_blob(
-            snap_id, name, series, snap_blob, authority='local',
-            stores=['ubuntu'])
-
-        latest_revision = ws.get_latest_revision_for_snap_id(snap_id)
-        next_revision = latest_revision + 1 if latest_revision else 1
-        binary_path = _store_snap(snap_path, name, next_revision)
-        logger.info("Binary file path: %s", binary_path)
-        registration_success = ws.create_revision(
-            snap_id,
-            next_revision,
-            architectures,
-            binary_path,
-            binary_filesize,
-            sha512,
-            sha3_384,
-            version,
-            confinement,
-            snap_yaml
-        )
-        exploded_architectures = set(architectures)
-        if 'all' in exploded_architectures:
-            exploded_architectures.remove('all')
-            exploded_architectures.update(SUPPORTED_ARCHITECTURES)
-        if registration_success and args.channel:
-            # TODO: Track/branch
-            ws.release_revision(
-                snap_id, name, series, [None, args.channel, None],
-                list(exploded_architectures), next_revision)
-
-        ws.create_or_update_assertions(
-            snap_id,
-            name,
-            series,
-            next_revision,
-            sha3_384,
-            binary_filesize
-        )
-
-
-def _parse_snap_yaml(workdir, snap_path):
-    """Extract the contents of the snap yaml file, given the path to a .snap"""
-    return yaml.safe_load(_read_snap_yaml(workdir, snap_path))
-
-
-def _read_snap_yaml(workdir, snap_path):
-    unsquash_path = os.path.join(workdir, 'unsquashed_snap')
-    subprocess.check_call(
-        ['unsquashfs', '-d', unsquash_path, snap_path],
-        stdout=subprocess.DEVNULL)
-    yaml_path = os.path.join(unsquash_path, 'meta', 'snap.yaml')
-    with open(yaml_path, 'r') as yaml_file:
-        return yaml_file.read()
-
-
-def _extract_sha3_384(file_path):
-    blocksize = 2**20
-    with open(file_path, 'rb') as snap_file:
-        hasher = hashlib.sha3_384()
-        while True:
-            buf = snap_file.read(blocksize)
-            if not buf:
-                break
-            hasher.update(buf)
-        return hasher.hexdigest()
-
-
-def _extract_sha512(file_path):
-    blocksize = 2**20
-    with open(file_path, 'rb') as snap_file:
-        hasher = hashlib.sha512()
-        while True:
-            buf = snap_file.read(blocksize)
-            if not buf:
-                break
-            hasher.update(buf)
-        return hasher.hexdigest()
-
-
-def _generate_new_snap_id():
-    """Generate a random ID to identify a snap entity.
-
-    Snap ids are a sequence of 32 random characters taken out of an alphabet
-    of 62 characters (uppercase letters + lowercase letters + numbers), for
-    a total of 310 bits of space. These unique identifiers are generated
-    centrally or delegated to known parties.
-
-    This function does not check for duplicates.
-
-    """
-    SNAP_ID_ALPHABET = string.ascii_letters + string.digits
-    return ''.join(
-            random.choice(SNAP_ID_ALPHABET) for _ in range(32))
-
-
-def _create_snap_blob(snap_name, description, summary):
-    """Generate the 'blob', as it's exported from SCA.
-
-    Many of the fields in the SCA data export aren't used in any part of the
-    snapv2 ecosystem, and have been omitted here. This script doesn't know
-    about some of the fields, so dummy data has been inserted.
-    """
-    # TODO: Fill in 'origin', 'developer_id', 'developer_name' and 'summary'
-    # somehow
-    return {
-        "origin": "developername",
-        "last_updated": None,
-        "package_name": snap_name,
-        "screenshot_url": None,
-        "developer_id": "46MtBuBZaWy3g8picgdg6YkrCQo84J46",
-        "ratings_average": 0.0,
-        "title": "snap title here",
-        "support_url": "",
-        "icon_url": None,
-        "developer_name": "developername",
-        "screenshot_urls": [],
-        "description": description,
-        "price": 0.0,
-        "translations": {},
-        "prices": {},
-        "publisher": "some publisher",
-        "summary": summary,
-    }
-
-
-def _store_snap(snap_path, snap_name, next_revision):
-    """Store a snap in the storage directory.
-
-    Returns the path that file was stored in, relative to the storage root.
-    """
-    storage_dir = get_storage_root()
-    target_filename = '%s_%d.snap' % (snap_name, next_revision)
-    target_path = os.path.join(storage_dir, target_filename)
-    shutil.copy(snap_path, target_path)
-    return '/' + os.path.relpath(target_path, storage_dir)
diff --git a/siab_client/tests/__init__.py b/siab_client/tests/__init__.py
deleted file mode 100644
index de20494..0000000
--- a/siab_client/tests/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Copyright 2017 Canonical Ltd.
-
-import os
-from unittest import TestLoader
-
-import siab_client
-
-
-def test_suite():
-    loader = TestLoader()
-    start_dir = os.path.split(siab_client.__file__)[0]
-    top_dir = os.path.join(start_dir, os.path.pardir)
-    suite = loader.discover(start_dir, top_level_dir=top_dir)
-    return suite
diff --git a/siab_client/tests/test_cli.py b/siab_client/tests/test_cli.py
deleted file mode 100644
index 18b7b8d..0000000
--- a/siab_client/tests/test_cli.py
+++ /dev/null
@@ -1,64 +0,0 @@
-# Copyright 2017 Canonical Ltd.
-
-import logging
-
-import fixtures
-from testtools import TestCase
-
-from siab_client import cli
-
-
-class ConfigureLoggingTests(TestCase):
-
-    def setUp(self):
-        super().setUp()
-        self.logger = logging.getLogger(__name__)
-        self.addCleanup(
-            self._restoreLogger,
-            self.logger, self.logger.level, list(self.logger.handlers))
-        self.stdout = self.useFixture(fixtures.StringStream('stdout')).stream
-        self.stdout.fileno = lambda: 1
-        self.useFixture(fixtures.MonkeyPatch('sys.stdout', self.stdout))
-        self.stderr = self.useFixture(fixtures.StringStream('stderr')).stream
-        self.useFixture(fixtures.MonkeyPatch('sys.stderr', self.stderr))
-
-    @staticmethod
-    def _restoreLogger(logger, level, handlers):
-        logger.setLevel(logger.level)
-        for handler in list(logger.handlers):
-            logger.removeHandler(handler)
-        for handler in handlers:
-            logger.addHandler(handler)
-
-    def test_log_levels(self):
-        self.useFixture(fixtures.MonkeyPatch('os.isatty', lambda fd: True))
-        cli.configure_logging(__name__)
-        self.assertEqual(logging.INFO, self.logger.level)
-        self.logger.debug('Debug')
-        self.logger.info('Info')
-        self.logger.warning('Warning: %s', 'smoke')
-        self.logger.error('Error: %s', 'fire')
-        self.stdout.seek(0)
-        self.assertEqual('Info\nWarning: smoke\n', self.stdout.read())
-        self.stderr.seek(0)
-        self.assertEqual('\033[0;31mError: fire\033[0m\n', self.stderr.read())
-
-    def test_requests_log_level_default(self):
-        cli.configure_logging(__name__)
-        self.assertEqual(logging.WARNING, logging.getLogger('requests').level)
-
-    def test_requests_log_level_debug(self):
-        cli.configure_logging(__name__, logging.DEBUG)
-        self.assertEqual(logging.DEBUG, logging.getLogger('requests').level)
-
-    def test_requests_log_level_error(self):
-        cli.configure_logging(__name__, logging.ERROR)
-        self.assertEqual(logging.ERROR, logging.getLogger('requests').level)
-
-    def test_no_tty(self):
-        self.useFixture(fixtures.MonkeyPatch('os.isatty', lambda fd: False))
-        self.useFixture(fixtures.EnvironmentVariable('TERM', 'xterm'))
-        cli.configure_logging(__name__)
-        self.logger.error('Error: %s', 'fire')
-        self.stderr.seek(0)
-        self.assertEqual('Error: fire\n', self.stderr.read())
diff --git a/siab_client/tests/test_config.py b/siab_client/tests/test_config.py
deleted file mode 100644
index 7bf5271..0000000
--- a/siab_client/tests/test_config.py
+++ /dev/null
@@ -1,72 +0,0 @@
-# Copyright 2017 Canonical Ltd.
-
-from testtools import TestCase
-
-from siab_client.config import ConfigProvider
-
-
-class ConfigProviderTestCase(TestCase):
-
-    def test_override_works_for_new_section_and_option(self):
-        default = {}
-        override = {
-            'new_section': {
-                'new_option': 'new_value'
-            }
-        }
-        expected = override.copy()
-
-        provider = ConfigProvider(default)
-        provider.override_for_test(override)
-
-        self.assertEqual(expected, provider())
-
-    def test_override_works_when_adding_new_option_to_existing_section(self):
-        default = {
-            'section': {
-                'option': 'value'
-            }
-        }
-        override = {
-            'section': {
-                'new_option': 'new_value'
-            }
-        }
-        expected = {
-            'section': {
-                'option': 'value',
-                'new_option': 'new_value'
-            }
-        }
-
-        provider = ConfigProvider(default)
-        provider.override_for_test(override)
-
-        self.assertEqual(expected, provider())
-
-    def test_override_works_when_changing_existing_option(self):
-        default = {
-            'section': {
-                'option': 'value'
-            }
-        }
-        override = {
-            'section': {
-                'option': 'new_value'
-            }
-        }
-        expected = {
-            'section': {
-                'option': 'new_value',
-            }
-        }
-
-        provider = ConfigProvider(default)
-        provider.override_for_test(override)
-
-        self.assertEqual(expected, provider())
-
-
-def test_suite():
-    from unittest import TestLoader
-    return TestLoader().loadTestsFromName(__name__)
diff --git a/siab_client/webservices.py b/siab_client/webservices.py
deleted file mode 100644
index addfd0f..0000000
--- a/siab_client/webservices.py
+++ /dev/null
@@ -1,278 +0,0 @@
-# Copyright 2017 Canonical Ltd.
-
-import base64
-import binascii
-import datetime
-import json
-import logging
-import os.path
-import urllib.parse
-
-import requests
-
-from siab_client import config
-
-
-logger = logging.getLogger(__name__)
-
-
-def get_snap_id_for_name(snap_name, series):
-    """Return the snap_name associated with this snap_name.
-
-    Returns None if the snap_name has not been associated with a snap_id yet.
-    """
-    ident_root = config.read_config()['services']['snapident']
-    resp = requests.post(
-        urllib.parse.urljoin(ident_root, '/snaps/filter'),
-        json={
-            'filters': [{
-                'snap_name': snap_name,
-                'series': series
-            }]
-        }
-    )
-    snap_results = resp.json()['snaps']
-    if not snap_results:
-        return None
-    assert len(snap_results) == 1
-    return snap_results[0]['snap_id']
-
-
-def register_snap_name_and_blob(snap_id, snap_name, series, snap_blob,
-                                private=False, authority=None,
-                                publisher_id=None, published=True,
-                                stores=['ubuntu'], country_whitelist=None,
-                                country_blacklist=None):
-    ident_root = config.read_config()['services']['snapident']
-    data = {'snap_id': snap_id,
-            'private': private,
-            'publisher_id': snap_blob['developer_id'],
-            'snap_name': snap_name,
-            'series': series,
-            'blob': snap_blob,
-            'authority': authority,
-            'status': 'published' if published else 'unpublished',
-            'stores': stores}
-    if country_whitelist is not None:
-        data['country_whitelist'] = country_whitelist
-    if country_blacklist is not None:
-        data['country_blacklist'] = country_blacklist
-    resp = requests.post(
-        urllib.parse.urljoin(ident_root, '/snaps/update'),
-        json={'snaps': [data]})
-    if resp.status_code == 200:
-        logger.info(
-            "Snap '%s' (%s) registered for series '%s'.",
-            snap_name, snap_id, series
-        )
-        return False
-    else:
-        _print_error_message('register snap', resp)
-        return True
-
-
-def release_revision(snap_id, snap_name, series, channel, arches,
-                     revision=None, redirect_channel=None,
-                     permanent_redirect=None):
-    reqs = []
-    for arch in arches:
-        d = {
-            'snap_id': snap_id,
-            'channel': channel,
-            'architecture': arch,
-            'series': series,
-        }
-        if revision is not None:
-            d['revision'] = revision
-        else:
-            d['redirect_channel'] = redirect_channel
-            d['permanent_redirect'] = permanent_redirect
-        reqs.append(d)
-    revs_root = config.read_config()['services']['snaprevs']
-    resp = requests.post(
-        urllib.parse.urljoin(revs_root, '/channelmaps/update'),
-        json={
-            'developer_id': 'wgrant',
-            'release_requests': reqs,
-        }
-    )
-    if resp.status_code == 200:
-        logger.info(
-            "Snap '%s' (%s) revision %s released to series=%s, "
-            "channel=%s, arches=%s",
-            snap_name, snap_id, revision, series, channel,
-            ','.join(arches)
-        )
-    else:
-        _print_error_message('release revision', resp)
-
-
-def get_latest_revision_for_snap_id(snap_id):
-    """Return the latest revision for the given snap_id.
-
-    If no revisions have been published yet, this function returns None.
-    """
-    snaprevs_root = config.read_config()['services']['snaprevs']
-    resp = requests.post(
-        urllib.parse.urljoin(snaprevs_root, '/revisions/filter'),
-        json={'filters': [{'snap_id': snap_id}]}
-    )
-    revisions = [s['revision'] for s in resp.json()['revisions']]
-    return max(revisions) if revisions else None
-
-
-def create_revision(snap_id, revision, architectures, binary_path, filesize,
-                    sha512, sha3_384, version, confinement, snap_yaml):
-    """Create a snap revision with snaprevs.
-
-    Returns True on succcess, False otherwise.
-    """
-    snaprevs_root = config.read_config()['services']['snaprevs']
-    # TODO: I suspect this is supposed to be UTC time, not local time?
-    created_at = datetime.datetime.now().isoformat()
-    # TODO: figure out what we're doing with developer ids.
-    created_by = 'TODO'
-    payload = {
-        'snap_id': snap_id,
-        'revision': revision,
-        'created_at': created_at,
-        'created_by': created_by,
-        'architectures': architectures,
-        'binary_path': binary_path,
-        'binary_filesize': filesize,
-        'binary_sha512': sha512,
-        'binary_sha3_384': sha3_384,
-        'version': version,
-        'confinement': confinement,
-        'snap_yaml': snap_yaml or '',
-        'epoch': 0,
-        'type': 'app',
-    }
-    resp = requests.post(
-        urllib.parse.urljoin(snaprevs_root, '/revisions/create'),
-        json=[payload]
-    )
-    if resp.status_code != 201:
-        _print_error_message('create revision', resp)
-        return False
-
-    logger.info("Revision %s of %s created.", revision, snap_id)
-    return True
-
-
-def create_snapsections(payload):
-    logger.info('Updating sections and snapsections...')
-
-    snapfind_root = config.read_config()['services']['snapfind']
-    snapfind_snapsection_endpoint = urllib.parse.urljoin(
-        snapfind_root, '/sections/snaps')
-
-    response = requests.post(snapfind_snapsection_endpoint, json=payload)
-    if response.ok:
-        logger.info('Done.')
-    else:
-        logger.error(response.text)
-
-
-def get_assertion(root, type_, key):
-    resp = requests.get(
-        urllib.parse.urljoin(root, os.path.join('assertions', type_, *key)),
-        headers={'Accept': 'application/x.ubuntu.assertion'})
-    if resp.status_code != 200:
-        return None
-    return resp.content
-
-
-def create_or_update_assertions(
-        snap_id, snap_name, series, revision, binary_sha3_384,
-        binary_filesize):
-    assertions_root = config.read_config()['services']['assertions']
-    authority = config.read_config()['assertions']['authority']
-    timestamp = datetime.datetime.now().isoformat() + 'Z'
-
-    if get_assertion(
-            assertions_root, 'snap-declaration', (series, snap_id)) is None:
-        logger.info("Creating snap-declaration ...")
-        assertion_headers = {
-            'type': 'snap-declaration',
-            'revision': '0',
-            'authority-id': authority,
-            'publisher-id': authority,
-            'series': series,
-            'snap-id': snap_id,
-            'snap-name': snap_name,
-            'timestamp': timestamp,
-        }
-        assertion = sign_assertion(assertion_headers)
-        save_assertion(assertion)
-
-    logger.info("Creating snap-revision ...")
-    snap_sha3_384 = base64.urlsafe_b64encode(
-        binascii.a2b_hex(binary_sha3_384)).decode().rstrip("=")
-    snap_size = str(binary_filesize)
-    snap_revision = str(revision)
-    assertion_headers = {
-        'type': 'snap-revision',
-        'authority-id': authority,
-        'developer-id': authority,
-        'snap-sha3-384': snap_sha3_384,
-        'snap-id': snap_id,
-        'snap-size': snap_size,
-        'snap-revision': snap_revision,
-        'timestamp': timestamp,
-    }
-    assertion = sign_assertion(assertion_headers)
-    save_assertion(assertion)
-
-
-def save_assertion(assertion):
-    assertions_root = config.read_config()['services']['assertions']
-    request_headers = {
-        'Content-Type': 'application/x.ubuntu.assertion',
-    }
-    resp = requests.post(
-        urllib.parse.urljoin(assertions_root, 'assertions'),
-        data=assertion, headers=request_headers)
-
-    if resp.status_code != 201:
-        _print_error_message('save assertion', resp)
-        resp.raise_for_status()
-
-
-def sign_assertion(assertion_headers):
-    assertions_root = config.read_config()['services']['assertions']
-    signing_key_id = config.read_config()['assertions']['signing_key_id']
-    request_headers = {
-        'Content-Type': 'application/json',
-    }
-    data = {
-        'key-id': signing_key_id,
-        'headers': assertion_headers,
-    }
-    resp = requests.post(
-        urllib.parse.urljoin(assertions_root, 'sign'),
-        headers=request_headers, json=data)
-
-    if resp.status_code != 200:
-        _print_error_message('sign assertion', resp)
-        resp.raise_for_status()
-
-    return resp.text
-
-
-def _print_error_message(action, response):
-    """Print failure messages from other services in a standard way."""
-    logger.error("Failed to %s:", action)
-    if response.status_code == 500:
-        logger.error("Server sent 500 response.")
-    else:
-        try:
-            json_document = response.json()
-            for error in json_document['error_list']:
-                logger.error(error['message'])
-        except json.JSONDecodeError:
-            logger.error(
-                "Server sent non-json response, printed verbatim below:")
-            logger.error('=' * 20)
-            logger.error(response.content)
-            logger.error('=' * 20)
diff --git a/snapstore b/snapstore
index 5d66fe9..07794cf 100755
--- a/snapstore
+++ b/snapstore
@@ -7,9 +7,9 @@
 import argparse
 import sys
 
-from siab_client.cli import configure_logging
-from siab_client.logic.upload import upload_snap
-from siab_client.logic.dump import (
+from snapstore_client.cli import configure_logging
+from snapstore_client.logic.upload import upload_snap
+from snapstore_client.logic.dump import (
     import_dump,
     import_snapsection_dump,
 )
diff --git a/snapstore_client/__init__.py b/snapstore_client/__init__.py
new file mode 100644
index 0000000..e69df82
--- /dev/null
+++ b/snapstore_client/__init__.py
@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Canonical Ltd.
+
+import os
+
+
+SUPPORTED_ARCHITECTURES = (
+    'amd64', 'arm64', 'armhf', 'i386', 'powerpc', 'ppc64el', 's390x')
+
+
+def get_storage_root():
+    return os.path.abspath(
+        os.path.join(
+            os.path.dirname(__file__),
+            '..',
+            'snap_storage'
+        )
+    )
diff --git a/snapstore_client/cli.py b/snapstore_client/cli.py
new file mode 100644
index 0000000..0ee6e66
--- /dev/null
+++ b/snapstore_client/cli.py
@@ -0,0 +1,66 @@
+# Copyright 2017 Canonical Ltd.
+
+"""Command-line interface niceties for this service."""
+
+import logging
+import os
+import sys
+
+
+class _StdoutFilter(logging.Filter):
+
+    def filter(self, record):
+        return record.levelno <= logging.WARNING
+
+
+class _StderrFilter(logging.Filter):
+
+    def filter(self, record):
+        return record.levelno >= logging.ERROR
+
+
+def _is_dumb_terminal():
+    """Return True if on a dumb terminal."""
+    is_stdout_tty = os.isatty(sys.stdout.fileno())
+    is_term_dumb = os.environ.get('TERM', '') == 'dumb'
+    return not is_stdout_tty or is_term_dumb
+
+
+class _ColouredFormatter(logging.Formatter):
+
+    _reset = '\033[0m'
+    _level_colours = {
+        'ERROR': '\033[0;31m',  # Dark red
+    }
+
+    def format(self, record):
+        colour = self._level_colours.get(record.levelname)
+        log_message = super().format(record)
+        if colour is not None:
+            return colour + log_message + self._reset
+        else:
+            return log_message
+
+
+def configure_logging(logger_name=None, log_level=logging.INFO):
+    stdout_handler = logging.StreamHandler(stream=sys.stdout)
+    stdout_handler.addFilter(_StdoutFilter())
+    stderr_handler = logging.StreamHandler(stream=sys.stderr)
+    stderr_handler.addFilter(_StderrFilter())
+    handlers = [stdout_handler, stderr_handler]
+    if _is_dumb_terminal():
+        formatter = logging.Formatter(style='{')
+    else:
+        formatter = _ColouredFormatter(style='{')
+    logger = logging.getLogger(logger_name)
+    for handler in handlers:
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    logger.setLevel(log_level)
+
+    # The requests library is too noisy at INFO level.
+    if log_level == logging.DEBUG:
+        logging.getLogger('requests').setLevel(log_level)
+    else:
+        logging.getLogger('requests').setLevel(
+            max(logging.WARNING, log_level))
diff --git a/snapstore_client/config.py b/snapstore_client/config.py
new file mode 100644
index 0000000..eacf0b3
--- /dev/null
+++ b/snapstore_client/config.py
@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Canonical Ltd.
+
+"""Configuration provider for this service."""
+
+import configparser
+import os
+
+
+ROOT = os.path.abspath(
+    os.path.join(
+        os.path.dirname(__file__),
+        '..'
+    )
+)
+
+
+DEFAULT_TEST_CONFIG = {
+    'services': {
+        'storage': 'http://localhost:8005/'
+    }
+}
+
+
+def _production_read_config():
+    root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+    config = configparser.ConfigParser(dict(ROOT=root))
+    default_path = os.path.join(root, 'service.conf')
+    config.read(default_path)
+    return {sec: dict(config.items(sec)) for sec in config.sections()}
+
+
+class ConfigProvider(object):
+
+    """Provide a single entry point for reading config that can be altered.
+
+    This class allows production code to call 'read_config' and get a copy of
+    test configuration during test runs, but production config during normal
+    operations.
+    """
+
+    def __init__(self, default_test_config):
+        self._test_override = []
+        self._default_test_config = default_test_config
+
+    def __call__(self):
+        if self._test_override:
+            return self._test_override[-1]
+        else:
+            return _production_read_config()
+
+    def merge_config(self, config, new_config):
+        merged_config = config.copy()
+        for key in new_config.keys():
+            if key in config.keys():
+                if isinstance(config[key], dict) and \
+                   isinstance(new_config[key], dict):
+                    merged_config[key] = self.merge_config(
+                        config[key], new_config[key])
+                else:
+                    merged_config[key] = new_config[key]
+            else:
+                merged_config[key] = new_config[key]
+        return merged_config
+
+    def override_for_test(self, new_config):
+        """Override configuration for a test.
+
+        In a test, if you wanted to set a value, you can do this::
+
+            from snapdevicegw.config import read_config
+
+            def test_something(self):
+                new_config = {
+                    'worker': {
+                        'some_setting': 'some_value'
+                    }
+                }
+                self.addCleanup(read_config.override_for_test(new_config))
+
+        The configuration provided is merged on top of DEFAULT_TEST_CONFIG
+        (see above), so there's no need to specify values that are in the
+        default config.
+        """
+        if self._test_override:
+            source = self._test_override[-1]
+        else:
+            source = self._default_test_config.copy()
+        config = self.merge_config(source, new_config)
+        self._test_override.append(config)
+        return self._test_override.pop
+
+
+read_config = ConfigProvider(DEFAULT_TEST_CONFIG)
diff --git a/snapstore_client/logic/__init__.py b/snapstore_client/logic/__init__.py
new file mode 100644
index 0000000..d115bb8
--- /dev/null
+++ b/snapstore_client/logic/__init__.py
@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Canonical Ltd.
diff --git a/snapstore_client/logic/dump.py b/snapstore_client/logic/dump.py
new file mode 100644
index 0000000..d2c2a40
--- /dev/null
+++ b/snapstore_client/logic/dump.py
@@ -0,0 +1,193 @@
+# Copyright 2017 Canonical Ltd.
+
+import base64
+import codecs
+import csv
+import itertools
+import json
+import logging
+import os.path
+
+import yaml
+
+from snapstore_client import (
+    SUPPORTED_ARCHITECTURES,
+    config,
+)
+from snapstore_client import webservices as ws
+
+
+logger = logging.getLogger(__name__)
+
+
+RISK_ORDER = ['stable', 'candidate', 'beta', 'edge']
+
+
+def parse_channel(channel):
+    segments = channel.split('/')
+    if len(segments) == 1:
+        return None, segments[0], None
+    if len(segments) == 2:
+        return segments[0], segments[1], None
+    return segments
+
+
+def import_dump(args):
+    logger.info('Importing from %s.', args.root)
+    for snap_id in args.snap_id:
+        snap_root = os.path.join(args.root, snap_id)
+        _import_snap(snap_root)
+
+
+def _import_snap(dir):
+    with open(os.path.join(dir, 'snap.json')) as f:
+        snap_meta = json.loads(f.read())
+    logger.info(' %s -> %s', snap_meta['snap_id'], snap_meta['name'])
+
+    # XXX: Series and authority hardcoded.
+    error = ws.register_snap_name_and_blob(
+        snap_id=snap_meta['snap_id'],
+        snap_name=snap_meta['name'],
+        snap_blob=snap_meta['_cpi_data'],
+        private=snap_meta['private'],
+        series='16',
+        publisher_id=snap_meta['publisher_id'],
+        authority='canonical',
+        published=snap_meta['status'] == 'Published',
+        stores=snap_meta['stores'],
+        country_whitelist=snap_meta['country_whitelist'] or None,
+        country_blacklist=snap_meta['country_blacklist'] or None,
+        )
+    if error:
+        return
+
+    with open(os.path.join(dir, 'channelmap.json')) as f:
+        channelmaps = json.loads(f.read())
+
+    # Collect metadata for the interesting revisions. We currently only
+    # import those that are visible in channels now.
+    rev_metas = {}
+    for cm in channelmaps:
+        path = os.path.join(
+            dir, 'revisions', '{:d}.json'.format(cm['revision']))
+        if not os.path.exists(path):
+            continue
+        with open(path) as f:
+            rev_meta = json.loads(f.read())
+            assert rev_meta['revision'] == cm['revision']
+            rev_metas[cm['revision']] = rev_meta
+
+    # Collect the interesting revisions' SHA3-384s, translating them
+    # from hex to the snappy-style URL-safe base64.
+    sha3_384s = [
+        base64.urlsafe_b64encode(
+            codecs.decode(rev_meta['binary_sha3_384'], 'hex')).decode('ascii')
+        for rev_meta in rev_metas.values()]
+
+    # Ensure we have all relevant assertions locally before exposing new
+    # revisions to clients.
+    _sync_snap_assertions(
+        'https://assertions.ubuntu.com/v1/', snap_meta['snap_id'], '16',
+        sha3_384s)
+
+    seen_archs = set()
+    seen_tracks = set()
+    seen_track_risk_archs = set()
+    rev_created = []
+    for cm in channelmaps:
+        rev_meta = rev_metas.get(cm['revision'])
+        if rev_meta is None:
+            continue
+        if cm['revision'] not in rev_created:
+            ws.create_revision(
+                snap_meta['snap_id'], cm['revision'],
+                rev_meta['architectures'],
+                '/remotes/ubuntu/{}'.format(rev_meta['binary_path']),
+                rev_meta['binary_filesize'], rev_meta['binary_sha512'],
+                rev_meta['binary_sha3_384'], rev_meta['version'],
+                rev_meta['confinement'], rev_meta['snap_yaml_raw'])
+            rev_created.append(cm['revision'])
+        track, risk, branch = parse_channel(cm['channel'])
+        exploded_architectures = set(rev_meta['architectures'])
+        seen_archs.update(exploded_architectures)
+        seen_tracks.add(track)
+        seen_track_risk_archs.update(
+            (track, risk, arch) for arch in exploded_architectures)
+        if 'all' in exploded_architectures:
+            exploded_architectures.remove('all')
+            exploded_architectures.update(SUPPORTED_ARCHITECTURES)
+        ws.release_revision(
+            snap_meta['snap_id'], snap_meta['name'], cm['series'],
+            [track, risk, branch], exploded_architectures, cm['revision'])
+
+    # Fill in tracking.
+    all_track_risk_archs = set(
+        itertools.product(seen_tracks, RISK_ORDER[1:], seen_archs))
+    for track, risk, arch in all_track_risk_archs - seen_track_risk_archs:
+        ws.release_revision(
+            snap_meta['snap_id'], snap_meta['name'], cm['series'],
+            [track, risk, None], [arch],
+            redirect_channel=[
+                track, RISK_ORDER[RISK_ORDER.index(risk) - 1], None],
+            permanent_redirect=False)
+
+
+def import_snapsection_dump(args):
+    """Import snapsection tsv dump.
+
+    Assumes tsv takes form:
+    snap_id\tfeatured\tscore\tsection_name
+    """
+    logger.info('Importing snapsections from %s.', args.tsv_file)
+
+    sections = {}
+    with open(args.tsv_file, 'r') as tsvin:
+        tsv = csv.reader(tsvin, delimiter='\t')
+        for snap_id, featured, score, section_name in tsv:
+            if section_name not in sections:
+                sections[section_name] = []
+            sections[section_name].append({
+                'snap_id': snap_id,
+                'featured': bool(featured),
+                'score': int(score),
+                'series': '16',
+            })
+    payload = {'sections': []}
+    for section in sections:
+        payload['sections'].append({
+            'section_name': section,
+            'snaps': sections[section]
+        })
+    ws.create_snapsections(payload)
+
+
+def _parse_assertion(assertion):
+    return yaml.safe_load(assertion.split(b'\n\n')[0])
+
+
+def _sync_snap_assertions(remote, snap_id, series, sha3_384s):
+    local = config.read_config()['services']['assertions']
+
+    # Collect the snap-declaration and snap-revisions.
+    decl_raw = ws.get_assertion(remote, 'snap-declaration', (series, snap_id))
+    rev_raws = [
+        ws.get_assertion(remote, 'snap-revision', (sha3_384,))
+        for sha3_384 in sha3_384s
+        if ws.get_assertion(local, 'snap-revision', (sha3_384,)) is None]
+
+    # Collect dependencies (currently just accounts).
+    accounts = set()
+    accounts.add(_parse_assertion(decl_raw)['publisher-id'])
+    accounts.update(
+        _parse_assertion(rev_raw)['developer-id'] for rev_raw in rev_raws)
+
+    # Import dependencies that don't exist.
+    for account in accounts:
+        if ws.get_assertion(local, 'account', (account,)) is not None:
+            continue
+        ws.save_assertion(ws.get_assertion(remote, 'account', (account,)))
+
+    # Now save the main assertions.
+    ws.save_assertion(decl_raw)
+    for rev_raw in rev_raws:
+        ws.save_assertion(rev_raw)
diff --git a/snapstore_client/logic/upload.py b/snapstore_client/logic/upload.py
new file mode 100644
index 0000000..5dd5d1d
--- /dev/null
+++ b/snapstore_client/logic/upload.py
@@ -0,0 +1,200 @@
+# Copyright 2017 Canonical Ltd.
+
+import hashlib
+import logging
+import os
+import random
+import shutil
+import string
+import subprocess
+import sys
+import tempfile
+
+import yaml
+
+from snapstore_client import (
+    SUPPORTED_ARCHITECTURES,
+    get_storage_root,
+)
+from snapstore_client import webservices as ws
+
+if sys.version < '3.6':
+    import sha3  # noqa
+
+
+logger = logging.getLogger(__name__)
+
+
+def upload_snap(args):
+    snap_path = args.snap
+    with tempfile.TemporaryDirectory() as workdir:
+        snap_yaml = _parse_snap_yaml(workdir, snap_path)
+
+        name = snap_yaml['name']
+        version = str(snap_yaml['version'])
+        summary = snap_yaml['summary']
+        description = snap_yaml['description']
+        confinement = snap_yaml['confinement']
+        architectures = snap_yaml['architectures']
+        sha3_384 = _extract_sha3_384(snap_path)
+        sha512 = _extract_sha512(snap_path)
+        binary_filesize = os.path.getsize(snap_path)
+
+        snap_yaml = _read_snap_yaml(workdir, snap_path)
+
+        logger.info("Name: %s", name)
+        logger.info("Version: %s", version)
+        logger.info("Summary: %s", summary)
+        logger.info("Description: %s", description)
+        logger.info("Confinement: %s", confinement)
+        logger.info("Architectures: %s", ', '.join(architectures))
+        logger.info("Sha3_384: %s", sha3_384)
+        logger.info("Sha512: %s", sha512)
+        logger.info("Binary filesize: %d", binary_filesize)
+
+        series = '16'
+
+        snap_id = ws.get_snap_id_for_name(name, series)
+        if snap_id is None:
+            snap_id = _generate_new_snap_id()
+
+        snap_blob = _create_snap_blob(
+            name,
+            description,
+            summary,
+        )
+        ws.register_snap_name_and_blob(
+            snap_id, name, series, snap_blob, authority='local',
+            stores=['ubuntu'])
+
+        latest_revision = ws.get_latest_revision_for_snap_id(snap_id)
+        next_revision = latest_revision + 1 if latest_revision else 1
+        binary_path = _store_snap(snap_path, name, next_revision)
+        logger.info("Binary file path: %s", binary_path)
+        registration_success = ws.create_revision(
+            snap_id,
+            next_revision,
+            architectures,
+            binary_path,
+            binary_filesize,
+            sha512,
+            sha3_384,
+            version,
+            confinement,
+            snap_yaml
+        )
+        exploded_architectures = set(architectures)
+        if 'all' in exploded_architectures:
+            exploded_architectures.remove('all')
+            exploded_architectures.update(SUPPORTED_ARCHITECTURES)
+        if registration_success and args.channel:
+            # TODO: Track/branch
+            ws.release_revision(
+                snap_id, name, series, [None, args.channel, None],
+                list(exploded_architectures), next_revision)
+
+        ws.create_or_update_assertions(
+            snap_id,
+            name,
+            series,
+            next_revision,
+            sha3_384,
+            binary_filesize
+        )
+
+
+def _parse_snap_yaml(workdir, snap_path):
+    """Extract the contents of the snap yaml file, given the path to a .snap"""
+    return yaml.safe_load(_read_snap_yaml(workdir, snap_path))
+
+
+def _read_snap_yaml(workdir, snap_path):
+    unsquash_path = os.path.join(workdir, 'unsquashed_snap')
+    subprocess.check_call(
+        ['unsquashfs', '-d', unsquash_path, snap_path],
+        stdout=subprocess.DEVNULL)
+    yaml_path = os.path.join(unsquash_path, 'meta', 'snap.yaml')
+    with open(yaml_path, 'r') as yaml_file:
+        return yaml_file.read()
+
+
+def _extract_sha3_384(file_path):
+    blocksize = 2**20
+    with open(file_path, 'rb') as snap_file:
+        hasher = hashlib.sha3_384()
+        while True:
+            buf = snap_file.read(blocksize)
+            if not buf:
+                break
+            hasher.update(buf)
+        return hasher.hexdigest()
+
+
+def _extract_sha512(file_path):
+    blocksize = 2**20
+    with open(file_path, 'rb') as snap_file:
+        hasher = hashlib.sha512()
+        while True:
+            buf = snap_file.read(blocksize)
+            if not buf:
+                break
+            hasher.update(buf)
+        return hasher.hexdigest()
+
+
+def _generate_new_snap_id():
+    """Generate a random ID to identify a snap entity.
+
+    Snap ids are a sequence of 32 random characters taken out of an alphabet
+    of 62 characters (uppercase letters + lowercase letters + numbers), for
+    a total of 310 bits of space. These unique identifiers are generated
+    centrally or delegated to known parties.
+
+    This function does not check for duplicates.
+
+    """
+    SNAP_ID_ALPHABET = string.ascii_letters + string.digits
+    return ''.join(
+            random.choice(SNAP_ID_ALPHABET) for _ in range(32))
+
+
+def _create_snap_blob(snap_name, description, summary):
+    """Generate the 'blob', as it's exported from SCA.
+
+    Many of the fields in the SCA data export aren't used in any part of the
+    snapv2 ecosystem, and have been omitted here. This script doesn't know
+    about some of the fields, so dummy data has been inserted.
+    """
+    # TODO: Fill in 'origin', 'developer_id', 'developer_name' and 'summary'
+    # somehow
+    return {
+        "origin": "developername",
+        "last_updated": None,
+        "package_name": snap_name,
+        "screenshot_url": None,
+        "developer_id": "46MtBuBZaWy3g8picgdg6YkrCQo84J46",
+        "ratings_average": 0.0,
+        "title": "snap title here",
+        "support_url": "",
+        "icon_url": None,
+        "developer_name": "developername",
+        "screenshot_urls": [],
+        "description": description,
+        "price": 0.0,
+        "translations": {},
+        "prices": {},
+        "publisher": "some publisher",
+        "summary": summary,
+    }
+
+
+def _store_snap(snap_path, snap_name, next_revision):
+    """Store a snap in the storage directory.
+
+    Returns the path that file was stored in, relative to the storage root.
+    """
+    storage_dir = get_storage_root()
+    target_filename = '%s_%d.snap' % (snap_name, next_revision)
+    target_path = os.path.join(storage_dir, target_filename)
+    shutil.copy(snap_path, target_path)
+    return '/' + os.path.relpath(target_path, storage_dir)
diff --git a/snapstore_client/tests/__init__.py b/snapstore_client/tests/__init__.py
new file mode 100644
index 0000000..1c2c9eb
--- /dev/null
+++ b/snapstore_client/tests/__init__.py
@@ -0,0 +1,14 @@
+# Copyright 2017 Canonical Ltd.
+
+import os
+from unittest import TestLoader
+
+import snapstore_client
+
+
+def test_suite():
+    loader = TestLoader()
+    start_dir = os.path.split(snapstore_client.__file__)[0]
+    top_dir = os.path.join(start_dir, os.path.pardir)
+    suite = loader.discover(start_dir, top_level_dir=top_dir)
+    return suite
diff --git a/snapstore_client/tests/test_cli.py b/snapstore_client/tests/test_cli.py
new file mode 100644
index 0000000..001159d
--- /dev/null
+++ b/snapstore_client/tests/test_cli.py
@@ -0,0 +1,64 @@
+# Copyright 2017 Canonical Ltd.
+
+import logging
+
+import fixtures
+from testtools import TestCase
+
+from snapstore_client import cli
+
+
+class ConfigureLoggingTests(TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.logger = logging.getLogger(__name__)
+        self.addCleanup(
+            self._restoreLogger,
+            self.logger, self.logger.level, list(self.logger.handlers))
+        self.stdout = self.useFixture(fixtures.StringStream('stdout')).stream
+        self.stdout.fileno = lambda: 1
+        self.useFixture(fixtures.MonkeyPatch('sys.stdout', self.stdout))
+        self.stderr = self.useFixture(fixtures.StringStream('stderr')).stream
+        self.useFixture(fixtures.MonkeyPatch('sys.stderr', self.stderr))
+
+    @staticmethod
+    def _restoreLogger(logger, level, handlers):
+        logger.setLevel(logger.level)
+        for handler in list(logger.handlers):
+            logger.removeHandler(handler)
+        for handler in handlers:
+            logger.addHandler(handler)
+
+    def test_log_levels(self):
+        self.useFixture(fixtures.MonkeyPatch('os.isatty', lambda fd: True))
+        cli.configure_logging(__name__)
+        self.assertEqual(logging.INFO, self.logger.level)
+        self.logger.debug('Debug')
+        self.logger.info('Info')
+        self.logger.warning('Warning: %s', 'smoke')
+        self.logger.error('Error: %s', 'fire')
+        self.stdout.seek(0)
+        self.assertEqual('Info\nWarning: smoke\n', self.stdout.read())
+        self.stderr.seek(0)
+        self.assertEqual('\033[0;31mError: fire\033[0m\n', self.stderr.read())
+
+    def test_requests_log_level_default(self):
+        cli.configure_logging(__name__)
+        self.assertEqual(logging.WARNING, logging.getLogger('requests').level)
+
+    def test_requests_log_level_debug(self):
+        cli.configure_logging(__name__, logging.DEBUG)
+        self.assertEqual(logging.DEBUG, logging.getLogger('requests').level)
+
+    def test_requests_log_level_error(self):
+        cli.configure_logging(__name__, logging.ERROR)
+        self.assertEqual(logging.ERROR, logging.getLogger('requests').level)
+
+    def test_no_tty(self):
+        self.useFixture(fixtures.MonkeyPatch('os.isatty', lambda fd: False))
+        self.useFixture(fixtures.EnvironmentVariable('TERM', 'xterm'))
+        cli.configure_logging(__name__)
+        self.logger.error('Error: %s', 'fire')
+        self.stderr.seek(0)
+        self.assertEqual('Error: fire\n', self.stderr.read())
diff --git a/snapstore_client/tests/test_config.py b/snapstore_client/tests/test_config.py
new file mode 100644
index 0000000..4e07079
--- /dev/null
+++ b/snapstore_client/tests/test_config.py
@@ -0,0 +1,72 @@
+# Copyright 2017 Canonical Ltd.
+
+from testtools import TestCase
+
+from snapstore_client.config import ConfigProvider
+
+
+class ConfigProviderTestCase(TestCase):
+
+    def test_override_works_for_new_section_and_option(self):
+        default = {}
+        override = {
+            'new_section': {
+                'new_option': 'new_value'
+            }
+        }
+        expected = override.copy()
+
+        provider = ConfigProvider(default)
+        provider.override_for_test(override)
+
+        self.assertEqual(expected, provider())
+
+    def test_override_works_when_adding_new_option_to_existing_section(self):
+        default = {
+            'section': {
+                'option': 'value'
+            }
+        }
+        override = {
+            'section': {
+                'new_option': 'new_value'
+            }
+        }
+        expected = {
+            'section': {
+                'option': 'value',
+                'new_option': 'new_value'
+            }
+        }
+
+        provider = ConfigProvider(default)
+        provider.override_for_test(override)
+
+        self.assertEqual(expected, provider())
+
+    def test_override_works_when_changing_existing_option(self):
+        default = {
+            'section': {
+                'option': 'value'
+            }
+        }
+        override = {
+            'section': {
+                'option': 'new_value'
+            }
+        }
+        expected = {
+            'section': {
+                'option': 'new_value',
+            }
+        }
+
+        provider = ConfigProvider(default)
+        provider.override_for_test(override)
+
+        self.assertEqual(expected, provider())
+
+
+def test_suite():
+    from unittest import TestLoader
+    return TestLoader().loadTestsFromName(__name__)
diff --git a/snapstore_client/webservices.py b/snapstore_client/webservices.py
new file mode 100644
index 0000000..dd42182
--- /dev/null
+++ b/snapstore_client/webservices.py
@@ -0,0 +1,278 @@
+# Copyright 2017 Canonical Ltd.
+
+import base64
+import binascii
+import datetime
+import json
+import logging
+import os.path
+import urllib.parse
+
+import requests
+
+from snapstore_client import config
+
+
+logger = logging.getLogger(__name__)
+
+
+def get_snap_id_for_name(snap_name, series):
+    """Return the snap_name associated with this snap_name.
+
+    Returns None if the snap_name has not been associated with a snap_id yet.
+    """
+    ident_root = config.read_config()['services']['snapident']
+    resp = requests.post(
+        urllib.parse.urljoin(ident_root, '/snaps/filter'),
+        json={
+            'filters': [{
+                'snap_name': snap_name,
+                'series': series
+            }]
+        }
+    )
+    snap_results = resp.json()['snaps']
+    if not snap_results:
+        return None
+    assert len(snap_results) == 1
+    return snap_results[0]['snap_id']
+
+
+def register_snap_name_and_blob(snap_id, snap_name, series, snap_blob,
+                                private=False, authority=None,
+                                publisher_id=None, published=True,
+                                stores=['ubuntu'], country_whitelist=None,
+                                country_blacklist=None):
+    ident_root = config.read_config()['services']['snapident']
+    data = {'snap_id': snap_id,
+            'private': private,
+            'publisher_id': snap_blob['developer_id'],
+            'snap_name': snap_name,
+            'series': series,
+            'blob': snap_blob,
+            'authority': authority,
+            'status': 'published' if published else 'unpublished',
+            'stores': stores}
+    if country_whitelist is not None:
+        data['country_whitelist'] = country_whitelist
+    if country_blacklist is not None:
+        data['country_blacklist'] = country_blacklist
+    resp = requests.post(
+        urllib.parse.urljoin(ident_root, '/snaps/update'),
+        json={'snaps': [data]})
+    if resp.status_code == 200:
+        logger.info(
+            "Snap '%s' (%s) registered for series '%s'.",
+            snap_name, snap_id, series
+        )
+        return False
+    else:
+        _print_error_message('register snap', resp)
+        return True
+
+
+def release_revision(snap_id, snap_name, series, channel, arches,
+                     revision=None, redirect_channel=None,
+                     permanent_redirect=None):
+    reqs = []
+    for arch in arches:
+        d = {
+            'snap_id': snap_id,
+            'channel': channel,
+            'architecture': arch,
+            'series': series,
+        }
+        if revision is not None:
+            d['revision'] = revision
+        else:
+            d['redirect_channel'] = redirect_channel
+            d['permanent_redirect'] = permanent_redirect
+        reqs.append(d)
+    revs_root = config.read_config()['services']['snaprevs']
+    resp = requests.post(
+        urllib.parse.urljoin(revs_root, '/channelmaps/update'),
+        json={
+            'developer_id': 'wgrant',
+            'release_requests': reqs,
+        }
+    )
+    if resp.status_code == 200:
+        logger.info(
+            "Snap '%s' (%s) revision %s released to series=%s, "
+            "channel=%s, arches=%s",
+            snap_name, snap_id, revision, series, channel,
+            ','.join(arches)
+        )
+    else:
+        _print_error_message('release revision', resp)
+
+
+def get_latest_revision_for_snap_id(snap_id):
+    """Return the latest revision for the given snap_id.
+
+    If no revisions have been published yet, this function returns None.
+    """
+    snaprevs_root = config.read_config()['services']['snaprevs']
+    resp = requests.post(
+        urllib.parse.urljoin(snaprevs_root, '/revisions/filter'),
+        json={'filters': [{'snap_id': snap_id}]}
+    )
+    revisions = [s['revision'] for s in resp.json()['revisions']]
+    return max(revisions) if revisions else None
+
+
+def create_revision(snap_id, revision, architectures, binary_path, filesize,
+                    sha512, sha3_384, version, confinement, snap_yaml):
+    """Create a snap revision with snaprevs.
+
+    Returns True on succcess, False otherwise.
+    """
+    snaprevs_root = config.read_config()['services']['snaprevs']
+    # TODO: I suspect this is supposed to be UTC time, not local time?
+    created_at = datetime.datetime.now().isoformat()
+    # TODO: figure out what we're doing with developer ids.
+    created_by = 'TODO'
+    payload = {
+        'snap_id': snap_id,
+        'revision': revision,
+        'created_at': created_at,
+        'created_by': created_by,
+        'architectures': architectures,
+        'binary_path': binary_path,
+        'binary_filesize': filesize,
+        'binary_sha512': sha512,
+        'binary_sha3_384': sha3_384,
+        'version': version,
+        'confinement': confinement,
+        'snap_yaml': snap_yaml or '',
+        'epoch': 0,
+        'type': 'app',
+    }
+    resp = requests.post(
+        urllib.parse.urljoin(snaprevs_root, '/revisions/create'),
+        json=[payload]
+    )
+    if resp.status_code != 201:
+        _print_error_message('create revision', resp)
+        return False
+
+    logger.info("Revision %s of %s created.", revision, snap_id)
+    return True
+
+
+def create_snapsections(payload):
+    logger.info('Updating sections and snapsections...')
+
+    snapfind_root = config.read_config()['services']['snapfind']
+    snapfind_snapsection_endpoint = urllib.parse.urljoin(
+        snapfind_root, '/sections/snaps')
+
+    response = requests.post(snapfind_snapsection_endpoint, json=payload)
+    if response.ok:
+        logger.info('Done.')
+    else:
+        logger.error(response.text)
+
+
+def get_assertion(root, type_, key):
+    resp = requests.get(
+        urllib.parse.urljoin(root, os.path.join('assertions', type_, *key)),
+        headers={'Accept': 'application/x.ubuntu.assertion'})
+    if resp.status_code != 200:
+        return None
+    return resp.content
+
+
+def create_or_update_assertions(
+        snap_id, snap_name, series, revision, binary_sha3_384,
+        binary_filesize):
+    assertions_root = config.read_config()['services']['assertions']
+    authority = config.read_config()['assertions']['authority']
+    timestamp = datetime.datetime.now().isoformat() + 'Z'
+
+    if get_assertion(
+            assertions_root, 'snap-declaration', (series, snap_id)) is None:
+        logger.info("Creating snap-declaration ...")
+        assertion_headers = {
+            'type': 'snap-declaration',
+            'revision': '0',
+            'authority-id': authority,
+            'publisher-id': authority,
+            'series': series,
+            'snap-id': snap_id,
+            'snap-name': snap_name,
+            'timestamp': timestamp,
+        }
+        assertion = sign_assertion(assertion_headers)
+        save_assertion(assertion)
+
+    logger.info("Creating snap-revision ...")
+    snap_sha3_384 = base64.urlsafe_b64encode(
+        binascii.a2b_hex(binary_sha3_384)).decode().rstrip("=")
+    snap_size = str(binary_filesize)
+    snap_revision = str(revision)
+    assertion_headers = {
+        'type': 'snap-revision',
+        'authority-id': authority,
+        'developer-id': authority,
+        'snap-sha3-384': snap_sha3_384,
+        'snap-id': snap_id,
+        'snap-size': snap_size,
+        'snap-revision': snap_revision,
+        'timestamp': timestamp,
+    }
+    assertion = sign_assertion(assertion_headers)
+    save_assertion(assertion)
+
+
+def save_assertion(assertion):
+    assertions_root = config.read_config()['services']['assertions']
+    request_headers = {
+        'Content-Type': 'application/x.ubuntu.assertion',
+    }
+    resp = requests.post(
+        urllib.parse.urljoin(assertions_root, 'assertions'),
+        data=assertion, headers=request_headers)
+
+    if resp.status_code != 201:
+        _print_error_message('save assertion', resp)
+        resp.raise_for_status()
+
+
+def sign_assertion(assertion_headers):
+    assertions_root = config.read_config()['services']['assertions']
+    signing_key_id = config.read_config()['assertions']['signing_key_id']
+    request_headers = {
+        'Content-Type': 'application/json',
+    }
+    data = {
+        'key-id': signing_key_id,
+        'headers': assertion_headers,
+    }
+    resp = requests.post(
+        urllib.parse.urljoin(assertions_root, 'sign'),
+        headers=request_headers, json=data)
+
+    if resp.status_code != 200:
+        _print_error_message('sign assertion', resp)
+        resp.raise_for_status()
+
+    return resp.text
+
+
+def _print_error_message(action, response):
+    """Print failure messages from other services in a standard way."""
+    logger.error("Failed to %s:", action)
+    if response.status_code == 500:
+        logger.error("Server sent 500 response.")
+    else:
+        try:
+            json_document = response.json()
+            for error in json_document['error_list']:
+                logger.error(error['message'])
+        except json.JSONDecodeError:
+            logger.error(
+                "Server sent non-json response, printed verbatim below:")
+            logger.error('=' * 20)
+            logger.error(response.content)
+            logger.error('=' * 20)