Merge lp:~snappy-dev/click/default-apparmor into lp:click

[Barry Warsaw]

snappy build needs to generate default apparmor profile automatically

Unmerged revisions

574. By Barry Warsaw on 2014-12-03

Create default apparmor profiles if the yaml doesn't explicitly name
integration:<app>:apparmor{,-profile}

With tests!

573. By Michael Vogt on 2014-12-03

merged lp:~mvo/click/yaml-manifest

572. By Michael Vogt on 2014-12-03

make dpkg output in install quiet unless "--verbose" is given

571. By Michael Vogt on 2014-12-03

merged lp:~snappy-dev/click/progressmeter (thanks to Barry Warsaw)

570. By Michael Vogt on 2014-12-03

add support for packages.yaml "binaries:"

569. By Michael Vogt on 2014-12-02

merge previous upload

568. By Michael Vogt on 2014-12-02

merged lp:~mvo/click/yaml-manifest

567. By Michael Vogt on 2014-11-28

more fixes

566. By Michael Vogt on 2014-11-28

fix test failure

565. By Michael Vogt on 2014-11-28

add support for "services" in packages.yaml

=== added directory 'acquire'
=== added symlink 'acquire/file'
=== target is u'pycurl'
=== added symlink 'acquire/ftp'
=== target is u'pycurl'
=== added symlink 'acquire/http'
=== target is u'pycurl'
=== added file 'acquire/http-udm'
--- acquire/http-udm	1970-01-01 00:00:00 +0000
+++ acquire/http-udm	2014-12-03 23:19:34 +0000
@@ -0,0 +1,28 @@
+#!/usr/bin/python3
+
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Michael Vogt <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Acquire method for ubuntu-download-manager."""
+
+from click.acquire import ClickAcquireMethodUbuntuDownloadManager
+
+from dbus.mainloop.glib import DBusGMainLoop
+DBusGMainLoop(set_as_default=True)
+
+
+if __name__ == "__main__":
+    m = ClickAcquireMethodUbuntuDownloadManager()
+    m.run()

=== added symlink 'acquire/https'
=== target is u'pycurl'
=== added file 'acquire/pycurl'
--- acquire/pycurl	1970-01-01 00:00:00 +0000
+++ acquire/pycurl	2014-12-03 23:19:34 +0000
@@ -0,0 +1,30 @@
+#!/usr/bin/python3
+
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Michael Vogt <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Acquire pycurl method click."""
+
+import signal
+import sys
+
+from click.acquire import ClickAcquireMethodPycurl
+
+
+if __name__ == "__main__":
+    # apt will send a SIGINT to all methods that do not send "Need-Cleanup: 1"
+    signal.signal(signal.SIGINT, lambda *args: sys.exit())
+    m = ClickAcquireMethodPycurl()
+    m.run()

=== added file 'click/acquire.py'
--- click/acquire.py	1970-01-01 00:00:00 +0000
+++ click/acquire.py	2014-12-03 23:19:34 +0000
@@ -0,0 +1,450 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Michael Vogt <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Acquire of Click packages."""
+
+from __future__ import print_function
+
+__metaclass__ = type
+__all__ = [
+    'ClickAcquire',
+    'ClickAcquireError',
+    'ClickAcquireMethod',
+    'ClickAcquireMethodPycurl',
+    'ClickAcquireMethodUbuntuDownloadManager',
+    'ClickAcquireStatus',
+    'ClickAcquireStatusMeter',
+    'ClickAcquireStatusText',
+    ]
+
+import os
+import math
+import select
+import subprocess
+import sys
+from textwrap import dedent
+
+from progressbar import ProgressBar, Bar, Widget
+
+import apt_pkg
+from debian.deb822 import Deb822
+import dbus
+from gi.repository import GLib
+import pycurl
+from six.moves.urllib.parse import urlparse
+
+from click.paths import acquire_methods_dir
+from click.repository import get_repository
+from click.oauth import get_oauth_headers_for_uri
+
+class ClickAcquireError(Exception):
+    """Error during acquire"""
+    pass
+
+
+def extract_one_message(lines):
+    msg = []
+    while True:
+        try:
+            line = lines.pop(0)
+        except IndexError:
+            break
+        if os.environ.get("CLICK_DEBUG_ACQUIRE", ""):
+            sys.stderr.write("[%s] raw_line: '%s'\n" % (
+                os.getpid(), line.replace("\n", "\\n")))
+        msg.append(line)
+        if len(msg) > 0 and line == "":
+            # we are done, collect all remaining "\n" and stop
+            while len(lines) > 0 and lines[0] == "":
+                lines.pop(0)
+            break
+    if len(msg) < 2:
+        return -1 , ""
+    if os.environ.get("CLICK_DEBUG_ACQUIRE", ""):
+        sys.stderr.write("[%s] msg: '%s'\n" % (os.getpid(), str(msg)))
+    number = int(msg[0].split()[0])
+    return number, "\n".join(msg)
+
+
+def _read_messages(input_file, timeout=None):
+    infd = input_file.fileno()
+    msgs = []
+    rl, wl, xl = select.select([infd], [], [], timeout)
+    if rl:
+        # FIXME: 16k message limit is arbitrary
+        buf = os.read(infd, 16*1024).decode("utf-8")
+        if os.environ.get("CLICK_DEBUG_ACQUIRE", ""):
+            sys.stderr.write("[%s] read buf: '%s'\n" % (
+                os.getpid(), buf))
+        lines = buf.split("\n")
+        while True:
+            number, msg = extract_one_message(lines)
+            if number < 0:
+                break
+            msgs.append( (number, msg) )
+    return msgs
+
+
+class ClickAcquireStatus:
+    """Base class for the status reporting """
+
+    def __init__(self):
+        self.fetched_bytes = 0
+        self.total_bytes = 1.0
+        self.uri = ""
+
+    def pulse(self):
+        pass
+
+    def done(self):
+        pass
+
+
+class ClickAcquireStatusText(ClickAcquireStatus):
+    """Text based progress reporting for the acquire progress"""
+
+    def pulse(self):
+        sys.stdout.write("\r")
+        sys.stdout.write("[%3.2f %%] Fetching %s" % (
+            (self.fetched_bytes/self.total_bytes)*100.0,
+            os.path.basename(self.uri)))
+        sys.stdout.flush()
+
+    def done(self):
+        self.pulse()
+        sys.stdout.write("\n")
+        sys.stdout.write("Done fetching %s\n" % self.uri)
+
+
+class FileSize(Widget):
+    def update(self, pbar):
+        value = pbar.maxval                         # or .currval?
+        if value < 1000:
+            return '{:3d} B '.format(int(value))
+        scale = int(math.log(value, 1000))          # or binary? e.g. MiB
+        try:
+            suffix = ' kMGTPEZY'[scale]
+        except IndexError:
+            # Should never happen, but still.
+            suffix = '!'
+        scaled_value = value // 1000 ** scale
+        return '{:3d} {:1s}B '.format(scaled_value, suffix)
+
+
+class OK(Widget):
+    def update(self, pbar):
+        if pbar.currval >= pbar.maxval:
+            return 'OK'
+        else:
+            return '  '
+
+SPACER = '    '
+
+class ClickAcquireStatusMeter(ClickAcquireStatus):
+    """Progress meter reporting for the acquire progress"""
+
+    # We have to defer creating the actual progress bar until its first use
+    # because the constructor doesn't get called with essential information
+    # (e.g. the uri and the total bytes).  These get set after the fact but
+    # before the first call to .pulse(), so initialize the object there.
+    _progress = None
+
+    def pulse(self):
+        if self.total_bytes <= 1:
+            return
+        if self._progress is None:
+            # Massage the uri.  Use the part to the right of the .click
+            # suffix, minus any version number.
+            base = os.path.basename(self.uri)
+            if base.startswith('com.ubuntu.snappy.'):
+                base = base[18:]
+            snap, _, extra = base.partition('_')
+            self._progress = ProgressBar(widgets=[
+                snap,
+                SPACER,
+                # XXX in the examples, it's unclear whether the size field
+                # should be the total size or the fetched size.  Also, decimal
+                # (MB) or binary (MiB)?  For now, we go with total size in
+                # decimal.
+                FileSize(),
+                SPACER,
+                Bar(marker='=', left='[', right=']'),
+                SPACER,
+                OK(),
+                SPACER,
+                ],
+                maxval=self.total_bytes)
+            self._progress.start()
+        self._progress.update(self.fetched_bytes)
+
+    def done(self):
+        self._progress.finish()
+
+
+# similar to Acquire/AcquireWorker
+class ClickAcquire:
+    """Acquire from remote locations"""
+
+    # default status reporting timeout
+    TIMEOUT = 0.05
+
+    # acquire method status codecs
+    M_CAPABILITIES = 100
+    M_STATUS = 102
+    M_REDIRECT = 103
+    URI_START = 200
+    URI_SUCCESS = 201
+    URI_FAILURE = 400
+
+    def __init__(self,  status=ClickAcquireStatus()):
+        self._fetch_queue = []
+        self._status = status
+
+    def _uri_acquire(self, pipe, uri, destfile):
+        cmd = dedent("""\
+        600 URI Acquire
+        URI: {uri}
+        Filename: {destfile}
+
+        """).format(uri=uri, destfile=destfile)
+        pipe.write(cmd)
+        pipe.flush()
+
+    def _redirect(self, pipe, new_uri, destfile):
+        self._uri_acquire(pipe, new_uri, destfile)
+
+    def _run_acquire_method(self, uri, destfile):
+        parsed_uri = urlparse(uri)
+        cmd = os.path.join(acquire_methods_dir, parsed_uri.scheme)
+        p = subprocess.Popen([cmd],
+            stdout=subprocess.PIPE, stdin=subprocess.PIPE,
+            universal_newlines=True)
+        while True:
+            for number, raw_message in _read_messages(p.stdout, self.TIMEOUT):
+                message = Deb822(raw_message)
+                if number == self.M_CAPABILITIES:
+                    self._uri_acquire(p.stdin, uri, destfile)
+                elif number == self.M_STATUS:
+                    pass
+                elif number == self.M_REDIRECT:
+                    self._redirect(p.stdin, message.get("New-URI"), destfile)
+                elif number == self.URI_START:
+                    self._status.uri = message.get("URI", 0)
+                    self._status.total_bytes = int(message.get("Size", 0))
+                elif number == self.URI_SUCCESS:
+                    self._status.fetched_bytes = int(message.get("Size"))
+                    self._status.done()
+                    p.stdout.close()
+                    p.stdin.close()
+                    return True
+                elif number == self.URI_FAILURE:
+                    p.stdout.close()
+                    p.stdin.close()
+                    raise ClickAcquireError("Uri failure for %s: %s" % (
+                        message.get("uri"), message.get("Message")))
+            # update progress
+            if os.path.exists(destfile):
+                self._status.fetched_bytes = os.path.getsize(destfile)
+                self._status.pulse()
+        return False
+
+    def fetch(self, uri, destfile):
+        self._run_acquire_method(uri, destfile)
+
+
+# similar to the apt AcquireMethod
+class ClickAcquireMethod:
+
+    M_CONFIGURATION = 601
+    M_FETCH = 600
+
+    VERSION = 0.1
+
+    def __init__(self):
+        s = dedent("""\
+        100 Capabilities
+        Version: {version}
+        Single-Instance: true
+
+        """).format(version=self.VERSION)
+        sys.stdout.write(s)
+        sys.stdout.flush()
+
+    def run(self):
+        while True:
+            msgs = _read_messages(sys.stdin)
+            if not msgs:
+                break
+            for number, raw_message in msgs:
+                message = Deb822(raw_message)
+                if number == self.M_CONFIGURATION:
+                    pass
+                elif number == self.M_FETCH:
+                    self.fetch(message.get("URI"), message.get("FileName"))
+
+    def uri_start(self, uri, filename, size):
+        # note that apt itself does not use "Filename" here because it
+        # will set a filename and expects the method to use it, however
+        # this will not work with UbuntuDownloadManager as it downloads
+        # to its own location
+        sys.stdout.write(dedent("""\
+        200 URI Start
+        URI: {uri}
+        Filename: {filename}
+        Size: {size}
+
+        """).format(uri=uri, filename=filename, size=size))
+        sys.stdout.flush()
+
+    def uri_done(self, uri, filename):
+        # bug in python-apt
+        hashes = apt_pkg.Hashes(filename.encode("utf-8"))
+        sys.stdout.write(dedent("""\
+        201 URI Done
+        URI: {uri}
+        Filename: {filename}
+        Size: {size}
+        Sha256-Hash: {sha256hash}
+
+        """).format(uri=uri, filename=filename, size=os.path.getsize(filename),
+                    sha256hash=hashes.sha256))
+        sys.stdout.flush()
+
+    def fail(self, uri, err="unknown error"):
+        sys.stdout.write(dedent("""\
+        400 URI Failure
+        URI: {uri}
+        Message: {err}
+
+        """).format(uri=uri, err=err))
+        sys.stdout.flush()
+
+    def fetch(self, uri, destfile):
+        pass
+
+
+class ClickAcquireMethodPycurl(ClickAcquireMethod):
+
+    def _write_to_file_callback(self, data):
+        self._destfile_fp.write(data)
+        return len(data)
+
+    def _progress_info(self, dltotal, dlnow, ultotal, ulnow):
+        if dltotal > 0 and not self._uri_start_reported:
+            self.uri_start(
+                self.uri, self._destfile_fp.name, int(dltotal))
+            self._uri_start_reported = True
+
+    def fetch(self, uri, destfile):
+        self._uri_start_reported = False
+        self.uri = uri
+        self._destfile_fp = open(destfile, "wb")
+        curl = pycurl.Curl()
+        curl.setopt(pycurl.URL, uri)
+        curl.setopt(pycurl.WRITEFUNCTION, self._write_to_file_callback)
+        curl.setopt(pycurl.NOPROGRESS, 0)
+        curl.setopt(pycurl.PROGRESSFUNCTION, self._progress_info)
+        curl.setopt(pycurl.FOLLOWLOCATION, 1)
+        curl.setopt(pycurl.MAXREDIRS, 5)
+        curl.setopt(pycurl.FAILONERROR, 1)
+        # timeout 120s for conenction
+        curl.setopt(pycurl.CONNECTTIMEOUT, 120)
+        # timeout if the speed is 120s below 10 bytes/sec
+        curl.setopt(pycurl.LOW_SPEED_LIMIT, 10);
+        curl.setopt(pycurl.LOW_SPEED_TIME, 120);
+        # ssl: no need to set any option here,
+        #       SSL_VERIFYPEER=1, SSL_VERIFYHOST=2,
+        #       CAINFO=/etc/ssl/certs/ca-certificates.crt
+        #      by default in libcurl3 these days
+
+        # FIXME: duplicated code with network.py:http_request
+        # add auth header
+        repo = get_repository()
+        if repo.credentials:
+            headers = get_oauth_headers_for_uri(uri, repo.credentials)
+            header_list = []
+            for k, v in headers.items():
+                header_list.append("%s: %s" % (k, v))
+            curl.setopt(pycurl.HTTPHEADER, header_list)
+        # do it
+        try:
+            curl.perform()
+            self._destfile_fp.close()
+            self.uri_done(uri, destfile)
+        except pycurl.error as e:
+            self.fail(self.uri, e.args)
+            self._destfile_fp.close()
+
+
+class ClickAcquireMethodUbuntuDownloadManager(ClickAcquireMethod):
+
+    MANAGER_PATH = '/'
+    MANAGER_IFACE = 'com.canonical.applications.DownloadManager'
+    DOWNLOAD_IFACE = 'com.canonical.applications.Download'
+
+    def __init__(self):
+        super(ClickAcquireMethodUbuntuDownloadManager, self).__init__()
+        self.bus = dbus.SessionBus()
+        self.loop = GLib.MainLoop()
+
+    def _created_callback(self, dbus_path):
+        pass
+
+    def _finished_callback(self, path, loop):
+        self.down_path = path
+        loop.quit()
+
+    def _progress_callback(self, total, progress):
+        #print('Progress is %s/%s' % (progress, total))
+        if not self._started:
+            # FIXME: we need the tmpfile path from udm
+            tmpfile = "meep"
+            self.uri_start(self.uri, tmpfile, total)
+            self._started = True
+
+    def fetch(self, uri, destfile):
+        self.uri = uri
+        self._started = False
+        manager = self.bus.get_object(
+            'com.canonical.applications.Downloader', self.MANAGER_PATH)
+        manager_dev_iface = dbus.Interface(
+            manager, dbus_interface=self.MANAGER_IFACE)
+        manager_dev_iface.connect_to_signal(
+            'downloadCreated', self._created_callback)
+        down_path = manager_dev_iface.createDownload(
+            (uri, "", "", dbus.Dictionary({}, signature="sv"),
+             dbus.Dictionary({}, signature="ss")))
+        download1 = self.bus.get_object('com.canonical.applications.Downloader',
+            down_path)
+        download_dev_iface1 = dbus.Interface(
+            download1, dbus_interface=self.DOWNLOAD_IFACE)
+        download_dev_iface1.connect_to_signal(
+            'progress', self._progress_callback)
+        download_dev_iface1.connect_to_signal(
+            'finished',
+            lambda path: self._finished_callback(path, self.loop))
+        download_dev_iface1.start()
+        self.loop.run()
+        # FIXME error handling, i.e. send self.fail()
+        self.uri_done(uri, self.down_path)
+
+
+if __name__ == "__main__":
+    log = ClickAcquireStatusText()
+    acq = ClickAcquire(log)
+    uri = sys.argv[1]
+    if not acq.fetch(uri, os.path.basename(uri)):
+        sys.exit(1)
+    sys.exit(0)

=== modified file 'click/build.py'
--- click/build.py	2014-05-05 13:10:19 +0000
+++ click/build.py	2014-12-03 23:19:34 +0000
@@ -45,6 +45,12 @@
     # "click build" is required to work with only the Python standard library.
     pass
 
+try:
+    import yaml
+    HAVE_YAML=True
+except ImportError:
+    HAVE_YAML=False
+
 from click import osextras
 from click.arfile import ArFile
 from click.preinst import static_preinst
@@ -56,6 +62,18 @@
 )
 
 
+APPARMOR_DEFAULT_TEMPLATE = """\
+{
+    "template": "default",
+    "policy_groups": [
+        "networking"
+    ],
+    "policy_vendor": "ubuntu-snappy",
+    "policy_version": 1.3
+}
+"""
+
+
 @contextlib.contextmanager
 def make_temp_dir():
     temp_dir = tempfile.mkdtemp(prefix="click")
@@ -83,24 +101,110 @@
 class ClickBuilderBase:
     def __init__(self):
         self.file_map = {}
+        self.autogen_apparmor = []
 
     def add_file(self, source_path, dest_path):
         self.file_map[source_path] = dest_path
 
     def read_manifest(self, manifest_path):
+        if manifest_path.endswith(".yaml"):
+            self._read_manifest_snappy(manifest_path)
+        elif manifest_path.endswith(".json"):
+            self._read_manifest_json(manifest_path)
+        self._remove_reserved_keys()
+
+    def _read_manifest_snappy(self, manifest_path):
+        """The "new" snappy yaml based format"""
+        if not HAVE_YAML:
+            raise Exception("Please install python3-yaml")
+        with io.open(manifest_path, encoding="UTF-8") as manifest:
+            try:
+                self.manifest = yaml.safe_load(manifest)
+            except Exception as e:
+                raise ClickBuildError(
+                    "Error reading manifest from %s: %s" % (manifest_path, e))
+        # adjust differences
+        self.manifest["version"] = str(self.manifest["version"])
+        readme = os.path.join(os.path.dirname(manifest_path), "readme.md")
+        with io.open(readme) as f:
+            self.manifest["title"] = f.readline().strip()
+            # FIXME: read paragraph here instead of just the second line
+            self.manifest["description"] = f.readline()
+        # icon is mandatory
+        if "icon" not in self.manifest:
+            raise ClickBuildError(
+                "Missing 'icon:' tag in '%s'" % manifest_path)
+        # renamed fields in snappy
+        if not "framework" in self.manifest:
+            self.manifest["framework"] = ""
+        for click_name, snappy_name in (("framework", "frameworks"),
+                                        ("maintainer", "vendor"),
+                                        ("hooks", "integration")):
+            # FIXME: warn when the old names are used
+            if snappy_name in self.manifest:
+                self.manifest[click_name] = self.manifest[snappy_name]
+                # its just a rename, no need to keep the old name around
+                del self.manifest[snappy_name]
+
+        # deal with new "services" field
+        hooks = self.manifest.get("hooks", {})
+        for service in self.manifest.get("services", []):
+            name = service["name"]
+            current_hook = hooks.get(name, {})
+            snappy_systemd = "{}.snappy-systemd".format(name)
+            description = service.get(
+                "description",
+                self.manifest.get("description", "no description"))
+            systemd_path = os.path.join(
+                os.path.dirname(manifest_path), snappy_systemd)
+            with open(systemd_path, "w") as fp:
+                yaml.dump({"description": description,
+                           "start": service["start"],
+                          }, fp)
+            current_hook["snappy-systemd"] = "meta/"+snappy_systemd
+            hooks[name] = current_hook
+            # Is there an explicit apparmor hook?  If so, use it otherwise
+            # generate a default one.
+            if (    'apparmor' not in current_hook and
+                    'apparmor-profile' not in current_hook):
+                template_path = os.path.join(
+                    'meta', '{}.apparmor'.format(name))
+                current_hook['apparmor'] = template_path
+                self.autogen_apparmor.append(template_path)
+        self.manifest["hooks"] = hooks
+        # cleanup
+        if "services" in self.manifest:
+            del self.manifest["services"]
+
+        # deal with the new "binaries" field and generate one app for each
+        hooks = self.manifest.get("hooks", {})
+        for binary in self.manifest.get("binaries", []):
+            base_name = os.path.basename(binary["name"])
+            current_hook = hooks.get(base_name, {})
+            current_hook["bin-path"] = binary["name"]
+            hooks[base_name] = current_hook
+        self.manifest["hooks"] = hooks
+        # cleanup
+        if "binaries" in self.manifest:
+            del self.manifest["binaries"]
+
+    def _read_manifest_json(self, manifest_path):
+        """Compat with the "old" click json format"""
         with io.open(manifest_path, encoding="UTF-8") as manifest:
             try:
                 self.manifest = json.load(manifest)
             except Exception as e:
                 raise ClickBuildError(
                     "Error reading manifest from %s: %s" % (manifest_path, e))
-            keys = sorted(self.manifest)
-            for key in keys:
-                if key.startswith("_"):
-                    print(
-                        "Ignoring reserved dynamic key '%s'." % key,
-                        file=sys.stderr)
-                    del self.manifest[key]
+
+    def _remove_reserved_keys(self):
+        keys = sorted(self.manifest)
+        for key in keys:
+            if key.startswith("_"):
+                print(
+                    "Ignoring reserved dynamic key '%s'." % key,
+                    file=sys.stderr)
+                del self.manifest[key]
 
     @property
     def name(self):
@@ -135,6 +239,7 @@
     # TODO: This should be configurable, or at least extensible.
     _ignore_patterns = [
         "*.click",
+        "*.snap",
         ".*.sw?",
         "*~",
         ",,*",
@@ -234,6 +339,11 @@
             if "framework" in self.manifest:
                 self._validate_framework(self.manifest["framework"])
 
+            for template_path in self.autogen_apparmor:
+                path = os.path.join(root_path, template_path)
+                with io.open(path, 'w', encoding='utf-8') as fp:
+                    fp.write(APPARMOR_DEFAULT_TEMPLATE)
+
             du_output = subprocess.check_output(
                 ["du", "-k", "-s", "--apparent-size", "."],
                 cwd=temp_dir, universal_newlines=True).rstrip("\n")
@@ -267,7 +377,9 @@
                         self.manifest, ensure_ascii=False, sort_keys=True,
                         indent=4, separators=(",", ": ")),
                     file=manifest)
-            os.unlink(full_manifest_path)
+            # FIXME: ugly!
+            if not full_manifest_path.endswith("package.yaml"):
+                os.unlink(full_manifest_path)
             os.chmod(real_manifest_path, 0o644)
 
             md5sums_path = os.path.join(control_dir, "md5sums")

=== modified file 'click/commands/__init__.py'
--- click/commands/__init__.py	2014-05-20 09:03:05 +0000
+++ click/commands/__init__.py	2014-12-03 23:19:34 +0000
@@ -29,8 +29,11 @@
     "info",
     "install",
     "list",
+    "login",
     "pkgdir",
     "register",
+    "search",
+    "update",
     "unregister",
     "verify",
     )

=== modified file 'click/commands/info.py'
--- click/commands/info.py	2014-10-07 08:56:03 +0000
+++ click/commands/info.py	2014-12-03 23:19:34 +0000
@@ -28,6 +28,10 @@
 
 from click.install import DebFile
 from click.json_helpers import json_object_to_python
+from click.repository import (
+    get_repository,
+    ClickRepositoryError,
+)
 
 
 def _load_manifest(manifest_file):
@@ -73,14 +77,55 @@
         "--user", metavar="USER",
         help="look up PACKAGE-NAME for USER (if you have permission; "
              "default: current user)")
+    parser.add_option(
+        "--repository", default=False, action="store_true",
+        help="Search in remote repository only")
+    parser.add_option(
+        "--no-repository", default=False, action="store_true",
+        help="Never search in a remote repository ")
     options, args = parser.parse_args(argv)
+    pkgname = args[0]
     if len(args) < 1:
         parser.error("need file name")
-    try:
-        manifest = get_manifest(options, args[0])
-    except Exception as e:
-        print(e, file=sys.stderr)
-        return 1
+
+    # see if its available locally: pkgname, click-path, path-to-unpacked-click
+    manifest = None
+    if not options.repository:
+        try:
+            manifest = get_manifest(options, pkgname)
+        except Exception as e:
+            pass
+
+    # now check remote
+    if manifest is None and not options.no_repository:
+        repo = get_repository()
+        try:
+            details = repo.details(pkgname)
+            manifest = {k: details.get(k)
+                        # FIXME: this list is a big ugly
+                        for k in ('name',
+                                  'download_url',
+                                  'title',
+                                  'description',
+                                  'binary_filesize',
+                                  'publisher',
+                                  'framework',
+                                  'version',
+                                  'last_updated',
+                                  'architecture',
+                                  'department',
+                                  'changelog',
+                                  'ratings_average',
+                                  'price',
+                                  'keywords',
+                                  'license',
+                              )}
+            manifest["_repository"] = repo.description
+        except ClickRepositoryError as e:
+            print(
+                "Can not get details for %s:%s" % (pkgname, e), file=sys.stderr)
+            return 1
+
     json.dump(
         manifest, sys.stdout, ensure_ascii=False, sort_keys=True, indent=4,
         separators=(",", ": "))

=== modified file 'click/commands/install.py'
--- click/commands/install.py	2014-09-10 12:28:49 +0000
+++ click/commands/install.py	2014-12-03 23:19:34 +0000
@@ -18,12 +18,33 @@
 from __future__ import print_function
 
 from optparse import OptionParser
+import os
 import sys
+import tempfile
 from textwrap import dedent
 
+from six.moves.urllib.parse import urlparse
+
 from gi.repository import Click
 
+from click.acquire import (
+    ClickAcquire,
+    ClickAcquireStatusMeter,
+)
 from click.install import ClickInstaller, ClickInstallerError
+from click.repository import (
+    get_repository,
+)
+
+def download_click(package_uri):
+    t = tempfile.NamedTemporaryFile()
+    package_path = t.name
+    log = ClickAcquireStatusMeter()
+    acq = ClickAcquire(log)
+    acq.fetch(package_uri, package_path)
+    # return the tempfile so that it does not get deleted when we
+    # go out of scope here
+    return t
 
 
 def run(argv):
@@ -46,6 +67,9 @@
     parser.add_option(
         "--allow-unauthenticated", default=False, action="store_true",
         help="allow installing packages with no signatures")
+    parser.add_option(
+        "--verbose", default=False, action="store_true",
+        help="be more verbose on install")
     options, args = parser.parse_args(argv)
     if len(args) < 1:
         parser.error("need package file name")
@@ -53,13 +77,28 @@
     db.read(db_dir=None)
     if options.root is not None:
         db.add(options.root)
-    package_path = args[0]
+    package_uri = args[0]
     installer = ClickInstaller(
         db=db, force_missing_framework=options.force_missing_framework,
         allow_unauthenticated=options.allow_unauthenticated)
+    parsed_uri = urlparse(package_uri)
+    if parsed_uri.scheme != "":
+        t = download_click(package_uri)
+        package_path = t.name
+    elif os.path.exists(package_uri):
+        package_path = package_uri
+    else:
+        repo = get_repository()
+        details = repo.details(package_uri)
+        if repo.credentials:
+            t = download_click(details["download_url"])
+        else:
+            t = download_click(details["anon_download_url"])
+        package_path = t.name
     try:
         installer.install(
-            package_path, user=options.user, all_users=options.all_users)
+            package_path, user=options.user, all_users=options.all_users,
+            quiet=not options.verbose)
     except ClickInstallerError as e:
         print("Cannot install %s: %s" % (package_path, e), file=sys.stderr)
         return 1

=== added file 'click/commands/login.py'
--- click/commands/login.py	1970-01-01 00:00:00 +0000
+++ click/commands/login.py	2014-12-03 23:19:34 +0000
@@ -0,0 +1,53 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Michael Vogt
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Log into for Click repository"""
+
+from __future__ import print_function
+
+import getpass
+from optparse import OptionParser
+import sys
+from textwrap import dedent
+
+from click.repository import (
+    get_repository,
+    ClickLoginTwoFactorRequired,
+    ClickRepositoryError,
+)
+
+
+def run(argv):
+    parser = OptionParser(dedent("""\
+        %prog login user-name
+
+        """))
+    options, args = parser.parse_args(argv)
+    if len(args) < 1:
+        parser.error("need package file name")
+    repo = get_repository()
+    username = args[0]
+    print("Please enter the password for '%s'" %  username)
+    password = getpass.getpass()
+    try:
+        repo.login(username, password, store_on_disk=True)
+    except ClickLoginTwoFactorRequired:
+        otp = getpass.getpass("2fa: ")
+        repo.login(username, password, otp, store_on_disk=True)
+    except ClickRepositoryError as e:
+        print("login failed %s" % e, file=sys.stderr)
+        return 1
+
+    return 0

=== added file 'click/commands/search.py'
--- click/commands/search.py	1970-01-01 00:00:00 +0000
+++ click/commands/search.py	2014-12-03 23:19:34 +0000
@@ -0,0 +1,46 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Michael Vogt
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Search for Click packages"""
+
+from __future__ import print_function
+
+from optparse import OptionParser
+import sys
+from textwrap import dedent
+
+from click.repository import (
+    get_repository,
+    ClickRepositoryError,
+)
+
+
+def run(argv):
+    parser = OptionParser(dedent("""\
+        %prog search search-term(s)
+
+        """))
+    options, args = parser.parse_args(argv)
+    if len(args) < 1:
+        parser.error("need package file name")
+    repo = get_repository()
+    try:
+        result = repo.search(args[0])
+    except ClickRepositoryError as e:
+        print("Search failed %s" % e, file=sys.stderr)
+        return 1
+    for app in result:
+        print("%s - %s" % (app["name"], app["title"]))
+    return 0

=== added file 'click/commands/update.py'
--- click/commands/update.py	1970-01-01 00:00:00 +0000
+++ click/commands/update.py	2014-12-03 23:19:34 +0000
@@ -0,0 +1,108 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Michael Vogt
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Update Click packages"""
+
+from __future__ import print_function
+
+from optparse import OptionParser
+import sys
+import tempfile
+from textwrap import dedent
+
+from prettytable import PrettyTable, PLAIN_COLUMNS
+
+from gi.repository import Click
+from click.acquire import (
+    ClickAcquire,
+    ClickAcquireStatusText,
+)
+from click.install import ClickInstaller
+
+from click.repository import (
+    get_repository,
+    ClickRepositoryError,
+)
+
+
+def run(argv):
+    parser = OptionParser(dedent("""\
+        %prog update
+
+        """))
+    parser.add_option(
+        "--list", default=False, action="store_true",
+        help="Just list the update")
+    parser.add_option(
+        "--machine-readable", default=False, action="store_true",
+        help="output in machine readable form")
+    parser.add_option(
+        "--user", metavar="USER", help="register package for USER")
+    parser.add_option(
+        "--all-users", default=False, action="store_true",
+        help="register package for all users")
+    options, args = parser.parse_args(argv)
+    repo = get_repository()
+    try:
+        all_updates = repo.get_upgradable()
+    except ClickRepositoryError as e:
+        print("Update failed: %s" % e, file=sys.stderr)
+        return 1
+    if not all_updates:
+        return 0
+
+    if len(args) > 0:
+        updates = [up for up in all_updates if up[0]["name"] in args]
+    else:
+        updates = all_updates
+
+    if options.machine_readable:
+        for (current, new) in updates:
+            print("%s|%s|%s" % (
+                new["name"], current["version"], new["version"]))
+    elif options.list:
+        t = PrettyTable(["Part","Installed", "Available"])
+        t.set_style(PLAIN_COLUMNS)
+        t.align["Part"] = "l"
+        for (current, new) in updates:
+            t.add_row((new["name"], current["version"], new["version"]))
+        print(t)
+    else:
+        db = Click.DB()
+        db.read(db_dir=None)
+        installer = ClickInstaller(db=db)
+        for (current, new) in updates:
+            if repo.credentials:
+                package_uri = new["download_url"]
+            else:
+                package_uri = new["anon_download_url"]
+            print(package_uri)
+            # FIXME: duplication from commands/install.py
+            t = tempfile.NamedTemporaryFile()
+            package_path = t.name
+            log = ClickAcquireStatusText()
+            acq = ClickAcquire(log)
+            acq.fetch(package_uri, package_path)
+            installer.install(
+                package_path, user=options.user, all_users=options.all_users)
+        # output what just happend
+        t = PrettyTable(["Part","Installed"])
+        t.set_style(PLAIN_COLUMNS)
+        t.align["Part"] = "l"
+        for (current, new) in updates:
+            t.add_row((new["name"], new["version"]))
+        print(t)
+
+    return 0

=== modified file 'click/install.py'
--- click/install.py	2014-09-10 11:50:18 +0000
+++ click/install.py	2014-12-03 23:19:34 +0000
@@ -16,6 +16,7 @@
 """Installing Click packages."""
 
 from __future__ import print_function
+from hashlib import sha512
 
 __metaclass__ = type
 __all__ = [
@@ -76,6 +77,12 @@
 apt_pkg.init_system()
 
 
+def _dpkg_architecture():
+    return subprocess.check_output(
+        ["dpkg", "--print-architecture"],
+        universal_newlines=True).rstrip("\n")
+
+
 class DebsigVerifyError(Exception):
     pass
 
@@ -145,11 +152,6 @@
             return os.path.abspath(preload)
         return preload_path
 
-    def _dpkg_architecture(self):
-        return subprocess.check_output(
-            ["dpkg", "--print-architecture"],
-            universal_newlines=True).rstrip("\n")
-
     def extract(self, path, target):
         command = ["dpkg-deb", "-R", path, target]
         with open(path, "rb") as fd:
@@ -263,7 +265,7 @@
             if check_arch:
                 architecture = manifest.get("architecture", "all")
                 if architecture != "all":
-                    dpkg_architecture = self._dpkg_architecture()
+                    dpkg_architecture = _dpkg_architecture()
                     if isinstance(architecture, list):
                         if dpkg_architecture not in architecture:
                             raise ClickInstallerAuditError(
@@ -346,8 +348,27 @@
             os.mkdir(os.path.join(admin_dir, "info"))
             os.mkdir(os.path.join(admin_dir, "updates"))
             os.mkdir(os.path.join(admin_dir, "triggers"))
-
-    def _unpack(self, path, user=None, all_users=False):
+    def _add_checksum_to_manifest(self, path, inst_dir, package_name):
+        with open(path, "rb") as fd:
+            checksum = sha512(fd.read()).hexdigest()
+
+        admin_dir = os.path.join(inst_dir, ".click")
+        manifest_file = '{}.manifest'.format(package_name)
+        manifest_path = os.path.join(admin_dir, 'info', manifest_file)
+
+        with open(manifest_path) as fd:
+            manifest = json.load(fd)
+            manifest['checksum-sha512'] = checksum
+
+            tmp_file = '{}.tmp'.format(manifest_path)
+            with open(tmp_file, 'w') as manifest_fd:
+                # indent is for pretty-printing.
+                json.dump(manifest, fp=manifest_fd, indent=8)
+
+            # overwrite
+            os.rename(tmp_file, manifest_path)
+
+    def _unpack(self, path, user=None, all_users=False, quiet=True):
         package_name, package_version = self.audit(path, check_arch=True)
 
         # Is this package already unpacked in an underlay (non-topmost)
@@ -401,9 +422,24 @@
             kwargs = {}
             if sys.version >= "3.2":
                 kwargs["pass_fds"] = (fd.fileno(),)
-            subprocess.check_call(
-                command, preexec_fn=partial(self._install_preexec, inst_dir),
-                env=env, **kwargs)
+            if quiet:
+                fn = subprocess.check_output
+                kwargs["stderr"] = subprocess.STDOUT
+            else:
+                fn = subprocess.check_call
+            try:
+                fn(command,
+                    preexec_fn=partial(self._install_preexec, inst_dir),
+                    env=env, universal_newlines=True,
+                    **kwargs)
+            except subprocess.CalledProcessError as e:
+                logging.error("%s failed with exit_code %s:\n%s" % (
+                    command, e.returncode, e.output))
+                raise
+        # Now that the package has been installed, add the .click's
+        # checksum to the manifest.
+        self._add_checksum_to_manifest(path, inst_dir, package_name)
+        # ensure the permissions
         for dirpath, dirnames, filenames in os.walk(inst_dir):
             for entry in dirnames + filenames:
                 entry_path = os.path.join(dirpath, entry)
@@ -441,9 +477,9 @@
 
         return package_name, package_version, old_version
 
-    def install(self, path, user=None, all_users=False):
+    def install(self, path, user=None, all_users=False, quiet=True):
         package_name, package_version, old_version = self._unpack(
-            path, user=user, all_users=all_users)
+            path, user=user, all_users=all_users, quiet=quiet)
 
         if user is not None or all_users:
             if all_users:

=== added file 'click/network.py'
--- click/network.py	1970-01-01 00:00:00 +0000
+++ click/network.py	2014-12-03 23:19:34 +0000
@@ -0,0 +1,72 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Michael Vogt <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import pycurl
+
+from io import BytesIO, StringIO
+import os
+
+
+class HttpResponse:
+    """Http Response with status and data members"""
+
+    def __init__(self, status, data):
+        self.status = status
+        self.data = data
+
+    def __unicode__(self):
+        return self.data
+
+
+# similar to httplib2.Http().request()
+def http_request(url, data=None, headers=None):
+    """Send a http request to the given url and return (response, data)
+
+    param url  The url to send the request to
+    param data  (Optional) data to POST to the url
+    param headers  (Optional) headers to include with the request
+    return  A tuple of (response, body)
+    rtype  (HttpResponse, bytes)
+    """
+    def write_header(line):
+        header.write(line.decode("utf-8"))
+        return len(line)
+    def write_body(data):
+        body.write(data)
+        return len(data)
+    def post_data(num):
+        return data_stream.read(num)
+    header = StringIO()
+    body = BytesIO()
+    curl = pycurl.Curl()
+    curl.setopt(curl.URL, url)
+    if os.environ.get("CLICK_DEBUG_HTTP", ""):
+        curl.setopt(curl.VERBOSE, 1)
+    curl.setopt(pycurl.WRITEFUNCTION, write_body)
+    curl.setopt(pycurl.HEADERFUNCTION, write_header)
+    if data is not None:
+        data_stream = BytesIO(data)
+        curl.setopt(pycurl.READFUNCTION, post_data)
+        curl.setopt(pycurl.POSTFIELDSIZE, len(data))
+        curl.setopt(pycurl.POST, 1)
+    if headers is not None:
+        header_list = []
+        for k, v in headers.items():
+            header_list.append("%s: %s" % (k, v))
+        curl.setopt(pycurl.HTTPHEADER, header_list)
+    # ssl: no need to set extra options, pycurl has sensible defaults
+    curl.perform()
+    resp = HttpResponse(curl.getinfo(pycurl.HTTP_CODE), header.getvalue())
+    return resp, body.getvalue()

=== added file 'click/oauth.py'
--- click/oauth.py	1970-01-01 00:00:00 +0000
+++ click/oauth.py	2014-12-03 23:19:34 +0000
@@ -0,0 +1,29 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Michael Vogt <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import oauthlib.oauth1
+
+
+def get_oauth_headers_for_uri(uri, token):
+    client = oauthlib.oauth1.Client(token["consumer_key"],
+                                    token["consumer_secret"],
+                                    token["token_key"],
+                                    token["token_secret"])
+    new_uri, headers, body = client.sign(uri)
+    if new_uri != uri:
+        raise Exception("uri change not supported")
+    if body is not None:
+        raise Exception("body != None not supported")
+    return headers

=== modified file 'click/paths.py.in'
--- click/paths.py.in	2014-05-08 15:48:01 +0000
+++ click/paths.py.in	2014-12-03 23:19:34 +0000
@@ -14,6 +14,9 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """Click paths."""
+import os
 
 preload_path = "@pkglibdir@/libclickpreload.so"
 frameworks_dir = "@pkgdatadir@/frameworks"
+acquire_methods_dir = (os.environ.get("CLICK_ACQUIRE_METHODS_DIR", "") or
+                       "@pkglibdir@/acquire")

=== added file 'click/repository.py'
--- click/repository.py	1970-01-01 00:00:00 +0000
+++ click/repository.py	2014-12-03 23:19:34 +0000
@@ -0,0 +1,224 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Michael Vogt
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Search Click packages."""
+
+from __future__ import print_function
+
+__metaclass__ = type
+__all__ = [
+    'ClickRepository',
+    'ClickRepositoryError',
+    ]
+
+import json
+import platform
+import os
+
+import apt_pkg
+from gi.repository import Click
+from six.moves.urllib.parse import quote as url_quote
+
+from click.json_helpers import json_array_to_python
+
+import click.install
+from click.network import http_request
+from click.oauth import get_oauth_headers_for_uri
+
+
+class ClickLoginTwoFactorRequired(Exception):
+    pass
+
+
+class ClickRepositoryError(Exception):
+    pass
+
+
+def get_repository():
+    """Factory to get a click repository for the current distro"""
+    distro = platform.dist()[0]
+    if distro.startswith('Ubuntu'):
+        return ClickRepositoryAppsUbuntuCom()
+    raise ClickRepositoryError("No repository for distribution '%s'" % distro)
+
+
+class ClickRepository:
+
+    def search(self, search_string):
+        """Search the repository for the given search string
+
+        Returns a list of click manifest from the repository
+        """
+        raise NotImplementedError()
+
+    def get_upgradable(self):
+        """Get all click packages where a newer version is available
+
+        Returns a list of (old_manifest, new_manifest) pairs
+        """
+        raise NotImplementedError()
+
+    def details(self, name):
+        """Get the details for the given click name
+
+        Returns a click manifest
+        """
+        raise NotImplementedError()
+
+    def login(self, username, password, otp=None, store_on_disk=True):
+        """Log into the given repository with username/password"""
+        raise NotImplementedError()
+
+    @property
+    def description(self):
+        """The description of the repository as a URL"""
+        raise NotImplementedError()
+
+    @property
+    def credentials(self):
+        """The credentials for the repository (or None)"""
+        return None
+
+
+class ClickRepositoryAppsUbuntuCom(ClickRepository):
+    """Interface to click repository from apps.ubuntu.com"""
+
+    SEARCH_URI = "https://search.apps.ubuntu.com/api/v1/search?q=%s"
+    DETAILS_URI = "https://search.apps.ubuntu.com/api/v1/package/%s"
+    BULK_APPS_URI = "https://myapps.developer.ubuntu.com/dev/api/"\
+                    "click-metadata/"
+
+    TOKEN_FILE = os.path.expanduser("~/.config/click/ubuntu-sso.json")
+
+    def _http_request(self, uri, *args, **kwargs):
+        """Send a oauth signed http request to the repo server"""
+        if self.credentials:
+            token = self.credentials
+            headers = kwargs.pop("headers", {})
+            headers.update(get_oauth_headers_for_uri(uri, token))
+            kwargs["headers"] = headers
+        return http_request(uri, *args, **kwargs)
+
+    @property
+    def credentials(self):
+        if os.path.exists(self.TOKEN_FILE):
+            with open(self.TOKEN_FILE) as f:
+                return json.load(f)
+        return None
+
+    @property
+    def description(self):
+        return "https://myapps.developer.ubuntu.com/dev/click-apps/"
+
+    def search(self, search_term):
+        result = []
+        url = self.SEARCH_URI % url_quote(search_term)
+        if not self.credentials:
+            url += ",allow_unauthenticated:True"
+        frameworks = ["%s-%s" % (f.get_base_name(), f.get_base_version())
+                      for f in Click.Framework.get_frameworks()]
+        headers = {
+            "Accept": "application/hal+json",
+            "X-Ubuntu-Frameworks": ",".join(frameworks),
+            "X-Ubuntu-Architecture": click.install._dpkg_architecture(),
+        }
+        resp, raw_content = http_request(url, headers=headers)
+        content = raw_content.decode("utf-8")
+        if resp.status != 200:
+            raise ClickRepositoryError(content)
+        data = json.loads(content)
+        if not "_embedded" in data:
+            return result
+        for item in data["_embedded"]["clickindex:package"]:
+            result.append(item)
+        return result
+
+    def details(self, name):
+        resp, raw_content = self._http_request(
+            self.DETAILS_URI % url_quote(name))
+        content = raw_content.decode("utf-8")
+        if resp.status != 200:
+            raise ClickRepositoryError(content)
+        return json.loads(content)
+
+    def get_upgradable(self):
+        result = []
+        db = Click.DB()
+        db.read(db_dir=None)
+        registry = Click.User.for_user(db, name=None)
+        # build the dict of installed apps for the POST
+        current_apps = {}
+        for app in json_array_to_python(registry.get_manifests()):
+            current_apps[app["name"]] = app
+        # if we have nothing installed, do not query the server
+        if not current_apps:
+            return result
+        json_post_data = json.dumps({
+            "name": list(current_apps.keys()),
+        }).encode("utf-8")
+        # query the API
+        resp, raw_content = http_request(
+            self.BULK_APPS_URI,
+            json_post_data,
+            headers={"content-type": "application/json"})
+        content = raw_content.decode("utf-8")
+        if resp.status != 200:
+            raise ClickRepositoryError(
+                "Failed to get upgradable packages: %s" % resp.content)
+        # return a list of (old, new) pairs to the caller
+        server_apps = json.loads(content)
+        result = []
+        for new in server_apps:
+            current = current_apps[new["name"]]
+            if apt_pkg.version_compare(current["version"], new["version"]) < 0:
+                result.append( (current, new) )
+        return result
+
+    def login(self, username, password, otp=None, store_on_disk=True):
+        token_name = "click"
+        token = self._get_oauth_token(username, password, token_name, otp)
+
+        if store_on_disk:
+            Click.ensuredir(os.path.dirname(self.TOKEN_FILE))
+            with open(self.TOKEN_FILE, "w") as f:
+                os.chmod(f.name, 0o600)
+                f.write(json.dumps(token))
+
+        return token
+
+    def _get_oauth_token(self, username, password, token_name, otp=None):
+        UBUNTUONE_API_BASE = "https://login.ubuntu.com/api/v2"
+        UBUNTUONE_OAUTH_API = UBUNTUONE_API_BASE + "/tokens/oauth"
+
+        data = {"email": username,
+                "password": password,
+                "token_name": token_name,
+            }
+        if otp:
+            data["otp"] = otp
+        data = json.dumps(data).encode("utf-8")
+        resp, content = http_request(
+            UBUNTUONE_OAUTH_API,
+            data=data,
+            headers={"content-type": "application/json"})
+        msg = json.loads(content.decode("utf-8"))
+        if resp.status not in (200, 201):
+            if msg["code"] == "TWOFACTOR_REQUIRED":
+                raise ClickLoginTwoFactorRequired()
+            else:
+                raise Exception(
+                    "get_oauth_token failed with status %s" % resp.status)
+        token = msg
+        return token

=== added file 'click/tests/test_acquire.py'
--- click/tests/test_acquire.py	1970-01-01 00:00:00 +0000
+++ click/tests/test_acquire.py	2014-12-03 23:19:34 +0000
@@ -0,0 +1,174 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Michael Vogt <[e-mail]>
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Unit tests for click.acquire."""
+
+from __future__ import print_function
+
+__metaclass__ = type
+__all__ = [
+    'TestClickAcquire',
+    ]
+
+import multiprocessing
+import os.path
+import time
+
+from six.moves import (
+    SimpleHTTPServer,
+    socketserver,
+)
+
+from click.acquire import (
+    ClickAcquire,
+    ClickAcquireError,
+    _read_messages,
+)
+
+from click.tests.helpers import (
+    TestCase,
+)
+
+import click.acquire
+click.acquire.acquire_methods_dir = os.path.join(
+    os.path.dirname(__file__), "..", "..", "acquire")
+os.environ["PYTHONPATH"] = os.path.abspath(
+    os.path.join(os.path.dirname(__file__), "..", ".."))
+
+# local httpd
+LOCALHOST = "localhost"
+PORT = 8128
+
+
+class MyHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
+    def log_message(self, format, *args):
+        pass
+
+
+class MySocketServer(socketserver.TCPServer):
+    allow_reuse_address = True
+
+
+class Httpd(multiprocessing.Process):
+
+    def __init__(self, basedir):
+        super(Httpd, self).__init__()
+        self.basedir = basedir
+
+    def run(self):
+        os.chdir(self.basedir)
+        server = MySocketServer((LOCALHOST, PORT), MyHandler)
+        while True:
+            server.handle_request()
+        server.shutdown()
+
+    def stop(self):
+        self.terminate()
+        self.join()
+
+
+class TestClickAcquire(TestCase):
+
+    def setUp(self):
+        super(TestClickAcquire, self).setUp()
+        self.use_temp_dir()
+        self.httpd = Httpd(self.temp_dir)
+        self.httpd.start()
+
+    def tearDown(self):
+        self.httpd.stop()
+
+    def test_acquire_fail(self):
+        acq = ClickAcquire()
+        destfile = os.path.join(self.temp_dir, "meep")
+        with self.assertRaises(ClickAcquireError):
+            acq.fetch("http://%s:%s/not-here" % (LOCALHOST, PORT), destfile)
+
+    def test_acquire_good(self):
+        acq = ClickAcquire()
+        destfile = os.path.join(self.temp_dir, "meep")
+        canary_str = "hello"
+        with open(os.path.join(self.temp_dir, "i-am-here"), "w") as f:
+            f.write(canary_str)
+        acq.fetch("http://%s:%s/i-am-here" % (LOCALHOST, PORT), destfile)
+        with open(destfile) as f:
+            data = f.read()
+        self.assertEqual(canary_str, data)
+
+
+class TestClickAcquireReadMessages(TestCase):
+
+    def test_forked_read_message(self):
+        read_end, write_end = os.pipe()
+        pid = os.fork()
+        if pid == 0:
+            os.close(write_end)
+            with os.fdopen(read_end) as f:
+                number, msg = _read_messages(f)[0]
+                self.assertEqual(msg, "102 Status\nFoo: Bar\n")
+                self.assertEqual(number, 102)
+            os._exit(0)
+        os.close(read_end)
+        os.write(write_end, "102 Status\nFoo: Bar\n\n".encode("utf-8"))
+        os.waitpid(pid, 0)
+        os.close(write_end)
+
+    def test_forked_read_multiple_messages(self):
+        read_end, write_end = os.pipe()
+        pid = os.fork()
+        if pid == 0:
+            os.close(write_end)
+            with os.fdopen(read_end) as f:
+                msgs = _read_messages(f)
+                self.assertEqual(len(msgs), 2)
+                self.assertEqual(msgs[0][0], 100)
+                self.assertEqual(msgs[1][0], 200)
+            os._exit(0)
+        os.close(read_end)
+        os.write(write_end, "100 Status\n\n200 meep\n\n".encode("utf-8"))
+        os.waitpid(pid, 0)
+        os.close(write_end)
+
+    def test_forked_read_message_broken_pipe(self):
+        read_end, write_end = os.pipe()
+        pid = os.fork()
+        if pid == 0:
+            os.close(write_end)
+            with os.fdopen(read_end) as f:
+                self.assertEqual(_read_messages(f), [])
+            os._exit(0)
+        os.close(read_end)
+        os.write(write_end, "102 close-before-msg".encode("utf-8"))
+        os.close(write_end)
+        os.waitpid(pid, 0)
+
+    def test_forked_read_message_with_timeout(self):
+        read_end, write_end = os.pipe()
+        pid = os.fork()
+        if pid == 0:
+            os.close(write_end)
+            with os.fdopen(read_end) as f:
+                self.assertEqual(_read_messages(f, 0.1), [])
+                msgs = _read_messages(f)
+                self.assertEqual(len(msgs), 2)
+                self.assertEqual(msgs[0][1], "100 aaa\n")
+                self.assertEqual(msgs[1][1], "200 bbb\n")
+            os._exit(0)
+        os.close(read_end)
+        # simulate slow method
+        time.sleep(0.2)
+        os.write(write_end, "100 aaa\n\n".encode("utf-8"))
+        os.write(write_end, "200 bbb\n\n".encode("utf-8"))
+        os.waitpid(pid, 0)

=== modified file 'click/tests/test_build.py'
--- click/tests/test_build.py	2014-09-04 13:41:30 +0000
+++ click/tests/test_build.py	2014-12-03 23:19:34 +0000
@@ -56,6 +56,12 @@
     return decorator
 
 
+def extract_field(path, name):
+    return subprocess.check_output(
+        ["dpkg-deb", "-f", path, name],
+        universal_newlines=True).rstrip("\n")
+
+
 class TestClickBuilderBaseMixin:
     def test_read_manifest(self):
         self.use_temp_dir()
@@ -118,11 +124,6 @@
         super(TestClickBuilder, self).setUp()
         self.builder = ClickBuilder()
 
-    def extract_field(self, path, name):
-        return subprocess.check_output(
-            ["dpkg-deb", "-f", path, name],
-            universal_newlines=True).rstrip("\n")
-
     @disable_logging
     @umask(0o22)
     def test_build(self):
@@ -157,9 +158,9 @@
             ("Maintainer", "Foo Bar <[e-mail]>"),
             ("Description", "test title"),
         ):
-            self.assertEqual(value, self.extract_field(path, key))
+            self.assertEqual(value, extract_field(path, key))
         self.assertNotEqual(
-            "", self.extract_field(path, "Installed-Size"))
+            "", extract_field(path, "Installed-Size"))
         control_path = os.path.join(self.temp_dir, "control")
         subprocess.check_call(["dpkg-deb", "-e", path, control_path])
         manifest_path = os.path.join(control_path, "manifest")
@@ -242,7 +243,7 @@
         path = os.path.join(self.temp_dir, "com.example.test_1.0_multi.click")
         self.assertEqual(path, self.builder.build(self.temp_dir))
         self.assertTrue(os.path.exists(path))
-        self.assertEqual("multi", self.extract_field(path, "Architecture"))
+        self.assertEqual("multi", extract_field(path, "Architecture"))
         control_path = os.path.join(self.temp_dir, "control")
         subprocess.check_call(["dpkg-deb", "-e", path, control_path])
         manifest_path = os.path.join(control_path, "manifest")
@@ -339,3 +340,286 @@
             self.assertCountEqual(
                 [".", "./bin", "./bin/foo", "./manifest.json"], tar.getnames())
             self.assertTrue(tar.getmember("./bin/foo").isfile())
+
+
+SIMPLE_TEMPLATE = """\
+name: test-yaml
+icon: data/icon.svg
+version: 1.0
+maintainer: Foo Bar <[e-mail]>
+architecture: all
+framework: ubuntu-core-15.04
+integration:
+  app1:
+    hookname: hook-file-name
+services:
+  - name: app1
+    description: some description
+    start: start-something
+    stop: stop-something
+binaries:
+  - name: path/to/cli1
+"""
+
+APPARMOR_1_TEMPLATE = """\
+name: test-yaml
+icon: data/icon.svg
+version: 1.0
+maintainer: Foo Bar <[e-mail]>
+architecture: all
+framework: ubuntu-core-15.04
+integration:
+  app1:
+    hookname: hook-file-name
+    apparmor: path/to/app1.apparmor
+services:
+  - name: app1
+    description: some description
+    start: start-something
+    stop: stop-something
+  - name: app2
+    description: some description
+    start: start-something
+    stop: stop-something
+binaries:
+  - name: path/to/cli1
+"""
+
+APPARMOR_2_TEMPLATE = """\
+name: test-yaml
+icon: data/icon.svg
+version: 1.0
+maintainer: Foo Bar <[e-mail]>
+architecture: all
+framework: ubuntu-core-15.04
+integration:
+  app1:
+    hookname: hook-file-name
+    apparmor-profile: path/to/app1.apparmor-profile
+services:
+  - name: app1
+    description: some description
+    start: start-something
+    stop: stop-something
+  - name: app2
+    description: some description
+    start: start-something
+    stop: stop-something
+binaries:
+  - name: path/to/cli1
+"""
+
+
+class TestClickBuildYaml(TestCase):
+    def setUp(self):
+        super(TestClickBuildYaml, self).setUp()
+        self.builder = ClickBuilder()
+
+    def _make_metadata(self, scratch, template=SIMPLE_TEMPLATE):
+        with mkfile(os.path.join(scratch, "meta", "package.yaml")) as f:
+            f.write(dedent(template))
+        with mkfile(os.path.join(scratch, "meta", "readme.md")) as f:
+            f.write(dedent("""test title
+
+            Long description that spawns
+            two lines.
+
+            Some more random data.
+            """))
+
+    def test_build_valid_pkg(self):
+        self.use_temp_dir()
+        scratch = os.path.join(self.temp_dir, "scratch")
+        touch(os.path.join(scratch, "bin", "foo"))
+        touch(os.path.join(scratch, "data", "icon.svg"))
+        self._make_metadata(scratch)
+        self.builder.add_file(scratch, "./")
+        # FIXME: make it a .snap
+        expected_path = os.path.join(self.temp_dir, "test-yaml_1.0_all.click")
+        actual_path = self.builder.build(self.temp_dir, "meta/package.yaml")
+        self.assertEqual(expected_path, actual_path)
+        self.assertTrue(os.path.exists(actual_path))
+        # check the fields
+        for key, value in (
+            ("Package", "test-yaml"),
+            ("Version", "1.0"),
+            ("Click-Version", "0.4"),
+            ("Architecture", "all"),
+            ("Maintainer", "Foo Bar <[e-mail]>"),
+            ("Description", "test title"),
+        ):
+            self.assertEqual(value, extract_field(actual_path, key))
+        click_contents = subprocess.check_output(
+            ["dpkg-deb", "-c", actual_path], universal_newlines=True)
+        for file_path in ("./data/icon.svg", "./meta/package.yaml",
+                          "./meta/readme.md", "./bin/foo",
+                          "./meta/app1.apparmor"):
+            self.assertIn(file_path, click_contents)
+
+    def test_read_manifest(self):
+        self.use_temp_dir()
+        self._make_metadata(self.temp_dir)
+        self.builder.read_manifest(self.temp_dir+"/meta/package.yaml")
+        self.assertEqual("test-yaml", self.builder.name)
+        self.assertEqual("1.0", self.builder.version)
+        self.assertEqual("Foo Bar <[e-mail]>", self.builder.maintainer)
+        self.assertEqual("test title", self.builder.title)
+        self.assertEqual("all", self.builder.architecture)
+        self.assertEqual(
+            "meta/app1.snappy-systemd",
+            self.builder.manifest["hooks"]["app1"]["snappy-systemd"])
+        self.assertEqual(
+            "hook-file-name",
+            self.builder.manifest["hooks"]["app1"]["hookname"])
+        self.assertEqual(
+            "path/to/cli1",
+            self.builder.manifest["hooks"]["cli1"]["bin-path"])
+        self.assertEqual(
+            "meta/app1.apparmor",
+            self.builder.manifest["hooks"]["app1"]["apparmor"])
+
+    def test_one_explicit_apparmor(self):
+        self.use_temp_dir()
+        self._make_metadata(self.temp_dir, APPARMOR_1_TEMPLATE)
+        self.builder.read_manifest(self.temp_dir + "/meta/package.yaml")
+        self.assertEqual(
+            "path/to/app1.apparmor",
+            self.builder.manifest["hooks"]["app1"]["apparmor"])
+        self.assertEqual(
+            "meta/app2.apparmor",
+            self.builder.manifest["hooks"]["app2"]["apparmor"])
+
+    def test_one_explicit_apparmor_profile(self):
+        self.use_temp_dir()
+        self._make_metadata(self.temp_dir, APPARMOR_2_TEMPLATE)
+        self.builder.read_manifest(self.temp_dir + "/meta/package.yaml")
+        self.assertEqual(
+            "path/to/app1.apparmor-profile",
+            self.builder.manifest["hooks"]["app1"]["apparmor-profile"])
+        self.assertIsNone(
+            self.builder.manifest["hooks"]["app1"].get('apparmor'))
+        self.assertEqual(
+            "meta/app2.apparmor",
+            self.builder.manifest["hooks"]["app2"]["apparmor"])
+
+    def test_one_explicit_apparmor_file(self):
+        self.use_temp_dir()
+        scratch = os.path.join(self.temp_dir, "scratch")
+        touch(os.path.join(scratch, "bin", "foo"))
+        touch(os.path.join(scratch, "data", "icon.svg"))
+        apparmor_path = os.path.join(scratch, 'path', 'to', 'app1.apparmor')
+        os.makedirs(os.path.dirname(apparmor_path))
+        with open(apparmor_path, 'w', encoding='utf-8') as fp:
+            fp.write(dedent("""\
+            {
+                "template": "default",
+                "policy_groups": [
+                    "networking"
+                ],
+                "policy_vendor": "ubuntu-snappy",
+                "policy_version": 99.99
+            }
+            """))
+        self._make_metadata(scratch, APPARMOR_1_TEMPLATE)
+        self.builder.add_file(scratch, "./")
+        # FIXME: make it a .snap
+        expected_path = os.path.join(self.temp_dir, "test-yaml_1.0_all.click")
+        actual_path = self.builder.build(self.temp_dir, "meta/package.yaml")
+        self.assertEqual(expected_path, actual_path)
+        self.assertTrue(os.path.exists(actual_path))
+        contents = os.path.join(self.temp_dir, 'contents')
+        subprocess.check_output(
+            ["dpkg-deb", "-R", actual_path, contents], universal_newlines=True)
+        self.assertEqual(sorted(os.listdir(contents)),
+                         ['DEBIAN', 'bin', 'data', 'meta', 'path'])
+        self.assertEqual(
+            sorted(os.listdir(os.path.join(contents, 'path', 'to'))),
+            ['app1.apparmor'])
+        with open(os.path.join(contents, 'path', 'to', 'app1.apparmor'),
+                  encoding='utf-8') as fp:
+            data = fp.read()
+        self.assertEqual(data, dedent("""\
+            {
+                "template": "default",
+                "policy_groups": [
+                    "networking"
+                ],
+                "policy_vendor": "ubuntu-snappy",
+                "policy_version": 99.99
+            }
+            """))
+        with open(os.path.join(contents, 'meta', 'app2.apparmor'),
+                  encoding='utf-8') as fp:
+            data = fp.read()
+        self.assertEqual(data, dedent("""\
+            {
+                "template": "default",
+                "policy_groups": [
+                    "networking"
+                ],
+                "policy_vendor": "ubuntu-snappy",
+                "policy_version": 1.3
+            }
+            """))
+
+    def test_one_explicit_apparmor_profile_file(self):
+        self.use_temp_dir()
+        scratch = os.path.join(self.temp_dir, "scratch")
+        touch(os.path.join(scratch, "bin", "foo"))
+        touch(os.path.join(scratch, "data", "icon.svg"))
+        apparmor_path = os.path.join(
+            scratch, 'path', 'to', 'app1.apparmor-profile')
+        os.makedirs(os.path.dirname(apparmor_path))
+        with open(apparmor_path, 'w', encoding='utf-8') as fp:
+            fp.write(dedent("""\
+            {
+                "template": "default",
+                "policy_groups": [
+                    "networking"
+                ],
+                "policy_vendor": "ubuntu-snappy",
+                "policy_version": 88.88
+            }
+            """))
+        self._make_metadata(scratch, APPARMOR_2_TEMPLATE)
+        self.builder.add_file(scratch, "./")
+        # FIXME: make it a .snap
+        expected_path = os.path.join(self.temp_dir, "test-yaml_1.0_all.click")
+        actual_path = self.builder.build(self.temp_dir, "meta/package.yaml")
+        self.assertEqual(expected_path, actual_path)
+        self.assertTrue(os.path.exists(actual_path))
+        contents = os.path.join(self.temp_dir, 'contents')
+        subprocess.check_output(
+            ["dpkg-deb", "-R", actual_path, contents], universal_newlines=True)
+        self.assertEqual(sorted(os.listdir(contents)),
+                         ['DEBIAN', 'bin', 'data', 'meta', 'path'])
+        self.assertEqual(
+            sorted(os.listdir(os.path.join(contents, 'path', 'to'))),
+            ['app1.apparmor-profile'])
+        with open(
+                os.path.join(contents, 'path', 'to', 'app1.apparmor-profile'),
+                encoding='utf-8') as fp:
+            data = fp.read()
+        self.assertEqual(data, dedent("""\
+            {
+                "template": "default",
+                "policy_groups": [
+                    "networking"
+                ],
+                "policy_vendor": "ubuntu-snappy",
+                "policy_version": 88.88
+            }
+            """))
+        with open(os.path.join(contents, 'meta', 'app2.apparmor'),
+                  encoding='utf-8') as fp:
+            data = fp.read()
+        self.assertEqual(data, dedent("""\
+            {
+                "template": "default",
+                "policy_groups": [
+                    "networking"
+                ],
+                "policy_vendor": "ubuntu-snappy",
+                "policy_version": 1.3
+            }
+            """))

=== modified file 'click/tests/test_install.py'
--- click/tests/test_install.py	2014-08-19 06:32:16 +0000
+++ click/tests/test_install.py	2014-12-03 23:19:34 +0000
@@ -32,6 +32,7 @@
 import subprocess
 
 from unittest import skipUnless
+from hashlib import sha512
 
 from debian.deb822 import Deb822
 from gi.repository import Click
@@ -446,6 +447,18 @@
                 "Description": "test",
                 "Click-Version": "0.2",
             }, status[0])
+            manifest_file = "test-package.manifest"
+            manifest_path = os.path.join(inst_dir,
+                                         ".click", "info",
+                                         manifest_file)
+            self.assertTrue(os.path.exists(manifest_path))
+            with open(manifest_path) as fd:
+                manifest = json.load(fd)
+            self.assertTrue(manifest)
+            self.assertTrue("checksum-sha512" in manifest)
+            with open(path, "rb") as fd:
+                checksum = sha512(fd.read()).hexdigest()
+            self.assertEqual(checksum, manifest["checksum-sha512"])
             mock_package_install_hooks.assert_called_once_with(
                 db, "test-package", None, "1.0", user_name=None)
 
@@ -456,18 +469,12 @@
         with self.run_in_subprocess(
                 "click_get_frameworks_dir") as (enter, preloads):
             enter()
-            original_call = subprocess.call
+            original_call = subprocess.check_output
 
             def call_side_effect(*args, **kwargs):
-                if "TEST_VERBOSE" in os.environ:
-                    return original_call(
-                        ["touch", os.path.join(self.temp_dir, "sentinel")],
-                        **kwargs)
-                else:
-                    with open("/dev/null", "w") as devnull:
-                        return original_call(
-                            ["touch", os.path.join(self.temp_dir, "sentinel")],
-                            stdout=devnull, stderr=devnull, **kwargs)
+                return original_call(
+                    ["touch", os.path.join(self.temp_dir, "sentinel")],
+                    **kwargs)
 
             path = self.make_fake_package(
                 control_fields={
@@ -490,7 +497,7 @@
             db.add(root)
             installer = ClickInstaller(db)
             self._setup_frameworks(preloads, frameworks=["ubuntu-sdk-13.10"])
-            with mock.patch("subprocess.call") as mock_call:
+            with mock.patch("subprocess.check_output") as mock_call:
                 mock_call.side_effect = call_side_effect
                 self.assertRaises(
                     subprocess.CalledProcessError, installer.install, path)
@@ -611,7 +618,7 @@
         os.path.exists(ClickInstaller(None)._preload_path()),
         "preload bits not built; installing packages will fail")
     @mock.patch("gi.repository.Click.package_install_hooks")
-    @mock.patch("click.install.ClickInstaller._dpkg_architecture")
+    @mock.patch("click.install._dpkg_architecture")
     def test_single_architecture(self, mock_dpkg_architecture,
                                  mock_package_install_hooks):
         with self.run_in_subprocess(
@@ -648,7 +655,7 @@
         os.path.exists(ClickInstaller(None)._preload_path()),
         "preload bits not built; installing packages will fail")
     @mock.patch("gi.repository.Click.package_install_hooks")
-    @mock.patch("click.install.ClickInstaller._dpkg_architecture")
+    @mock.patch("click.install._dpkg_architecture")
     def test_multiple_architectures(self, mock_dpkg_architecture,
                                     mock_package_install_hooks):
         with self.run_in_subprocess(

=== modified file 'debian/changelog'
--- debian/changelog	2014-11-14 12:29:14 +0000
+++ debian/changelog	2014-12-03 23:19:34 +0000
@@ -1,3 +1,124 @@
+click (0.4.35+ppa19) vivid; urgency=low
+
+  * fix frameworks mapping
+  * remove duplicated information from auto-generated manifest.json
+    when package.yaml is used
+
+ -- Michael Vogt <[e-mail]>  Wed, 03 Dec 2014 16:47:40 +0100
+
+click (0.4.35+ppa18) vivid; urgency=low
+
+  [ Barry Warsaw ]
+  * add install progress meter
+  
+  [ Michael Vogt ]
+  * make dpkg output in install quiet unless "--verbose" is given
+
+ -- Michael Vogt <[e-mail]>  Wed, 03 Dec 2014 10:16:43 +0100
+
+click (0.4.35+ppa17) vivid; urgency=low
+
+  * add support for packages.yaml "binaries:"
+
+ -- Michael Vogt <[e-mail]>  Tue, 02 Dec 2014 16:37:12 +0100
+
+click (0.4.35+ppa16) vivid; urgency=low
+
+  * click/build.py:
+    - make yaml service description optional
+
+ -- Michael Vogt <[e-mail]>  Tue, 02 Dec 2014 08:49:21 +0100
+
+click (0.4.35+ppa15) vivid; urgency=low
+
+  * more fixes
+
+ -- Michael Vogt <[e-mail]>  Fri, 28 Nov 2014 14:42:18 +0100
+
+click (0.4.35+ppa14) vivid; urgency=low
+
+  * fix test failure
+
+ -- Michael Vogt <[e-mail]>  Fri, 28 Nov 2014 13:44:31 +0100
+
+click (0.4.35+ppa13) vivid; urgency=low
+
+  * add support for "services" in packages.yaml
+
+ -- Michael Vogt <[e-mail]>  Fri, 28 Nov 2014 13:39:32 +0100
+
+click (0.4.35+ppa12) vivid; urgency=low
+
+  * use "integration" instead of "hooks" in the packages.yaml
+
+ -- Michael Vogt <[e-mail]>  Fri, 28 Nov 2014 08:35:31 +0100
+
+click (0.4.35+ppa11) vivid; urgency=low
+
+  * use /apps prefix instead of /opt/com.ubuntu.click
+
+ -- Michael Vogt <[e-mail]>  Thu, 27 Nov 2014 09:05:37 +0100
+
+click (0.4.35+ppa10) vivid; urgency=low
+
+  * merge fixes from lp:~mvo/click/yaml-manifest
+
+ -- Michael Vogt <[e-mail]>  Wed, 26 Nov 2014 17:57:51 +0100
+
+click (0.4.35+ppa9) vivid; urgency=low
+
+  * merged lp:~mvo/click/yaml-manifest
+
+ -- Michael Vogt <[e-mail]>  Wed, 26 Nov 2014 16:50:25 +0100
+
+click (0.4.35+ppa8) vivid; urgency=low
+
+  * merge lp:~mvo/click/add-checksum-to-manifest
+
+ -- Michael Vogt <[e-mail]>  Tue, 25 Nov 2014 17:58:24 +0100
+
+click (0.4.35+ppa7) vivid; urgency=low
+
+  * fix typos in click update
+
+ -- Michael Vogt <[e-mail]>  Mon, 24 Nov 2014 17:32:42 +0100
+
+click (0.4.35+ppa6) vivid; urgency=low
+
+  * send application/hal+json header (as requested by the u1 team)
+
+ -- Michael Vogt <[e-mail]>  Thu, 20 Nov 2014 15:55:43 +0100
+
+click (0.4.35+ppa5) vivid; urgency=low
+
+  * do not fail if logind is not available
+
+ -- Michael Vogt <[e-mail]>  Wed, 19 Nov 2014 22:17:20 +0100
+
+click (0.4.35+ppa4) vivid; urgency=low
+
+  * merge  lp:~mvo/click/lp1394256-run-user-hooks 
+
+ -- Michael Vogt <[e-mail]>  Wed, 19 Nov 2014 21:54:54 +0100
+
+click (0.4.35+ppa3) vivid; urgency=low
+
+  * merged lp:~jamesodhunt/click/add-checksum-to-manifest
+
+ -- Michael Vogt <[e-mail]>  Wed, 19 Nov 2014 16:46:54 +0100
+
+click (0.4.35+ppa2) vivid; urgency=low
+
+  * fix click update for anonymous clicks
+
+ -- Michael Vogt <[e-mail]>  Mon, 17 Nov 2014 16:57:23 +0100
+
+click (0.4.35+ppa1) vivid; urgency=low
+
+  * merged with vivid
+
+ -- Michael Vogt <[e-mail]>  Fri, 14 Nov 2014 17:43:35 +0100
+
 click (0.4.35) vivid; urgency=low
 
   [ Michael Vogt ]
@@ -8,6 +129,53 @@
 
  -- Ubuntu daily release <[e-mail]>  Fri, 14 Nov 2014 12:29:14 +0000
 
+click (0.4.34.2+ppa7) vivid; urgency=low
+
+  * fix tests
+
+ -- Michael Vogt <[e-mail]>  Wed, 12 Nov 2014 10:43:51 +0100
+
+click (0.4.34.2+ppa6) vivid; urgency=low
+
+  * send correct frameworks/architecture to the click store
+
+ -- Michael Vogt <[e-mail]>  Wed, 12 Nov 2014 10:01:19 +0100
+
+click (0.4.34.2+ppa5) vivid; urgency=low
+
+  * add support for 2fa
+
+ -- Michael Vogt <[e-mail]>  Tue, 11 Nov 2014 15:32:33 +0100
+
+click (0.4.34.2+ppa4) vivid; urgency=low
+
+  * merged lp:~mvo/click/sso+acquire
+
+ -- Michael Vogt <[e-mail]>  Wed, 05 Nov 2014 14:58:39 +0100
+
+click (0.4.34.2+ppa3) vivid; urgency=low
+
+  * pep8/pyflakes
+
+ -- Michael Vogt <[e-mail]>  Wed, 05 Nov 2014 14:47:32 +0100
+
+click (0.4.34.2+ppa2) vivid; urgency=low
+
+  * support "click update click1 click2"
+  * support "click update --user=USER"
+  * support "click update --all-users"
+  * show new status after "click update"
+  * merge latest lp:~mvo/click/sso changes to support anonymous
+    downloads
+
+ -- Michael Vogt <[e-mail]>  Wed, 05 Nov 2014 14:18:24 +0100
+
+click (0.4.34.2+ppa1) vivid; urgency=low
+
+  * merged lp:click/devel
+
+ -- Michael Vogt <[e-mail]>  Tue, 04 Nov 2014 10:15:13 +0100
+
 click (0.4.34.2) vivid; urgency=medium
 
   [ Michael Vogt ]
@@ -41,6 +209,44 @@
 
  -- Ubuntu daily release <[e-mail]>  Mon, 03 Nov 2014 12:49:25 +0000
 
+click (0.4.34~ppa6) utopic; urgency=low
+
+  * merge fixes from acquire/repository
+
+ -- Michael Vogt <[e-mail]>  Tue, 21 Oct 2014 17:44:56 -0400
+
+click (0.4.34~ppa5) utopic; urgency=low
+
+  * add python3-oauthlib, python3-prettytable to the build-depends
+
+ -- Michael Vogt <[e-mail]>  Tue, 21 Oct 2014 13:59:25 -0400
+
+click (0.4.34~ppa4) utopic; urgency=low
+
+  * fix tests
+
+ -- Michael Vogt <[e-mail]>  Tue, 21 Oct 2014 12:48:25 -0400
+
+click (0.4.34~ppa3) utopic; urgency=medium
+
+  [ Michael Vogt ]
+  * Demote ubuntu-app-launch-tools from a click recommends to a suggests,
+    since they are not needed on server installs.
+  * Use dh-systemd to enable click system and user hook integration
+    (LP: #1379657).
+  * merged lp:~mvo/click/sso+acquire
+  * hack XB-Task: ubuntu-core
+
+  [ Colin Watson ]
+  * Make "click info" always try opening the input file as a package and
+    only try to interpret it as a file in an installed package if that
+    fails, rather than guessing by the input file extension.
+
+  [ Pete Woods ]
+  * Include Canonical's cmake-extras project in the schroot.
+
+ -- Michael Vogt <[e-mail]>  Tue, 21 Oct 2014 11:54:52 -0400
+
 click (0.4.33) utopic; urgency=medium
 
   [ Pete Woods ]

=== modified file 'debian/click.postinst'
--- debian/click.postinst	2014-10-14 09:47:48 +0000
+++ debian/click.postinst	2014-12-03 23:19:34 +0000
@@ -8,8 +8,8 @@
 			clickpkg
 	fi
 
-	mkdir -p -m 755 /opt/click.ubuntu.com
-	chown clickpkg:clickpkg /opt/click.ubuntu.com
+	mkdir -p -m 755 /apps
+	chown clickpkg:clickpkg /apps
 
 	# dh-systemd has no support yet for user systemd units
 	# so we need to do this manually here

=== modified file 'debian/control'
--- debian/control	2014-10-10 07:10:23 +0000
+++ debian/control	2014-12-03 23:19:34 +0000
@@ -3,7 +3,7 @@
 Priority: optional
 Maintainer: Colin Watson <[e-mail]>
 Standards-Version: 3.9.5
-Build-Depends: debhelper (>= 9~), dh-autoreconf, intltool, python3:any (>= 3.2), python3-all:any, python3-setuptools, python3-apt, python3-debian, python3-gi, python3:any (>= 3.3) | python3-mock, pep8, python3-pep8, pyflakes, python3-sphinx, pkg-config, valac, gobject-introspection (>= 0.6.7), libgirepository1.0-dev (>= 0.6.7), libglib2.0-dev (>= 2.34), gir1.2-glib-2.0, libjson-glib-dev (>= 0.10), libgee-0.8-dev, libpackagekit-glib2-dev (>= 0.7.2), python3-coverage, python3-six, dh-systemd (>= 1.3)
+Build-Depends: debhelper (>= 9~), dh-autoreconf, intltool, python3:any (>= 3.2), python3-all:any, python3-setuptools, python3-apt, python3-debian, python3-gi, python3:any (>= 3.3) | python3-mock, pep8, python3-pep8, pyflakes, python3-sphinx, pkg-config, valac, gobject-introspection (>= 0.6.7), libgirepository1.0-dev (>= 0.6.7), libglib2.0-dev (>= 2.34), gir1.2-glib-2.0, libjson-glib-dev (>= 0.10), libgee-0.8-dev, libpackagekit-glib2-dev (>= 0.7.2), python3-coverage, python3-six, python3-pycurl, python3-dbus, dh-systemd (>= 1.3), python3-prettytable, python3-oauthlib, python3-yaml, python3-progressbar
 Vcs-Bzr: https://code.launchpad.net/~ubuntu-managed-branches/click/click
 Vcs-Browser: http://bazaar.launchpad.net/~ubuntu-managed-branches/click/click/files
 X-Auto-Uploader: no-rewrite-version
@@ -14,7 +14,7 @@
 Package: click
 Architecture: any
 Pre-Depends: ${misc:Pre-Depends}
-Depends: ${shlibs:Depends}, ${misc:Depends}, ${python3:Depends}, python3-click (= ${binary:Version}), adduser
+Depends: ${shlibs:Depends}, ${misc:Depends}, ${python3:Depends}, python3-click (= ${binary:Version}), adduser, python3-prettytable, python3-pycurl, python3-dbus, python3-oauthlib, python3-yaml, python3-progressbar
 Recommends: click-apparmor
 Suggests: click-reviewers-tools (>= 0.9), ubuntu-app-launch-tools | upstart-app-launch-tools
 Conflicts: click-package
@@ -25,6 +25,7 @@
  the file system, suitable for third-party applications.
  .
  This package provides common files, including the main click program.
+XB-Task: ubuntu-core
 
 Package: click-dev
 Architecture: any
@@ -40,7 +41,7 @@
 Package: python3-click
 Section: python
 Architecture: any
-Depends: ${misc:Depends}, ${python3:Depends}, gir1.2-click-0.4 (= ${binary:Version}), gir1.2-glib-2.0, python3-apt, python3-debian, python3-gi
+Depends: ${misc:Depends}, ${python3:Depends}, gir1.2-click-0.4 (= ${binary:Version}), gir1.2-glib-2.0, python3-apt, python3-debian, python3-gi, python3-pycurl
 Conflicts: python3-click-package
 Replaces: python3-click-package
 Provides: python3-click-package

=== modified file 'debian/rules'
--- debian/rules	2014-10-10 07:10:23 +0000
+++ debian/rules	2014-12-03 23:19:34 +0000
@@ -24,7 +24,8 @@
 confflags := \
 	--with-python-interpreters='$(PY3)' \
 	--with-systemdsystemunitdir=/lib/systemd/system \
-	--with-systemduserunitdir=/usr/lib/systemd/user
+	--with-systemduserunitdir=/usr/lib/systemd/user \
+	--with-default-root=/apps
 ifeq ($(PACKAGEKIT),no)
 confflags += --disable-packagekit
 endif

=== modified file 'lib/click/user.vala'
--- lib/click/user.vala	2014-09-29 13:23:12 +0000
+++ lib/click/user.vala	2014-12-03 23:19:34 +0000
@@ -33,8 +33,21 @@
  * symlinks per user.
  */
 
+
 namespace Click {
 
+	struct LogindUser {
+		uint32 uid;
+		string name;
+		string ObjectPath;
+	}
+
+	/* the logind dbus interface */
+	[DBus (name = "org.freedesktop.login1.Manager")]
+	interface LogindManager : Object {
+		public abstract LogindUser[] ListUsers () throws IOError;
+	}
+
 /* Pseudo-usernames selected to be invalid as a real username, and alluding
  * to group syntaxes used in other systems.
  */
@@ -596,6 +609,35 @@
 		if (! is_pseudo_user)
 			package_install_hooks (db, package,
 					       old_version, version, name);
+
+		// run user hooks for all logged in users
+		if (name == ALL_USERS)
+			run_user_hooks_for_all_logged_in_users (package, old_version, version);
+	}
+
+	private void
+	run_user_hooks_for_all_logged_in_users (string package, string? old_version,
+											string version) throws IOError
+	{
+		try {
+			LogindManager logind = Bus.get_proxy_sync (
+				BusType.SYSTEM,
+				"org.freedesktop.login1",
+				"/org/freedesktop/login1");
+			var users = logind.ListUsers();
+			foreach (LogindUser user in users)
+			{
+				// FIXME: ideally we would read from /etc/adduser.conf
+				if(user.uid >= 1000 && user.uid <= 30000)
+				{
+					package_install_hooks (db, package,
+										   old_version, version, user.name);
+				}
+			}
+		} catch (Error e) {
+			warning ("Can not connect to logind");
+			return;
+		}
 	}
 
 	private bool

=== modified file 'setup.py.in'
--- setup.py.in	2014-06-30 16:48:31 +0000
+++ setup.py.in	2014-12-03 23:19:34 +0000
@@ -1,5 +1,6 @@
 #! /usr/bin/env python3
 
+import glob
 import sys
 
 from setuptools import find_packages, setup
@@ -18,6 +19,8 @@
 if sys.version < "3.3":
     require('mock')
 require('chardet')
+require('click.paths')
+import click.paths
 
 if "@GCOVR@":
     require('coverage')
@@ -47,6 +50,11 @@
     license="GNU GPL",
     packages=find_packages(),
     scripts=['bin/click'],
+    data_files=[
+        # we need to remove the prefix here or we add it twice
+        (click.paths.acquire_methods_dir[1:].lstrip(sys.prefix),
+             glob.glob("acquire/*")),
+    ],
     install_requires=requirements,
     cmdclass={"test": test_extra},
     test_suite="click.tests",