Merge lp:~mhr3/unity-scopes-api/always-join-threads into lp:unity-scopes-api

[Michal Hruby]

Always join worker threads.

Always join worker threads. Otherwise if something throws an exception, the thread is destructed without being joined, and that's not a good thing to do.

[lp:~mhr3/unity-scopes-api/always-join-threads]

302. By Michal Hruby on 2014-04-09

Wrap the trap thread also in smartscopesproxy

303. By Marcus Tomlinson on 2014-04-09

Init state receiver first

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-04-04 14:53:32 +0000
+++ CMakeLists.txt	2014-04-08 16:22:25 +0000
@@ -54,11 +54,12 @@
 endif()
 
 include(FindPkgConfig)
-find_package(Boost COMPONENTS regex serialization REQUIRED)
+find_package(Boost COMPONENTS system filesystem regex serialization REQUIRED)
 pkg_check_modules(UNITY_API libunity-api>=0.1.1 REQUIRED)
 pkg_check_modules(PROCESS_CPP process-cpp>=1.0.0 REQUIRED)
 pkg_check_modules(LTTNG_UST lttng-ust REQUIRED)
 pkg_check_modules(LIBURCU_BP liburcu-bp REQUIRED)
+pkg_check_modules(APPARMOR REQUIRED libapparmor REQUIRED)
 find_program(LTTNG_EXECUTABLE lttng)
 if (NOT LTTNG_EXECUTABLE)
     message(SEND_ERROR "Cannot find LTTng executable: ensure that lttng-tools is installed")
@@ -100,7 +101,7 @@
 endif()
 set(CAPNPC_FLAGS "" CACHE STRING "Extra flags for capnpc.")
 
-set(OTHER_INCLUDE_DIRS ${OTHER_INCLUDE_DIRS} ${UNITY_API_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS} ${JSONCPP_INCLUDE_DIRS} ${PROCESS_CPP_INCLUDE_DIRS})
+set(OTHER_INCLUDE_DIRS ${OTHER_INCLUDE_DIRS} ${UNITY_API_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS} ${JSONCPP_INCLUDE_DIRS} ${PROCESS_CPP_INCLUDE_DIRS} ${APPARMOR_INCLUDE_DIRS})
 set(OTHER_LIBS ${UNITY_API_LDFLAGS} ${OTHER_LIBS})
 
 # Standard install paths
@@ -218,6 +219,7 @@
     ${Boost_LIBRARIES}
     ${JSONCPP_LDFLAGS}
     ${PROCESS_CPP_LDFLAGS}
+    ${APPARMOR_LDFLAGS}
     ${ZMQPPLIB}
     ${ZMQLIB}
     ${CAPNPLIB}

=== modified file 'debian/control'
--- debian/control	2014-04-04 14:53:32 +0000
+++ debian/control	2014-04-08 16:22:25 +0000
@@ -2,6 +2,7 @@
 Priority: optional
 Maintainer: Ubuntu Developers <[e-mail]>
 Build-Depends: debhelper (>= 9),
+               click-dev (>= 0.2.2),
                cmake,
                doxygen,
                google-mock,
@@ -9,8 +10,10 @@
                pkg-config,
                python3,
                capnproto,
+               libapparmor-dev,
                libprocess-cpp-dev (>= 1.0.0),
                libunity-api-dev (>= 7.80.5~),
+               libboost-filesystem-dev,
                libboost-regex-dev,
                libboost-serialization-dev,
                libcapnp-dev (>= 0.4.0),

=== added file 'debian/libunity-scopes1.scope.click-hook'
--- debian/libunity-scopes1.scope.click-hook	1970-01-01 00:00:00 +0000
+++ debian/libunity-scopes1.scope.click-hook	2014-04-08 16:22:25 +0000
@@ -0,0 +1,3 @@
+Pattern: ${home}/.local/share/unity-scopes/${id}
+User-Level: yes
+Hook-Name: scope

=== modified file 'debian/libunity-scopes1.symbols'
--- debian/libunity-scopes1.symbols	2014-04-04 17:36:38 +0000
+++ debian/libunity-scopes1.symbols	2014-04-08 16:22:25 +0000
@@ -430,6 +430,8 @@
  (c++)"unity::scopes::internal::MiddlewareFactory::to_kind(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::MiddlewareFactory::MiddlewareFactory(unity::scopes::internal::RuntimeImpl*)@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::MiddlewareFactory::~MiddlewareFactory()@Base" 0.4.0+14.04.20140312.1
+ (c++)"unity::scopes::internal::ScopeMetadataImpl::set_confinement_type(unity::scopes::ConfinementType)@Base" 0replaceme
+ (c++)"unity::scopes::internal::ScopeMetadataImpl::confinement_type() const@Base" 0replaceme
  (c++)"unity::scopes::internal::ScopeMetadataImpl::set_author(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::ScopeMetadataImpl::deserialize(std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, unity::scopes::Variant, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, unity::scopes::Variant> > > const&)@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::ScopeMetadataImpl::set_hot_key(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.4.0+14.04.20140312.1
@@ -511,6 +513,7 @@
  (c++)"unity::scopes::PreviewWidget::id() const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::PreviewWidget::data() const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::PreviewWidget::serialize() const@Base" 0.4.0+14.04.20140312.1
+ (c++)"unity::scopes::ScopeMetadata::confinement_type() const@Base" 0replaceme
  (c++)"unity::scopes::ScopeMetadata::description() const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::ScopeMetadata::search_hint() const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::ScopeMetadata::display_name() const@Base" 0.4.0+14.04.20140312.1
@@ -610,6 +613,7 @@
  (c++)"unity::scopes::internal::RuntimeImpl::factory() const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::RuntimeImpl::registry() const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::RuntimeImpl::scope_id() const@Base" 0.4.0+14.04.20140312.1
+ (c++)"unity::scopes::internal::ScopeConfig::confinement_type() const@Base" 0replaceme
  (c++)"unity::scopes::internal::ScopeConfig::description() const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::ScopeConfig::search_hint() const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::ScopeConfig::display_name() const@Base" 0.4.0+14.04.20140312.1
@@ -634,6 +638,7 @@
  (c++)"unity::scopes::internal::RuntimeConfig::registry_configfile() const@Base" 0.4.2+14.04.20140404.2
  (c++)"unity::scopes::internal::RuntimeConfig::default_middleware_configfile() const@Base" 0.4.2+14.04.20140404.2
  (c++)"unity::scopes::internal::MiddlewareBase::runtime() const@Base" 0.4.0+14.04.20140312.1
+ (c++)"unity::scopes::internal::RegistryConfig::click_installdir() const@Base" 0replaceme
  (c++)"unity::scopes::internal::RegistryConfig::endpointdir() const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::RegistryConfig::mw_configfile() const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::RegistryConfig::oem_installdir() const@Base" 0.4.0+14.04.20140312.1

=== modified file 'debian/rules'
--- debian/rules	2013-12-19 02:35:14 +0000
+++ debian/rules	2014-04-08 16:22:25 +0000
@@ -6,7 +6,7 @@
 export DPKG_GENSYMBOLS_CHECK_LEVEL=4
 
 %:
-	dh $@ --parallel --fail-missing
+	dh $@ --parallel --fail-missing --with click
 
 override_dh_auto_configure:
 	dh_auto_configure -- -DLIBDIR=/usr/lib/$(DEB_HOST_MULTIARCH)
@@ -14,3 +14,6 @@
 # Tests are not written to be run in parallel.
 override_dh_auto_test:
 	dh_auto_test --max-parallel=1 -- ARGS="--verbose"
+
+override_dh_click:
+	dh_click --name scope

=== modified file 'demo/CMakeLists.txt'
--- demo/CMakeLists.txt	2014-02-03 09:04:04 +0000
+++ demo/CMakeLists.txt	2014-04-08 16:22:25 +0000
@@ -1,3 +1,4 @@
+add_subdirectory(click)
 add_subdirectory(scopes)
 add_subdirectory(stand-alone)
 

=== added directory 'demo/click'
=== added file 'demo/click/CMakeLists.txt'
--- demo/click/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ demo/click/CMakeLists.txt	2014-04-08 16:22:25 +0000
@@ -0,0 +1,1 @@
+add_subdirectory(scope-click)

=== added directory 'demo/click/scope-click'
=== added file 'demo/click/scope-click/CMakeLists.txt'
--- demo/click/scope-click/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ demo/click/scope-click/CMakeLists.txt	2014-04-08 16:22:25 +0000
@@ -0,0 +1,34 @@
+
+if(CLICK_MODE)
+    project(unity-scope-click C CXX)
+    cmake_minimum_required(VERSION 2.8.10)
+
+    include(GNUInstallDirs)
+    include(FindPkgConfig)
+
+    pkg_check_modules(UNITY_SCOPES REQUIRED libunity-scopes>=0.4.0)
+    add_definitions(${UNITY_SCOPES_CFLAGS} ${UNITY_SCOPES_CFLAGS_OTHER})
+
+    add_definitions(-std=c++11)
+endif(CLICK_MODE)
+
+add_subdirectory(click)
+
+set(symbol_map "${CMAKE_CURRENT_SOURCE_DIR}/scope-click.map")
+
+add_library(scope-click MODULE scope-click.cpp)
+# Add_dependencies should be used sparingly. In this case we need the global
+# header to be generated before we start building the client binary.
+add_dependencies(scope-click globalheader)
+set_target_properties(scope-click PROPERTIES
+                      LINK_FLAGS "${ldflags} -Wl,--version-script,${symbol_map}")
+set_target_properties(scope-click PROPERTIES LINK_DEPENDS ${symbol_map})
+
+configure_file(scope-click.ini.in scope-click.ini)
+
+if(CLICK_MODE)
+    install(TARGETS scope-click
+            DESTINATION "${CMAKE_INSTALL_PREFIX}/scope-click/")
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/scope-click.ini"
+            DESTINATION "${CMAKE_INSTALL_PREFIX}/scope-click/")
+endif(CLICK_MODE)

=== added directory 'demo/click/scope-click/click'
=== added file 'demo/click/scope-click/click-build.sh'
--- demo/click/scope-click/click-build.sh	1970-01-01 00:00:00 +0000
+++ demo/click/scope-click/click-build.sh	2014-04-08 16:22:25 +0000
@@ -0,0 +1,47 @@
+#!/bin/sh
+
+# Copyright (C) 2014 Canonical Ltd
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authored by: Pete Woods <[e-mail]>
+
+# Simple script to build a click packaged scope.
+
+
+export LC_ALL=C
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: click-build.sh amd64|armhf|..."
+    exit 1
+fi
+
+BZR_SOURCE=${1:-lp:scope-click}
+
+CLICK_ARCH="$1"
+rm -rf "$CLICK_ARCH-build"
+rm -rf "package"
+mkdir "$CLICK_ARCH-build"
+(
+    cd "$CLICK_ARCH-build"
+    cmake .. \
+        -DCMAKE_INSTALL_PREFIX:PATH=../package \
+        -DCLICK_MODE=on \
+        -DCLICK_ARCH="$CLICK_ARCH" \
+        -DBZR_REVNO=$(cd ..; bzr revno) \
+        -DBZR_SOURCE="$BZR_SOURCE"
+    make install
+)
+click build package
+rm -rf "$CLICK_ARCH-build"
+rm -rf "package"

=== added file 'demo/click/scope-click/click/CMakeLists.txt'
--- demo/click/scope-click/click/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ demo/click/scope-click/click/CMakeLists.txt	2014-04-08 16:22:25 +0000
@@ -0,0 +1,8 @@
+if(CLICK_MODE)
+    if(NOT BZR_REVNO)
+        set(BZR_REVNO "latest")
+    endif(NOT BZR_REVNO)
+    configure_file(manifest.json.in ${CMAKE_CURRENT_BINARY_DIR}/manifest.json)
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/manifest.json
+            DESTINATION ${CMAKE_INSTALL_PREFIX})
+endif(CLICK_MODE)

=== added file 'demo/click/scope-click/click/manifest.json.in'
--- demo/click/scope-click/click/manifest.json.in	1970-01-01 00:00:00 +0000
+++ demo/click/scope-click/click/manifest.json.in	2014-04-08 16:22:25 +0000
@@ -0,0 +1,19 @@
+{
+    "description": "A pretend click scope",
+    "framework": "ubuntu-sdk-14.04-dev1",
+    "architecture": "@CLICK_ARCH@",
+    "hooks": {
+        "scope-click": {
+            "scope": "scope-click"
+        }
+    },
+    "icon": "@CLICK_SCOPE_ICON@",
+    "maintainer": "Ubuntu Developers <[e-mail]>",
+    "name": "com.ubuntu.scope-click",
+    "title": "Click Scope",
+    "version": "1.0.0.@BZR_REVNO@",
+    "x-source": {
+        "vcs-bzr": "@BZR_SOURCE@",
+        "vcs-bzr-revno": "@BZR_REVNO@"
+    }
+}

=== added file 'demo/click/scope-click/scope-click.cpp'
--- demo/click/scope-click/scope-click.cpp	1970-01-01 00:00:00 +0000
+++ demo/click/scope-click/scope-click.cpp	2014-04-08 16:22:25 +0000
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/scopes/ScopeBase.h>
+
+#include <iostream>
+#include <thread>
+
+#define EXPORT __attribute__ ((visibility ("default")))
+
+using namespace std;
+using namespace unity::scopes;
+
+// Demonstration of building a click scope. This file has the bare minimum scope implementation.
+
+class MyQuery : public SearchQueryBase
+{
+public:
+    MyQuery()
+    {
+    }
+
+    ~MyQuery()
+    {
+    }
+
+    virtual void cancelled() override
+    {
+        cerr << "scope-click: received cancel request" << endl;
+    }
+
+    virtual void run(SearchReplyProxy const&) override
+    {
+        cerr << "scope-click: received query" << endl;
+        this_thread::sleep_for(chrono::seconds(3));
+        cerr << "scope-click: query complete" << endl;
+    }
+};
+
+class MyScope : public ScopeBase
+{
+public:
+    virtual int start(string const&, RegistryProxy const&) override
+    {
+        return VERSION;
+    }
+
+    virtual void stop() override {}
+
+    virtual SearchQueryBase::UPtr search(CannedQuery const&, SearchMetadata const&) override
+    {
+        return SearchQueryBase::UPtr(new MyQuery);
+    }
+
+    virtual PreviewQueryBase::UPtr preview(Result const&, ActionMetadata const&) override
+    {
+        return nullptr;
+    }
+};
+
+extern "C"
+{
+
+    EXPORT
+    unity::scopes::ScopeBase*
+    // cppcheck-suppress unusedFunction
+    UNITY_SCOPE_CREATE_FUNCTION()
+    {
+        return new MyScope;
+    }
+
+    EXPORT
+    void
+    // cppcheck-suppress unusedFunction
+    UNITY_SCOPE_DESTROY_FUNCTION(unity::scopes::ScopeBase* scope_base)
+    {
+        delete scope_base;
+    }
+
+}

=== added file 'demo/click/scope-click/scope-click.ini.in'
--- demo/click/scope-click/scope-click.ini.in	1970-01-01 00:00:00 +0000
+++ demo/click/scope-click/scope-click.ini.in	2014-04-08 16:22:25 +0000
@@ -0,0 +1,9 @@
+[ScopeConfig]
+DisplayName = scope-click.DisplayName
+Description = scope-click.Description
+Art = scope-click.Art
+Author = Canonical Ltd.
+Icon = scope-click.Icon
+SearchHint = scope-click.SearchHint
+HotKey = scope-click.HotKey
+ConfinementType = UntrustedLocal

=== added file 'demo/click/scope-click/scope-click.map'
--- demo/click/scope-click/scope-click.map	1970-01-01 00:00:00 +0000
+++ demo/click/scope-click/scope-click.map	2014-04-08 16:22:25 +0000
@@ -0,0 +1,9 @@
+{
+global:
+        "unity_scope_create";
+        "unity_scope_destroy";
+local:
+    extern "C++" {
+        *;
+    };
+};

=== modified file 'include/unity/scopes/ScopeMetadata.h'
--- include/unity/scopes/ScopeMetadata.h	2014-04-03 16:46:00 +0000
+++ include/unity/scopes/ScopeMetadata.h	2014-04-08 16:22:25 +0000
@@ -27,8 +27,16 @@
 namespace scopes
 {
 
+enum class ConfinementType
+{
+    Trusted,
+    UntrustedLocal,
+    UntrustedInternet
+};
+
 namespace internal
 {
+
 class ScopeMetadataImpl;
 } // namespace internal
 
@@ -71,6 +79,12 @@
     std::string scope_id() const;
 
     /**
+    \brief Get the scope type.
+    \return The type of the scope.
+    */
+    ConfinementType confinement_type() const;
+
+    /**
     \brief Get the proxy object for this scope.
     \return The scope proxy.
     */

=== modified file 'include/unity/scopes/internal/RegistryConfig.h'
--- include/unity/scopes/internal/RegistryConfig.h	2014-01-28 03:12:35 +0000
+++ include/unity/scopes/internal/RegistryConfig.h	2014-04-08 16:22:25 +0000
@@ -45,6 +45,7 @@
     std::string mw_configfile() const;
     std::string scope_installdir() const;       // Directory for Canonical scopes
     std::string oem_installdir() const;         // Directory for OEM scope config files
+    std::string click_installdir() const;       // Directory for Click scope config files
     std::string scoperunner_path() const;       // Path to scoperunner binary
     std::string ss_registry_identity() const;   // Identity of smart scopes registry
     std::string ss_registry_endpoint() const;   // Endpoint of smart scopes registry
@@ -57,6 +58,7 @@
     std::string mw_configfile_;
     std::string scope_installdir_;
     std::string oem_installdir_;
+    std::string click_installdir_;
     std::string scoperunner_path_;
     std::string ss_registry_identity_;
     std::string ss_registry_endpoint_;

=== modified file 'include/unity/scopes/internal/ScopeConfig.h'
--- include/unity/scopes/internal/ScopeConfig.h	2014-03-18 10:25:32 +0000
+++ include/unity/scopes/internal/ScopeConfig.h	2014-04-08 16:22:25 +0000
@@ -21,6 +21,7 @@
 
 #include <unity/scopes/internal/ConfigBase.h>
 #include <unity/scopes/Variant.h>
+#include <unity/scopes/ScopeMetadata.h>
 
 namespace unity
 {
@@ -41,6 +42,7 @@
     ~ScopeConfig();
 
     bool overrideable() const;           // Optional, returns false if not present
+    ConfinementType confinement_type() const; // Optional, returns Trusted if not present
     std::string display_name() const;
     std::string description() const;
     std::string author() const;
@@ -54,6 +56,7 @@
 
 private:
     bool overrideable_;
+    ConfinementType confinement_type_;
     std::string display_name_;
     std::string description_;
     std::string author_;

=== modified file 'include/unity/scopes/internal/ScopeMetadataImpl.h'
--- include/unity/scopes/internal/ScopeMetadataImpl.h	2014-04-02 16:54:53 +0000
+++ include/unity/scopes/internal/ScopeMetadataImpl.h	2014-04-08 16:22:25 +0000
@@ -44,6 +44,7 @@
     ScopeMetadataImpl& operator=(ScopeMetadataImpl&&) = default;
 
     std::string scope_id() const;
+    ConfinementType confinement_type() const;
     ScopeProxy proxy() const;
     std::string display_name() const;   // localized
     std::string description() const;    // localized
@@ -57,6 +58,7 @@
     std::string scope_directory() const;
 
     void set_scope_id(std::string const& scope_id);
+    void set_confinement_type(ConfinementType scope_type);
     void set_proxy(ScopeProxy const& proxy);
     void set_display_name(std::string const& display_name);
     void set_description(std::string const& description);
@@ -78,6 +80,7 @@
 
     MiddlewareBase* mw_;
     std::string scope_id_;
+    ConfinementType confinement_type_;
     ScopeProxy proxy_;
     std::string display_name_;
     std::string description_;

=== modified file 'include/unity/scopes/internal/smartscopes/SmartScope.h'
--- include/unity/scopes/internal/smartscopes/SmartScope.h	2014-03-26 10:01:03 +0000
+++ include/unity/scopes/internal/smartscopes/SmartScope.h	2014-04-08 16:22:25 +0000
@@ -48,11 +48,22 @@
         : scope_id_(scope_id)
         , query_(query)
     {
+        static const std::string no_net_hint("no-internet");
+        if (hints.contains_hint(no_net_hint))
+        {
+            auto var = hints[no_net_hint];
+            if (var.which() == Variant::Type::Bool && var.get_bool())
+            {
+                std::cout << "SmartQuery(): networking disabled for remote scope " << scope_id << ", skipping" << std::endl;
+                return;
+            }
+        }
+
         SmartScopesClient::SPtr ss_client = reg->get_ssclient();
         std::string base_url = reg->get_base_url(scope_id_);
 
-        ///! TODO: session_id, query_id, locale, country
-        search_handle_ = ss_client->search(base_url, query_.query_string(), query.department_id(), "session_id", 0, hints.form_factor(), "", "", hints.cardinality());
+        ///! TODO: session_id, query_id, country
+        search_handle_ = ss_client->search(base_url, query_.query_string(), query.department_id(), "session_id", 0, hints.form_factor(), hints.locale(), "", hints.cardinality());
     }
 
     ~SmartQuery() noexcept
@@ -61,11 +72,20 @@
 
     virtual void cancelled() override
     {
-        search_handle_->cancel_search();
+        if (search_handle_ != nullptr)
+        {
+            search_handle_->cancel_search();
+        }
     }
 
     virtual void run(SearchReplyProxy const& reply) override
     {
+        if (search_handle_ == nullptr)
+        {
+            // this can happen if networking is disabled
+            return;
+        }
+
         std::vector<SearchResult> results = search_handle_->get_search_results();
         std::map<std::string, Category::SCPtr> categories;
 
@@ -124,8 +144,8 @@
         SmartScopesClient::SPtr ss_client = reg->get_ssclient();
         std::string base_url = reg->get_base_url(scope_id_);
 
-        ///! TODO: session_id, widgets_api_version, locale, country
-        preview_handle_ = ss_client->preview(base_url, result_["result_json"].get_string(), "session_id", hints.form_factor(), 0, "", "");
+        ///! TODO: session_id, widgets_api_version, country
+        preview_handle_ = ss_client->preview(base_url, result_["result_json"].get_string(), "session_id", hints.form_factor(), 0, hints.locale(), "");
     }
 
     ~SmartPreview()

=== modified file 'scoperegistry/FindFiles.cpp'
--- scoperegistry/FindFiles.cpp	2014-04-03 12:57:25 +0000
+++ scoperegistry/FindFiles.cpp	2014-04-08 16:22:25 +0000
@@ -25,8 +25,11 @@
 #include <string.h>
 #include <sys/stat.h>
 
+#include <boost/filesystem/path.hpp>
+
 using namespace std;
 using namespace unity;
+using namespace boost;
 
 namespace scoperegistry
 {
@@ -34,17 +37,6 @@
 namespace
 {
 
-bool has_suffix(string const& s, string const& suffix)
-{
-    auto s_len = s.length();
-    auto suffix_len = suffix.length();
-    if (s_len >= suffix_len)
-    {
-        return s.compare(s_len - suffix_len, suffix_len, suffix) == 0;
-    }
-    return false;
-}
-
 // Return all paths underneath the given dir that are of the given type
 // or are a symbolic link.
 
@@ -91,7 +83,7 @@
 
 } // namespace
 
-// Return all files of the form dir/<somescope>/<scomescope>.ini that are regular files or
+// Return all files of the form dir/*/<scomescope>.ini that are regular files or
 // symbolic links and have the specified suffix.
 // The empty suffix is legal and causes all regular files and symlinks to be returned.
 
@@ -102,32 +94,16 @@
     auto subdirs = find_entries(install_dir, Directory);
     for (auto subdir : subdirs)
     {
-        string scope_id = basename(const_cast<char*>(subdir.c_str()));    // basename() modifies its argument
         auto candidates = find_entries(subdir, File);
         for (auto c : candidates)
         {
-            string config_name = basename(const_cast<char*>(c.c_str()));    // basename() modifies its argument
-            if (config_name == scope_id + suffix)
-            {
-                files.emplace_back(c);
+            // TODO Check for multiple ini files
+
+            filesystem::path path(c);
+            if (path.extension() != suffix) {
+                continue;
             }
-        }
-    }
-
-    return files;
-}
-
-// Return all files with the given suffix in dir.
-
-vector<string> find_files(string const& dir, string const& suffix)
-{
-    vector<string> files;
-
-    auto candidates = find_entries(dir, File);
-    for (auto c : candidates)
-    {
-        if (has_suffix(c, suffix))
-        {
+
             files.emplace_back(c);
         }
     }

=== modified file 'scoperegistry/scoperegistry.cpp'
--- scoperegistry/scoperegistry.cpp	2014-04-03 16:46:00 +0000
+++ scoperegistry/scoperegistry.cpp	2014-04-08 16:22:25 +0000
@@ -39,12 +39,15 @@
 #include <libgen.h>
 #include <unistd.h>
 
+#include <boost/filesystem/path.hpp>
+
 using namespace scoperegistry;
 using namespace std;
 using namespace unity;
 using namespace unity::scopes;
 using namespace unity::scopes::internal;
 using namespace unity::util;
+using namespace boost;
 
 char const* prog_name;
 
@@ -57,30 +60,68 @@
     cerr << prog_name << ": " << msg << endl;
 }
 
-string strip_suffix(string const& s, string const& suffix)
-{
-    auto s_len = s.length();
-    auto suffix_len = suffix.length();
-    if (s_len >= suffix_len)
-    {
-        if (s.compare(s_len - suffix_len, suffix_len, suffix) == 0)
-        {
-            return string(s, 0, s_len - suffix_len);
-        }
-    }
-    return s;
-}
-
 // if path is an absolute path, just return it. otherwise, append it to scopedir.
-string relative_scope_path_to_abs_path(string const& path, string const& scopedir)
+filesystem::path relative_scope_path_to_abs_path(filesystem::path const& path, filesystem::path const& scopedir)
 {
-    if (path.size() > 0 && path[0] != '/')
+    if (path.is_relative())
     {
-        return scopedir + "/" + path;
+        return scopedir / path;
     }
     return path;
 }
 
+// throwing an exception without joining with a thread is a bad, bad thing to do, so let's RAII to avoid doing it
+struct SignalThreadWrapper
+{
+    std::shared_ptr<core::posix::SignalTrap> termination_trap;
+    std::shared_ptr<core::posix::SignalTrap> child_trap;
+    std::unique_ptr<core::posix::ChildProcess::DeathObserver> death_observer;
+    std::thread termination_trap_worker;
+    std::thread child_trap_worker;
+
+    SignalThreadWrapper() :
+        // We shutdown the runtime whenever these signals happen.
+        termination_trap(core::posix::trap_signals_for_all_subsequent_threads(
+            {
+                core::posix::Signal::sig_int,
+                core::posix::Signal::sig_hup,
+                core::posix::Signal::sig_term
+            })),
+        // And we maintain our list of processes with the help of sig_chld.
+        child_trap(core::posix::trap_signals_for_all_subsequent_threads(
+            {
+                core::posix::Signal::sig_chld
+            })),
+        // The death observer is required to make sure that we reap all child processes
+        // whenever multiple sigchld's are compressed together.
+        death_observer(core::posix::ChildProcess::DeathObserver::create_once_with_signal_trap(child_trap)),
+        // Starting up both traps.
+        termination_trap_worker([&]() { termination_trap->run(); }),
+        child_trap_worker([&]() { child_trap->run(); })
+    {
+    }
+
+    core::Signal<core::posix::Signal>& signal_raised()
+    {
+        return termination_trap->signal_raised();
+    }
+
+    ~SignalThreadWrapper()
+    {
+        // Stop termination_trap
+        termination_trap->stop();
+        if (termination_trap_worker.joinable())
+            termination_trap_worker.join();
+
+        // Please note that the child_trap must only be stopped once the
+        // termination_trap thread has been joined. We otherwise will encounter
+        // a race between the middleware shutting down and not receiving sigchld anymore.
+        child_trap->stop();
+        if (child_trap_worker.joinable())
+            child_trap_worker.join();
+    }
+};
+
 // Return a map of <scope, config_file> pairs for all scopes (Canonical and OEM scopes).
 // If a Canonical scope is overrideable and the OEM has configured a scope with the
 // same id, the OEM scope overrides the Canonical one.
@@ -98,8 +139,8 @@
     auto config_files = find_scope_config_files(scope_installdir, ".ini");
     for (auto&& path : config_files)
     {
-        string file_name = basename(const_cast<char*>(string(path).c_str()));    // basename() modifies its argument
-        string scope_id = strip_suffix(file_name, ".ini");
+        filesystem::path p(path);
+        string scope_id = p.stem().native();
         try
         {
             ScopeConfig config(path);
@@ -125,8 +166,9 @@
             auto oem_paths = find_scope_config_files(oem_installdir, ".ini");
             for (auto&& path : oem_paths)
             {
-                string file_name = basename(const_cast<char*>(string(path).c_str()));    // basename() modifies its argument
-                string scope_id = strip_suffix(file_name, ".ini");
+                filesystem::path p(path);
+                string file_name = p.filename().native();
+                string scope_id = p.stem().native();
                 if (fixed_scopes.find(scope_id) == fixed_scopes.end())
                 {
                     overrideable_scopes[scope_id] = path;  // Replaces scope if it was present already
@@ -149,6 +191,40 @@
     return fixed_scopes;
 }
 
+map<string, string> find_click_scopes(map<string, string> const& local_scopes, string const& click_installdir)
+{
+    map<string, string> click_scopes;
+
+    if (!click_installdir.empty())
+    {
+        try
+        {
+            auto click_paths = find_scope_config_files(click_installdir, ".ini");
+            for (auto&& path : click_paths)
+            {
+                filesystem::path p(path);
+                string file_name = p.filename().native();
+                string scope_id = p.stem().native();
+                if (local_scopes.find(scope_id) == local_scopes.end())
+                {
+                    click_scopes[scope_id] = path;
+                }
+                else
+                {
+                    error("ignoring non-overrideable scope config \"" + file_name + "\" in click directory " + click_installdir);
+                }
+            }
+        }
+        catch (ResourceException const& e)
+        {
+            error(e.what());
+            error("could not open Click installation directory, ignoring Click scopes");
+        }
+    }
+
+    return click_scopes;
+}
+
 // For each scope, open the config file for the scope, create the metadata info from the config,
 // and add an entry to the RegistryObject.
 
@@ -156,18 +232,19 @@
                       map<string, string> const& all_scopes,
                       MiddlewareBase::SPtr const& mw,
                       string const& scoperunner_path,
-                      string const& config_file)
+                      string const& config_file,
+                      bool click)
 {
     for (auto&& pair : all_scopes)
     {
         try
         {
             unique_ptr<ScopeMetadataImpl> mi(new ScopeMetadataImpl(mw.get()));
-            ScopeConfig sc(pair.second);
+            string scope_config(pair.second);
+            ScopeConfig sc(scope_config);
 
-            // dirname modifies its argument, so we need a copy of scope ini path.
-            std::vector<char> scope_ini(pair.second.c_str(), pair.second.c_str() + pair.second.size() + 1);
-            const std::string scope_dir(dirname(&scope_ini[0]));
+            filesystem::path scope_path(scope_config);
+            filesystem::path scope_dir(scope_path.parent_path());
 
             mi->set_scope_id(pair.first);
             mi->set_display_name(sc.display_name());
@@ -175,17 +252,24 @@
             mi->set_author(sc.author());
             mi->set_invisible(sc.invisible());
             mi->set_appearance_attributes(sc.appearance_attributes());
-            mi->set_scope_directory(scope_dir);
+            mi->set_scope_directory(scope_dir.native());
+
+            if (click && (sc.confinement_type() == ConfinementType::Trusted))
+            {
+                throw unity::InvalidArgumentException("Invalid type, Trusted for click scope: " + pair.first);
+            }
+            mi->set_confinement_type(sc.confinement_type());
+
             try
             {
-                mi->set_art(relative_scope_path_to_abs_path(sc.art(), scope_dir));
+                mi->set_art(relative_scope_path_to_abs_path(sc.art(), scope_dir).native());
             }
             catch (NotFoundException const&)
             {
             }
             try
             {
-                mi->set_icon(relative_scope_path_to_abs_path(sc.icon(), scope_dir));
+                mi->set_icon(relative_scope_path_to_abs_path(sc.icon(), scope_dir).native());
             }
             catch (NotFoundException const&)
             {
@@ -220,7 +304,7 @@
                 {
                     throw unity::InvalidArgumentException("Invalid scope runner executable for scope: " + pair.first);
                 }
-                exec_data.scoperunner_path = relative_scope_path_to_abs_path(custom_exec, scope_dir);
+                exec_data.scoperunner_path = relative_scope_path_to_abs_path(custom_exec, scope_dir).native();
             }
             catch (NotFoundException const&)
             {
@@ -278,29 +362,7 @@
 
     try
     {
-        // We shutdown the runtime whenever these signals happen.
-        auto termination_trap = core::posix::trap_signals_for_all_subsequent_threads(
-        {
-            core::posix::Signal::sig_int,
-            core::posix::Signal::sig_hup,
-            core::posix::Signal::sig_term
-        });
-
-        // And we maintain our list of processes with the help of sig_chld.
-        auto child_trap = core::posix::trap_signals_for_all_subsequent_threads(
-        {
-            core::posix::Signal::sig_chld
-        });
-
-        // The death observer is required to make sure that we reap all child processes
-        // whenever multiple sigchld's are compressed together.
-        auto death_observer =
-                core::posix::ChildProcess::DeathObserver::create_once_with_signal_trap(
-                    child_trap);
-
-        // Starting up both traps.
-        std::thread termination_trap_worker([termination_trap]() { termination_trap->run(); });
-        std::thread child_trap_worker([child_trap]() { child_trap->run(); });
+        SignalThreadWrapper signal_handler_wrapper;
 
         // And finally creating our runtime.
         RuntimeConfig rt_config(config_file);
@@ -315,6 +377,7 @@
         string mw_configfile;
         string scope_installdir;
         string oem_installdir;
+        string click_installdir;
         string scoperunner_path;
         string ss_reg_id;
         string ss_reg_endpoint;
@@ -325,6 +388,7 @@
             mw_configfile = c.mw_configfile();
             scope_installdir = c.scope_installdir();
             oem_installdir = c.oem_installdir();
+            click_installdir = c.click_installdir();
             scoperunner_path = c.scoperunner_path();
             ss_reg_id = c.ss_registry_identity();
             ss_reg_endpoint = c.ss_registry_endpoint();
@@ -334,7 +398,7 @@
 
         // Inform the signal thread that it should shutdown the middleware
         // if we get a termination signal.
-        termination_trap->signal_raised().connect([middleware](core::posix::Signal signal)
+        signal_handler_wrapper.signal_raised().connect([middleware](core::posix::Signal signal)
         {
             switch(signal)
             {
@@ -349,25 +413,28 @@
         });
 
         // The registry object stores the local and remote scopes
-        RegistryObject::SPtr registry(new RegistryObject(*death_observer));
+        RegistryObject::SPtr registry(new RegistryObject(*signal_handler_wrapper.death_observer));
 
         // Add the metadata for each scope to the lookup table.
         // We do this before starting any of the scopes, so aggregating scopes don't get a lookup failure if
         // they look for another scope in the registry.
 
         auto local_scopes = find_local_scopes(scope_installdir, oem_installdir);
+        auto click_scopes = find_click_scopes(local_scopes, click_installdir);
 
         // Before we add the local scopes, we check whether any scopes were explicitly specified
         // on the command line. If so, scopes on the command line override scopes in
         // configuration files.
         for (auto i = 2; i < argc; ++i)
         {
-            string file_name = basename(const_cast<char*>(string(argv[i]).c_str()));  // basename() modifies its argument
-            string scope_id = strip_suffix(file_name, ".ini");
+            filesystem::path path(argv[i]);
+            string scope_id = path.stem().native();
             local_scopes[scope_id] = argv[i];                   // operator[] overwrites pre-existing entries
         }
 
-        add_local_scopes(registry, local_scopes, middleware, scoperunner_path, runtime->configfile());
+        add_local_scopes(registry, local_scopes, middleware, scoperunner_path, runtime->configfile(), false);
+        add_local_scopes(registry, click_scopes, middleware, scoperunner_path, runtime->configfile(), true);
+        local_scopes.insert(click_scopes.begin(), click_scopes.end());
         if (ss_reg_id.empty() || ss_reg_endpoint.empty())
         {
             error("no remote registry configured, only local scopes will be available");
@@ -415,18 +482,6 @@
         // Wait until we are done, which happens if we receive a termination signal.
         middleware->wait_for_shutdown();
 
-        // Stop termination_trap
-        termination_trap->stop();
-        if (termination_trap_worker.joinable())
-            termination_trap_worker.join();
-
-        // Please note that the child_trap must only be stopped once the
-        // termination_trap thread has been joined. We otherwise will encounter
-        // a race between the middleware shutting down and not receiving sigchld anymore.
-        child_trap->stop();
-        if (child_trap_worker.joinable())
-            child_trap_worker.join();
-
         exit_status = 0;
     }
     catch (std::exception const& e)

=== modified file 'scoperunner/scoperunner.cpp'
--- scoperunner/scoperunner.cpp	2014-04-03 14:49:30 +0000
+++ scoperunner/scoperunner.cpp	2014-04-08 16:22:25 +0000
@@ -21,6 +21,7 @@
 #include <unity/scopes/internal/RegistryConfig.h>
 #include <unity/scopes/internal/RuntimeConfig.h>
 #include <unity/scopes/internal/RuntimeImpl.h>
+#include <unity/scopes/internal/ScopeConfig.h>
 #include <unity/scopes/internal/ScopeLoader.h>
 #include <unity/scopes/internal/ScopeObject.h>
 #include <unity/scopes/internal/ThreadSafeQueue.h>
@@ -32,15 +33,21 @@
 #include <cassert>
 #include <future>
 #include <iostream>
+#include <sstream>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include <libgen.h>
 
+#include <boost/filesystem/path.hpp>
+
+#include <sys/apparmor.h>
+
 using namespace std;
 using namespace unity::scopes;
 using namespace unity::scopes::internal;
+using namespace boost;
 
 namespace
 {
@@ -53,66 +60,66 @@
     cerr << prog_name << ": " << msg << endl;
 }
 
-bool has_suffix(string const& s, string const& suffix)
-{
-    auto s_len = s.length();
-    auto suffix_len = suffix.length();
-    if (s_len >= suffix_len)
-    {
-        return s.compare(s_len - suffix_len, suffix_len, suffix) == 0;
-    }
-    return false;
-}
-
-string strip_suffix(string const& s, string const& suffix)
-{
-    auto s_len = s.length();
-    auto suffix_len = suffix.length();
-    if (s_len >= suffix_len)
-    {
-        if (s.compare(s_len - suffix_len, suffix_len, suffix) == 0)
-        {
-            return string(s, 0, s_len - suffix_len);
-        }
-    }
-    return s;
-}
-
-// One thread for each scope, plus a future that the thread sets when it finishes.
-
-struct ThreadFuture
-{
-    thread t;
-    std::future<void> f;
-};
-
-// Each thread provides its own ID on a queue when it finishes. That allows us to
-// then locate the thread in the map. The promise is set by the thread so we can
-// find out what happened to it and join with it. Unfortunately, we have to jump
-// through these hoops because there is no way to wait on multiple futures in C++ 11.
-
-unordered_map<thread::id, ThreadFuture> threads;
-
-ThreadSafeQueue<thread::id> finished_threads;
-
-// Scope thread start function.
-
-void scope_thread(std::shared_ptr<core::posix::SignalTrap> trap,
-                  MWStateReceiverProxy reg_state_receiver,
-                  string const& mw_kind,
-                  string const& mw_config,
-                  string const& runtime_config,
-                  string const& scope_id,
-                  string const& lib_dir,
-                  promise<void> finished_promise)
-{
+// Run the scope specified by the config_file in a separate thread and wait for the thread to finish.
+// Return exit status for main to use.
+
+int run_scope(filesystem::path const& runtime_config, filesystem::path const& scope_config)
+{
+    auto trap = core::posix::trap_signals_for_all_subsequent_threads(
+    {
+        core::posix::Signal::sig_hup,
+        core::posix::Signal::sig_term
+    });
+
+    std::thread trap_worker([trap]() { trap->run(); });
+
+    // Retrieve the registry middleware and create a proxy to its state receiver
+    RuntimeConfig rt_config(runtime_config.native());
+    RegistryConfig reg_conf(rt_config.registry_identity(), rt_config.registry_configfile());
+    auto reg_runtime = RuntimeImpl::create(rt_config.registry_identity(), runtime_config.native());
+    auto reg_mw = reg_runtime->factory()->find(reg_runtime->registry_identity(), reg_conf.mw_kind());
+    auto reg_state_receiver = reg_mw->create_state_receiver_proxy("StateReceiver");
+
+    string lib_dir = scope_config.parent_path().native();
+    string scope_id = scope_config.stem().native();
+
+    int exit_status = 1;
     try
     {
         // Instantiate the run time, create the middleware, load the scope from its
         // shared library, and call the scope's start() method.
-        auto rt = RuntimeImpl::create(scope_id, runtime_config);
-        auto mw = rt->factory()->create(scope_id, mw_kind, mw_config);
-        ScopeLoader::SPtr loader = ScopeLoader::load(scope_id, lib_dir + "lib" + scope_id + ".so", rt->registry());
+        auto rt = RuntimeImpl::create(scope_id, runtime_config.native());
+        auto mw = rt->factory()->create(scope_id, reg_conf.mw_kind(), reg_conf.mw_configfile());
+
+        ScopeConfig sc(scope_config.c_str());
+
+        // Drop our privileges
+        string profile;
+        switch (sc.confinement_type())
+        {
+            case ConfinementType::Trusted:
+                break;
+            case ConfinementType::UntrustedLocal:
+                profile = "unity-scope-local";
+                break;
+            case ConfinementType::UntrustedInternet:
+                profile = "unity-scope-internet";
+                break;
+        }
+
+        if (!profile.empty())
+        {
+            int profile_change_code = aa_change_profile(profile.c_str());
+            if (profile_change_code != 0)
+            {
+                ostringstream message;
+                message << "Couldn't change to AppArmor profile [" << profile
+                        << "] error = [" << profile_change_code << "]";
+                throw ConfigException(message.str());
+            }
+        }
+
+        ScopeLoader::SPtr loader = ScopeLoader::load(scope_id, lib_dir + "/lib" + scope_id + ".so", rt->registry());
         loader->start();
 
         // Give a thread to the scope to do with as it likes. If the scope doesn't want to use it and
@@ -141,82 +148,15 @@
         // destructor will still call stop() on the scope.
         run_future.get();
 
-        finished_promise.set_value();
+        exit_status = 0;
+    }
+    catch (std::exception const& e)
+    {
+        error(e.what());
     }
     catch (...)
     {
-        finished_promise.set_exception(current_exception());
-    }
-
-    finished_threads.push(this_thread::get_id());
-}
-
-// Run each of the scopes in config_files in a separate thread and wait for each thread to finish.
-// Return the number of threads that did not terminate normally.
-
-int run_scopes(string const& runtime_config, vector<string> config_files)
-{
-    auto trap = core::posix::trap_signals_for_all_subsequent_threads(
-    {
-        core::posix::Signal::sig_hup,
-        core::posix::Signal::sig_term
-    });
-
-    std::thread trap_worker([trap]() { trap->run(); });
-
-    // Retrieve the registry middleware and create a proxy to its state receiver
-    RuntimeConfig rt_config(runtime_config);
-    RegistryConfig reg_conf(rt_config.registry_identity(), rt_config.registry_configfile());
-    auto reg_runtime = RuntimeImpl::create(rt_config.registry_identity(), runtime_config);
-    auto reg_mw = reg_runtime->factory()->find(reg_runtime->registry_identity(), reg_conf.mw_kind());
-    auto reg_state_receiver = reg_mw->create_state_receiver_proxy("StateReceiver");
-
-    for (auto file : config_files)
-    {
-        string file_name = basename(const_cast<char*>(string(file).c_str()));    // basename() modifies its argument
-        auto dir_len = file.size() - file_name.size();
-        string dir = file.substr(0, dir_len);
-        if (*dir.rbegin() != '/')
-        {
-            dir += "/";
-        }
-        string scope_id = strip_suffix(file_name, ".ini");
-
-        // For each scope, create a thread that loads the scope and initializes it.
-        // Each thread gets a promise to indicate when it is finished. When a thread
-        // completes, it fulfils the promise, and pushes its ID onto the finished queue.
-        // We collect exit status from the thread via the future from each promise.
-        promise<void> p;
-        auto f = p.get_future();
-        thread t(scope_thread, trap, reg_state_receiver, reg_conf.mw_kind(), reg_conf.mw_configfile(),
-                 runtime_config, scope_id, dir, move(p));
-
-        auto id = t.get_id();
-        threads[id] = ThreadFuture { move(t), move(f) };
-    }
-
-    // Now wait for the threads to finish (in any order).
-    int num_errors = 0;
-    for (int i = threads.size(); i > 0; --i)
-    {
-        try
-        {
-            auto id = finished_threads.wait_and_pop();
-            auto it = threads.find(id);
-            assert(it != threads.end());
-            it->second.t.join();
-            it->second.f.get();             // This will throw if the thread terminated due to an exception
-        }
-        catch (std::exception const& e)
-        {
-            error(e.what());
-            ++num_errors;
-        }
-        catch (...)
-        {
-            error("unknown exception");
-            ++num_errors;
-        }
+        error("unknown exception");
     }
 
     trap->stop();
@@ -224,7 +164,7 @@
     if (trap_worker.joinable())
         trap_worker.join();
 
-    return num_errors;
+    return exit_status;
 }
 
 } // namespace
@@ -240,27 +180,30 @@
     ::pthread_sigmask(SIG_SETMASK, &set, nullptr);
 
     prog_name = basename(argv[0]);
-    if (argc < 3)
+    if (argc != 3)
     {
-        cerr << "usage: " << prog_name << " runtime.ini configfile.ini [configfile.ini ...]" << endl;
+        cerr << "usage: " << prog_name << " runtime.ini configfile.ini" << endl;
         return 2;
     }
     char const* const runtime_config = argv[1];
+    char const* const scope_config = argv[2];
 
     int exit_status = 1;
     try
     {
-        vector<string> config_files;
-        for (int i = 2; i < argc; ++i)
-        {
-            if (!has_suffix(argv[i], ".ini"))
-            {
-                throw ConfigException(string("invalid config file name: \"") + argv[i] + "\": missing .ini extension");
-            }
-            config_files.push_back(argv[i]);
-        }
-
-        exit_status = run_scopes(runtime_config, config_files);
+        filesystem::path runtime_path(runtime_config);
+        if (runtime_path.extension() != ".ini")
+        {
+            throw ConfigException(string("invalid runtime config file name: \"") + runtime_config + "\": missing .ini extension");
+        }
+
+        filesystem::path scope_path(scope_config);
+        if (scope_path.extension() != ".ini")
+        {
+            throw ConfigException(string("invalid scope config file name: \"") + scope_config + "\": missing .ini extension");
+        }
+
+        exit_status = run_scope(runtime_path, scope_path);
     }
     catch (std::exception const& e)
     {

=== modified file 'src/scopes/ScopeMetadata.cpp'
--- src/scopes/ScopeMetadata.cpp	2014-04-02 16:54:53 +0000
+++ src/scopes/ScopeMetadata.cpp	2014-04-08 16:22:25 +0000
@@ -72,6 +72,11 @@
     return p->scope_id();
 }
 
+ConfinementType ScopeMetadata::confinement_type() const
+{
+    return p->confinement_type();
+}
+
 ScopeProxy ScopeMetadata::proxy() const
 {
     return p->proxy();

=== modified file 'src/scopes/internal/RegistryConfig.cpp'
--- src/scopes/internal/RegistryConfig.cpp	2014-01-28 03:12:35 +0000
+++ src/scopes/internal/RegistryConfig.cpp	2014-04-08 16:22:25 +0000
@@ -48,6 +48,11 @@
     mw_configfile_ = get_string(REGISTRY_CONFIG_GROUP, mw_kind_ + ".ConfigFile");
     scope_installdir_ = get_string(REGISTRY_CONFIG_GROUP, "Scope.InstallDir");
     oem_installdir_ = get_optional_string(REGISTRY_CONFIG_GROUP, "OEM.InstallDir");
+    click_installdir_ = get_optional_string(REGISTRY_CONFIG_GROUP, "Click.InstallDir");
+    if (click_installdir_.empty())
+    {
+        click_installdir_ = string(getenv("HOME")) + "/.local/share/unity-scopes/";
+    }
     scoperunner_path_ = get_string(REGISTRY_CONFIG_GROUP, "Scoperunner.Path");
     if (scoperunner_path_[0] != '/')
     {
@@ -96,6 +101,11 @@
     return oem_installdir_;
 }
 
+string RegistryConfig::click_installdir() const
+{
+    return click_installdir_;
+}
+
 string RegistryConfig::scoperunner_path() const
 {
     return scoperunner_path_;

=== modified file 'src/scopes/internal/ScopeConfig.cpp'
--- src/scopes/internal/ScopeConfig.cpp	2014-03-31 16:05:42 +0000
+++ src/scopes/internal/ScopeConfig.cpp	2014-04-08 16:22:25 +0000
@@ -39,6 +39,7 @@
 {
     const string overrideable_str = "Override";
     const string scope_id_str = "DisplayName";
+    const string scope_confinement_type_str = "ConfinementType";
     const string description_str = "Description";
     const string author_str = "Author";
     const string art_str = "Art";
@@ -47,6 +48,10 @@
     const string hot_key_str = "HotKey";
     const string invisible_str = "Invisible";
     const string scope_runner_exec = "ScopeRunner";
+
+    const string scope_confinement_type_trusted_str = "Trusted";
+    const string scope_confinement_type_untrusted_local_str = "UntrustedLocal";
+    const string scope_confinement_type_untrusted_internet_str = "UntrustedInternet";
 }
 
 ScopeConfig::ScopeConfig(string const& configfile) :
@@ -60,6 +65,28 @@
     {
         overrideable_ = false;
     }
+
+    confinement_type_ = ConfinementType::Trusted;
+    try
+    {
+        string confinement_type = parser()->get_string(SCOPE_CONFIG_GROUP, scope_confinement_type_str);
+        if (confinement_type == scope_confinement_type_trusted_str)
+        {
+            confinement_type_ = ConfinementType::Trusted;
+        }
+        else if (confinement_type == scope_confinement_type_untrusted_local_str)
+        {
+            confinement_type_ = ConfinementType::UntrustedLocal;
+        }
+        else if (confinement_type == scope_confinement_type_untrusted_internet_str)
+        {
+            confinement_type_ = ConfinementType::UntrustedInternet;
+        }
+    }
+    catch (LogicException const& e)
+    {
+    }
+
     display_name_ = parser()->get_string(SCOPE_CONFIG_GROUP, scope_id_str);
     description_ = parser()->get_string(SCOPE_CONFIG_GROUP, description_str);
     author_ = parser()->get_string(SCOPE_CONFIG_GROUP, author_str);
@@ -141,6 +168,11 @@
     return overrideable_;
 }
 
+ConfinementType ScopeConfig::confinement_type() const
+{
+    return confinement_type_;
+}
+
 string ScopeConfig::display_name() const
 {
     return display_name_;

=== modified file 'src/scopes/internal/ScopeMetadataImpl.cpp'
--- src/scopes/internal/ScopeMetadataImpl.cpp	2014-04-02 17:05:14 +0000
+++ src/scopes/internal/ScopeMetadataImpl.cpp	2014-04-08 16:22:25 +0000
@@ -36,7 +36,7 @@
 {
 
 ScopeMetadataImpl::ScopeMetadataImpl(MiddlewareBase* mw) :
-    mw_(mw)
+    mw_(mw), confinement_type_(ConfinementType::Trusted)
 {
 }
 
@@ -49,6 +49,7 @@
 ScopeMetadataImpl::ScopeMetadataImpl(ScopeMetadataImpl const& other) :
     mw_(other.mw_),
     scope_id_(other.scope_id_),
+    confinement_type_(other.confinement_type_),
     proxy_(other.proxy_),
     display_name_(other.display_name_),
     description_(other.description_),
@@ -87,6 +88,7 @@
     {
         mw_ = rhs.mw_;
         scope_id_ = rhs.scope_id_;
+        confinement_type_ = rhs.confinement_type_;
         proxy_ = rhs.proxy_;
         display_name_ = rhs.display_name_;
         description_ = rhs.description_;
@@ -107,6 +109,11 @@
     return scope_id_;
 }
 
+ConfinementType ScopeMetadataImpl::confinement_type() const
+{
+    return confinement_type_;
+}
+
 ScopeProxy ScopeMetadataImpl::proxy() const
 {
     return proxy_;
@@ -191,6 +198,11 @@
     scope_id_ = scope_id;
 }
 
+void ScopeMetadataImpl::set_confinement_type(ConfinementType confinement_type)
+{
+    confinement_type_ = confinement_type;
+}
+
 void ScopeMetadataImpl::set_proxy(ScopeProxy const& proxy)
 {
     proxy_ = proxy;
@@ -272,6 +284,7 @@
 
     VariantMap var;
     var["scope_id"] = scope_id_;
+    var["confinement_type"] = (int) confinement_type_;
     VariantMap proxy;
     proxy["identity"] = proxy_->identity();
     proxy["endpoint"] = proxy_->endpoint();
@@ -364,6 +377,9 @@
 
     // Optional fields
 
+    it = var.find("confinement_type");
+    confinement_type_ = (ConfinementType) it->second.get_int();
+
     it = var.find("art");
     if (it != var.end())
     {

=== modified file 'test/gtest/scopes/Registry/Registry_test.cpp'
--- test/gtest/scopes/Registry/Registry_test.cpp	2014-04-02 16:54:53 +0000
+++ test/gtest/scopes/Registry/Registry_test.cpp	2014-04-08 16:22:25 +0000
@@ -21,6 +21,9 @@
 #include <unity/scopes/SearchMetadata.h>
 #include <unity/scopes/SearchListenerBase.h>
 #include <unity/scopes/CategorisedResult.h>
+#include <boost/filesystem.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/filesystem/operations.hpp>
 #include <functional>
 #include <gtest/gtest.h>
 #include <signal.h>
@@ -86,6 +89,23 @@
     }
 }
 
+bool wait_for_registry()
+{
+    const int num_retries = 10;
+    const boost::filesystem::path path("/tmp/RegistryTest");
+    for (int i = 0; i<num_retries; i++)
+    {
+        if (boost::filesystem::exists(path))
+        {
+            boost::system::error_code error;
+            auto st = boost::filesystem::status(path, error).type();
+            return st == boost::filesystem::file_type::socket_file;
+        }
+        sleep(1);
+    }
+    return false;
+}
+
 int main(int argc, char **argv)
 {
     ::testing::InitGoogleTest(&argc, argv);
@@ -102,6 +122,8 @@
     }
     else if (rpid > 0)
     {
+        // FIXME: remove this once we have async queries and can set arbitrary timeout when calling registry
+        EXPECT_TRUE(wait_for_registry());
         auto rc = RUN_ALL_TESTS();
         kill(rpid, SIGTERM);
         return rc;

=== modified file 'test/gtest/scopes/internal/ScopeMetadataImpl/ScopeMetadataImpl_test.cpp'
--- test/gtest/scopes/internal/ScopeMetadataImpl/ScopeMetadataImpl_test.cpp	2014-04-03 16:46:00 +0000
+++ test/gtest/scopes/internal/ScopeMetadataImpl/ScopeMetadataImpl_test.cpp	2014-04-08 16:22:25 +0000
@@ -234,6 +234,7 @@
 
     unique_ptr<ScopeMetadataImpl> mi(new ScopeMetadataImpl(&mw));
     mi->set_scope_id("scope_id");
+    mi->set_confinement_type(ConfinementType::UntrustedLocal);
     auto mw_proxy = mw.create_scope_proxy("identity", "endpoint");
     mi->set_proxy(ScopeImpl::create(mw_proxy, mw.runtime(), "scope_id"));
     mi->set_display_name("display_name");
@@ -249,8 +250,9 @@
     // Check that serialize() sets the map values correctly
     auto m = ScopeMetadataImpl::create(move(mi));
     auto var = m.serialize();
-    EXPECT_EQ(11u, var.size());
+    EXPECT_EQ(12u, var.size());
     EXPECT_EQ("scope_id", var["scope_id"].get_string());
+    EXPECT_EQ(ConfinementType::UntrustedLocal, (ConfinementType) var["confinement_type"].get_int());
     EXPECT_EQ("display_name", var["display_name"].get_string());
     EXPECT_EQ("description", var["description"].get_string());
     EXPECT_EQ("author", var["author"].get_string());
@@ -264,6 +266,7 @@
     // Make another instance from the VariantMap and check its fields
     ScopeMetadataImpl c(var, &mw);
     EXPECT_EQ("scope_id", c.scope_id());
+    EXPECT_EQ(ConfinementType::UntrustedLocal, c.confinement_type());
     EXPECT_EQ("identity", c.proxy()->identity());
     EXPECT_EQ("endpoint", c.proxy()->endpoint());
     EXPECT_EQ("display_name", c.display_name());
@@ -448,6 +451,7 @@
     m["author"] = "author";
 
     // Optional attributes
+    m["confinement_type"] = (int) ConfinementType::UntrustedLocal;
     m["art"] = "art";
     m["icon"] = "icon";
     m["search_hint"] = "search_hint";

=== modified file 'test/whitespace/CMakeLists.txt'
--- test/whitespace/CMakeLists.txt	2013-05-29 04:57:50 +0000
+++ test/whitespace/CMakeLists.txt	2014-04-08 16:22:25 +0000
@@ -2,4 +2,8 @@
 # Test that all source files, cmakefiles, etc. do not contain trailing whitespace.
 #
 
-add_test(whitespace ${CMAKE_CURRENT_SOURCE_DIR}/check_whitespace.py ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})
+add_test(whitespace
+  ${CMAKE_CURRENT_SOURCE_DIR}/check_whitespace.py
+  ${CMAKE_SOURCE_DIR}
+  ${CMAKE_BINARY_DIR}
+)

=== modified file 'test/whitespace/check_whitespace.py'
--- test/whitespace/check_whitespace.py	2013-06-27 08:38:02 +0000
+++ test/whitespace/check_whitespace.py	2014-04-08 16:22:25 +0000
@@ -80,7 +80,7 @@
 
 parser = argparse.ArgumentParser(description = 'Test that source files do not contain trailing whitespace.')
 parser.add_argument('dir', nargs = 1, help = 'The directory to (recursively) search for source files')
-parser.add_argument('ignore_prefix', nargs = '?', default=None,
+parser.add_argument('ignore_prefix', nargs = '+', default=None,
                     help = 'Ignore source files with a path that starts with the given prefix.')
 args = parser.parse_args()
 
@@ -93,16 +93,20 @@
 # directory and check them for trailing whitespace.
 
 directory = os.path.abspath(args.dir[0])
-ignore = args.ignore_prefix and os.path.abspath(args.ignore_prefix) or None
+ignores = args.ignore_prefix and args.ignore_prefix or []
 
 found_whitespace = False
 try:
     for root, dirs, files in os.walk(directory, onerror = raise_error):
         for file in files:
             path = os.path.join(root, file)
-            if not (ignore and path.startswith(ignore)) and pat.match(file):
-                if scan_for_bad_whitespace(path):
-                    found_whitespace = True
+            ignored = False
+            for ignore in ignores:
+                if ignore and path.startswith(os.path.abspath(ignore)):
+                    ignored = True
+                    break
+            if not ignored and pat.match(file) and scan_for_bad_whitespace(path):
+                found_whitespace = True
 
 except OSError as e:
     error("cannot create file list for \"" + dir + "\": " + e.strerror)

=== removed file 'test/whitespace/check_whitespace.sh'
--- test/whitespace/check_whitespace.sh	2013-06-27 08:38:02 +0000
+++ test/whitespace/check_whitespace.sh	1970-01-01 00:00:00 +0000
@@ -1,62 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright (C) 2013 Canonical Ltd
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License version 3 as
-# published by the Free Software Foundation.
-#
-# 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 Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Authored by: Michi Henning <[e-mail]>
-#
-
-#
-# Check that files below the specified directory don't have lines with trailing whitespace.
-# Print out a messsage for each file with trailing whitespace and exit with non-zero status
-# if any such file is found.
-#
-
-usage()
-{
-    echo "usage: check_whitespace.sh dir [ignore_dir]" >&2
-    exit 2
-}
-
-[ $# -lt 1 ] && usage
-[ $# -gt 2 ] && usage
-
-ignore="grep -v CMakeFile"
-
-[ $# -eq 2 ] && {
-    ignore="$ignore | grep -v \"$2\""
-}
-
-err=no
-for file in `find "$1" \
-    -name '*.cpp' -o \
-    -name '*.h' -o \
-    -name '*.py' -o \
-    -name '*.sh' -o \
-    -name 'CMakeLists.txt' -o \
-    -name '*.cmake'  \
-    | grep -v CMakeFiles \
-    | eval $ignore`
-do
-    grep -q '[  ]$' "$file"
-    [ $? -eq 0 ] && {
-        echo "$file: trailing whitespace"
-        err=yes
-    }
-done
-
-[ $err = yes ] && exit 1
-
-exit 0