Merge lp:~mardy/account-polld/external-plugins into lp:account-polld

[Alberto Mardegan]

Support out-of-process plugins

Existing Go plugins have been moved into the account-polld-plugins-go project.

Support out-of-process plugins

Existing Go plugins have been moved into the account-polld-plugins-go project.

[lp:~mardy/account-polld/external-plugins]

216. By Alberto Mardegan on 2016-09-19

Avoid cyclical deps

217. By Alberto Mardegan on 2016-09-20

Handle sigterm signal

This allows us to collect coverage results

218. By Alberto Mardegan on 2016-09-21

Fix reauthentication logic, add a test for that

Unmerged revisions

218. By Alberto Mardegan on 2016-09-21

Fix reauthentication logic, add a test for that

217. By Alberto Mardegan on 2016-09-20

Handle sigterm signal

This allows us to collect coverage results

216. By Alberto Mardegan on 2016-09-19

Avoid cyclical deps

215. By Alberto Mardegan on 2016-09-19

Update dependencies and description

214. By Alberto Mardegan on 2016-09-16

Update VCS link

213. By Alberto Mardegan on 2016-09-15

Tests: wait till method returns

212. By Alberto Mardegan on 2016-09-15

more of the same

211. By Alberto Mardegan on 2016-09-15

Tests: increase plugin timeout

210. By Alberto Mardegan on 2016-09-15

Fix push object path

209. By Alberto Mardegan on 2016-09-14

Make tests more robust

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2016-09-21 07:16:22 +0000
@@ -0,0 +1,12 @@
+*.moc
+Makefile*
+account-polld/account-polld
+click-hook/account-polld.hook
+debian/*.log
+debian/*.substvars
+debian/*-stamp
+debian/account-polld/
+debian/files
+moc_*
+tests/account-polld/tst_account_polld
+tests/click-hook/tst_click_hook

=== added file '.qmake.conf'
--- .qmake.conf	1970-01-01 00:00:00 +0000
+++ .qmake.conf	2016-09-21 07:16:22 +0000
@@ -0,0 +1,2 @@
+TOP_SRC_DIR = $$PWD
+TOP_BUILD_DIR = $$shadowed($$PWD)

=== added directory 'account-polld'
=== added file 'account-polld.pro'
--- account-polld.pro	1970-01-01 00:00:00 +0000
+++ account-polld.pro	2016-09-21 07:16:22 +0000
@@ -0,0 +1,11 @@
+include(common-vars.pri)
+include(common-project-config.pri)
+
+TEMPLATE = subdirs
+SUBDIRS = \
+    account-polld \
+    click-hook \
+    tests
+CONFIG += ordered
+
+include(common-installs-config.pri)

=== added file 'account-polld/account-polld.pro'
--- account-polld/account-polld.pro	1970-01-01 00:00:00 +0000
+++ account-polld/account-polld.pro	2016-09-21 07:16:22 +0000
@@ -0,0 +1,40 @@
+include(../common-project-config.pri)
+include($${TOP_SRC_DIR}/common-vars.pri)
+
+TEMPLATE = app
+TARGET = account-polld
+
+CONFIG += \
+    link_pkgconfig \
+    no_keywords \
+    qt
+
+QT += \
+    dbus
+
+PKGCONFIG += \
+    accounts-qt5 \
+    libsignon-qt5
+
+DEFINES += \
+    DEBUG_ENABLED \
+    PLUGIN_DATA_FILE=\\\"$${PLUGIN_DATA_FILE}\\\"
+
+SOURCES += \
+    account_manager.cpp \
+    app_manager.cpp \
+    debug.cpp \
+    main.cpp \
+    plugin.cpp \
+    poll_service.cpp \
+    push_client.cpp
+
+HEADERS += \
+    account_manager.h \
+    app_manager.h \
+    debug.h \
+    plugin.h \
+    poll_service.h \
+    push_client.h
+
+include($${TOP_SRC_DIR}/common-installs-config.pri)

=== added file 'account-polld/account_manager.cpp'
--- account-polld/account_manager.cpp	1970-01-01 00:00:00 +0000
+++ account-polld/account_manager.cpp	2016-09-21 07:16:22 +0000
@@ -0,0 +1,282 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "account_manager.h"
+
+#include "app_manager.h"
+#include "debug.h"
+
+#include <Accounts/Account>
+#include <Accounts/AccountService>
+#include <Accounts/Application>
+#include <Accounts/Manager>
+#include <Accounts/Service>
+#include <QMetaObject>
+#include <SignOn/AuthSession>
+#include <SignOn/Identity>
+#include <SignOn/SessionData>
+
+using namespace AccountPolld;
+
+namespace AccountPolld {
+
+class AccountManagerPrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(AccountManager)
+
+    struct AuthState {
+        QVariantMap lastAuthReply;
+        bool needNewToken;
+    };
+
+public:
+    AccountManagerPrivate(AccountManager *q, AppManager *appManager);
+    ~AccountManagerPrivate() {};
+
+    void loadApplications();
+    void activateAccount(Accounts::AccountService *as,
+                         const QString &appKey);
+    void accountReady(Accounts::AccountService *as, const QString &appKey,
+                      const QVariantMap &auth = QVariantMap());
+    static QString accountServiceKey(Accounts::AccountService *as);
+    static QString accountServiceKey(uint accountId, const QString &serviceId);
+
+    void markAuthFailure(const AccountData &data);
+    QVariantMap formatAuthReply(const Accounts::AuthData &authData,
+                                const QVariantMap &reply) const;
+
+public Q_SLOTS:
+    void operationFinished();
+
+private:
+    Accounts::Manager m_manager;
+    AppManager *m_appManager;
+    Applications m_apps;
+    QHash<QString,Accounts::Application> m_accountApps;
+    QHash<QString,AuthState> m_authStates;
+    int m_pendingOperations;
+    AccountManager *q_ptr;
+};
+
+uint qHash(const AccountData &data) {
+    return ::qHash(data.pluginId) + ::qHash(data.accountId) +
+        ::qHash(data.serviceId);
+}
+
+} // namespace
+
+AccountManagerPrivate::AccountManagerPrivate(AccountManager *q,
+                                             AppManager *appManager):
+    QObject(q),
+    m_appManager(appManager),
+    m_pendingOperations(0),
+    q_ptr(q)
+{
+    qRegisterMetaType<AccountData>("AccountData");
+}
+
+QString AccountManagerPrivate::accountServiceKey(Accounts::AccountService *as)
+{
+    return accountServiceKey(as->account()->id(), as->service().name());
+}
+
+QString AccountManagerPrivate::accountServiceKey(uint accountId, const QString &serviceId)
+{
+    return QString("%1-%2").arg(accountId).arg(serviceId);
+}
+
+void AccountManagerPrivate::loadApplications()
+{
+    m_accountApps.clear();
+
+    m_apps = m_appManager->applications();
+    for (auto i = m_apps.constBegin(); i != m_apps.constEnd(); i++) {
+        Accounts::Application app = m_manager.application(i.value().appId);
+        if (app.isValid()) {
+            m_accountApps.insert(i.key(), app);
+        } else {
+            DEBUG() << "Application not found:" << i.value().appId;
+        }
+    }
+}
+
+QVariantMap AccountManagerPrivate::formatAuthReply(const Accounts::AuthData &authData,
+                                                   const QVariantMap &reply) const
+{
+    QVariantMap formattedReply(reply);
+
+    QString mechanism = authData.mechanism();
+    const QVariantMap &parameters = authData.parameters();
+    if (mechanism == "HMAC-SHA1" || mechanism == "PLAINTEXT") {
+        /* For OAuth 1.0, let's return also the Consumer key and secret along
+         * with the reply. */
+        formattedReply["ClientId"] = parameters.value("ConsumerKey");
+        formattedReply["ClientSecret"] = parameters.value("ConsumerSecret");
+    } else if (mechanism == "web_server" || mechanism == "user_agent") {
+        formattedReply["ClientId"] = parameters.value("ClientId");
+        formattedReply["ClientSecret"] = parameters.value("ClientId");
+    }
+
+    return formattedReply;
+}
+
+void AccountManagerPrivate::accountReady(Accounts::AccountService *as,
+                                         const QString &appKey,
+                                         const QVariantMap &auth)
+{
+    Q_Q(AccountManager);
+    AccountData accountData;
+    accountData.pluginId = appKey;
+    accountData.accountId = as->account()->id();
+    accountData.serviceId = as->service().name();
+    accountData.auth = auth;
+    QMetaObject::invokeMethod(q, "accountReady", Qt::QueuedConnection,
+                              Q_ARG(AccountData, accountData));
+}
+
+void AccountManagerPrivate::activateAccount(Accounts::AccountService *as,
+                                            const QString &appKey)
+{
+    const AppData &data = m_apps[appKey];
+    if (data.needsAuthData) {
+        Accounts::AuthData authData = as->authData();
+        QString key = accountServiceKey(as);
+
+        auto identity =
+            SignOn::Identity::existingIdentity(authData.credentialsId(), as);
+        auto authSession = identity->createSession(authData.method());
+        QObject::connect(authSession, &SignOn::AuthSession::response,
+                         [this,as,appKey](const SignOn::SessionData &reply) {
+            as->deleteLater();
+
+            QVariantMap authReply = formatAuthReply(as->authData(), reply.toMap());
+            AuthState &authState = m_authStates[accountServiceKey(as)];
+            if (authState.needNewToken && authReply == authState.lastAuthReply) {
+                /* This account won't work, don't even check it */
+                operationFinished();
+                return;
+            }
+
+            authState.needNewToken = false;
+            accountReady(as, appKey, authReply);
+            operationFinished();
+        });
+        QObject::connect(authSession, &SignOn::AuthSession::error,
+                         [this,as](const SignOn::Error &error) {
+            as->deleteLater();
+            operationFinished();
+            DEBUG() << "authentication error:" << error.message();
+        });
+
+        AuthState &authState = m_authStates[key];
+
+        QVariantMap sessionData = authData.parameters();
+        sessionData["UiPolicy"] = SignOn::NoUserInteractionPolicy;
+        if (authState.needNewToken) {
+            sessionData["ForceTokenRefresh"] = true;
+        }
+        m_pendingOperations++;
+        authSession->process(sessionData, authData.mechanism());
+    } else {
+        accountReady(as, appKey);
+    }
+}
+
+void AccountManagerPrivate::markAuthFailure(const AccountData &data)
+{
+    QString key = accountServiceKey(data.accountId, data.serviceId);
+    AuthState &authState = m_authStates[key];
+    authState.lastAuthReply = data.auth;
+    authState.needNewToken = true;
+}
+
+void AccountManagerPrivate::operationFinished()
+{
+    Q_Q(AccountManager);
+    m_pendingOperations--;
+    if (m_pendingOperations == 0) {
+        /* since the accountReady signal is sent in a queued connection, this
+         * signal must also be sent in that way, in order to be delivered after
+         * all the accountReady signals. */
+        QMetaObject::invokeMethod(q, "finished", Qt::QueuedConnection);
+    }
+}
+
+AccountManager::AccountManager(AppManager *appManager, QObject *parent):
+    QObject(parent),
+    d_ptr(new AccountManagerPrivate(this, appManager))
+{
+}
+
+AccountManager::~AccountManager()
+{
+    delete d_ptr;
+}
+
+void AccountManager::listAccounts()
+{
+    Q_D(AccountManager);
+
+    d->loadApplications();
+
+    d->m_pendingOperations++;
+
+    Accounts::AccountIdList accountIds = d->m_manager.accountListEnabled();
+    for (Accounts::AccountId accountId: accountIds) {
+        Accounts::Account *account = d->m_manager.account(accountId);
+        if (Q_UNLIKELY(!account)) continue;
+
+        Accounts::ServiceList services = account->enabledServices();
+
+        /* check if we have some plugins registered for this service */
+        for (auto i = d->m_accountApps.constBegin();
+             i != d->m_accountApps.constEnd(); i++) {
+            for (Accounts::Service &service: services) {
+                /* Check if the application can use this service */
+                if (i.value().serviceUsage(service).isEmpty()) {
+                    continue;
+                }
+
+                /* Check if the plugin manifest allows using this service */
+                const AppData &appData = d->m_apps[i.key()];
+                if (!appData.services.isEmpty() &&
+                    !appData.services.contains(service.name())) {
+                    DEBUG() << "Skipping service" << service.name() <<
+                        "for plugin" << i.key();
+                    continue;
+                }
+
+                auto *as = new Accounts::AccountService(account, service);
+                d->activateAccount(as, i.key());
+            }
+        }
+    }
+
+    d->operationFinished();
+}
+
+void AccountManager::markAuthFailure(const AccountData &data)
+{
+    Q_D(AccountManager);
+    d->markAuthFailure(data);
+}
+
+#include "account_manager.moc"

=== added file 'account-polld/account_manager.h'
--- account-polld/account_manager.h	1970-01-01 00:00:00 +0000
+++ account-polld/account_manager.h	2016-09-21 07:16:22 +0000
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#ifndef AP_ACCOUNT_MANAGER_H
+#define AP_ACCOUNT_MANAGER_H
+
+#include <QObject>
+#include <QVariantMap>
+
+namespace AccountPolld {
+
+struct AccountData {
+    QString pluginId;
+    uint accountId;
+    QString serviceId;
+    QVariantMap auth;
+
+    /* This is needed for using the struct as a QHash key; the "auth" map is
+     * intentionally omitted from the comparison as we don't want to use that
+     * as a key, too. */
+    bool operator==(const AccountData &other) const {
+        return pluginId == other.pluginId && accountId == other.accountId &&
+            serviceId == other.serviceId;
+    }
+};
+
+uint qHash(const AccountData &data);
+
+class AppManager;
+
+class AccountManagerPrivate;
+class AccountManager: public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit AccountManager(AppManager *appManager, QObject *parent = 0);
+    ~AccountManager();
+
+    /* Scan for accounts; for each valid account, the accountReady() signal
+     * will be emitted. A finished() signal will be emitted last. */
+    void listAccounts();
+
+    /* Call when the authentication data for an account is refused by the
+     * server because of token expiration */
+    void markAuthFailure(const AccountData &data);
+
+Q_SIGNALS:
+    void accountReady(const AccountData &data);
+    void finished();
+
+private:
+    AccountManagerPrivate *d_ptr;
+    Q_DECLARE_PRIVATE(AccountManager)
+};
+
+} // namespace
+
+Q_DECLARE_METATYPE(AccountPolld::AccountData)
+
+#endif // AP_ACCOUNT_MANAGER_H

=== added file 'account-polld/app_manager.cpp'
--- account-polld/app_manager.cpp	1970-01-01 00:00:00 +0000
+++ account-polld/app_manager.cpp	2016-09-21 07:16:22 +0000
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "debug.h"
+#include "app_manager.h"
+
+#include <QFile>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QStandardPaths>
+
+using namespace AccountPolld;
+
+namespace AccountPolld {
+
+class AppManagerPrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(AppManager)
+
+public:
+    AppManagerPrivate(AppManager *q);
+    ~AppManagerPrivate() {};
+
+    Applications readPluginData() const;
+
+private:
+    QString m_dataFilePath;
+    AppManager *q_ptr;
+};
+
+} // namespace
+
+AppManagerPrivate::AppManagerPrivate(AppManager *q):
+    QObject(q),
+    q_ptr(q)
+{
+    const QString localShare =
+        QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation);
+    m_dataFilePath = localShare + "/" PLUGIN_DATA_FILE;
+}
+
+Applications AppManagerPrivate::readPluginData() const
+{
+    Applications apps;
+
+    QFile file(m_dataFilePath);
+    if (!file.open(QIODevice::ReadOnly)) return apps;
+
+    QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
+    file.close();
+
+    QJsonObject mainObject = doc.object();
+    for (auto i = mainObject.begin(); i != mainObject.end(); i++) {
+        QJsonObject appObject = i.value().toObject();
+
+        AppData data;
+        data.profile = appObject.value("profile").toString();
+        data.execLine = appObject.value("exec").toString();
+        data.appId = appObject.value("appId").toString();
+        QJsonArray services = appObject.value("services").toArray();
+        for (const QJsonValue &v: services) {
+            data.services.append(v.toString());
+        }
+        data.interval = appObject.value("interval").toInt();
+        data.needsAuthData = appObject.value("needsAuthData").toBool();
+
+        if (data.profile.isEmpty() ||
+            data.execLine.isEmpty() ||
+            data.appId.isEmpty()) {
+            qWarning() << "Incomplete plugin data:" <<
+                QJsonDocument(appObject).toJson(QJsonDocument::Compact);
+            continue;
+        }
+
+        apps.insert(i.key(), data);
+    }
+
+    return apps;
+}
+
+AppManager::AppManager(QObject *parent):
+    QObject(parent),
+    d_ptr(new AppManagerPrivate(this))
+{
+}
+
+AppManager::~AppManager()
+{
+    delete d_ptr;
+}
+
+Applications AppManager::applications() const
+{
+    Q_D(const AppManager);
+
+    return d->readPluginData();
+}
+
+#include "app_manager.moc"

=== added file 'account-polld/app_manager.h'
--- account-polld/app_manager.h	1970-01-01 00:00:00 +0000
+++ account-polld/app_manager.h	2016-09-21 07:16:22 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#ifndef AP_APP_MANAGER_H
+#define AP_APP_MANAGER_H
+
+#include <QObject>
+#include <QStringList>
+#include <QHash>
+
+namespace AccountPolld {
+
+struct AppData {
+    QString profile; // apparmor label for the plugin process
+    QString execLine;
+    QString appId; // appId, for matching with OA
+    QStringList services;
+    int interval;
+    bool needsAuthData;
+};
+
+typedef QHash<QString,AppData> Applications;
+
+class AppManagerPrivate;
+
+class AppManager: public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit AppManager(QObject *parent = 0);
+    ~AppManager();
+
+    Applications applications() const;
+
+private:
+    AppManagerPrivate *d_ptr;
+    Q_DECLARE_PRIVATE(AppManager)
+};
+
+} // namespace
+
+#endif // AP_APP_MANAGER_H

=== added file 'account-polld/debug.cpp'
--- account-polld/debug.cpp	1970-01-01 00:00:00 +0000
+++ account-polld/debug.cpp	2016-09-21 07:16:22 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "debug.h"
+
+int appLoggingLevel = 1; // criticals
+
+void setLoggingLevel(int level)
+{
+    appLoggingLevel = level;
+}
+

=== added file 'account-polld/debug.h'
--- account-polld/debug.h	1970-01-01 00:00:00 +0000
+++ account-polld/debug.h	2016-09-21 07:16:22 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+#ifndef AP_DEBUG_H
+#define AP_DEBUG_H
+
+#include <QDebug>
+
+/* 0 - fatal, 1 - critical(default), 2 - info/debug */
+extern int appLoggingLevel;
+
+static inline bool debugEnabled()
+{
+    return appLoggingLevel >= 2;
+}
+
+static inline int loggingLevel()
+{
+    return appLoggingLevel;
+}
+
+void setLoggingLevel(int level);
+
+#ifdef DEBUG_ENABLED
+    #define DEBUG() \
+        if (debugEnabled()) qDebug() << __FILE__ << __LINE__ << __func__
+#else
+    #define DEBUG() while (0) qDebug()
+#endif
+
+#endif // AP_DEBUG_H

=== added file 'account-polld/main.cpp'
--- account-polld/main.cpp	1970-01-01 00:00:00 +0000
+++ account-polld/main.cpp	2016-09-21 07:16:22 +0000
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include <QCoreApplication>
+#include <QDBusConnection>
+#include <QProcessEnvironment>
+#include <QSettings>
+#include <signal.h>
+
+#include "debug.h"
+#include "poll_service.h"
+
+
+static void signalHandler(int)
+{
+    QCoreApplication::quit();
+}
+
+int main(int argc, char **argv)
+{
+    QCoreApplication app(argc, argv);
+
+    signal(SIGTERM, signalHandler);
+
+    QSettings settings("account-polld");
+
+    /* read environment variables */
+    QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
+    if (environment.contains(QLatin1String("AP_LOGGING_LEVEL"))) {
+        bool isOk;
+        int value = environment.value(
+            QLatin1String("AP_LOGGING_LEVEL")).toInt(&isOk);
+        if (isOk)
+            setLoggingLevel(value);
+    } else {
+        setLoggingLevel(settings.value("LoggingLevel", 1).toInt());
+    }
+
+    QDBusConnection connection = QDBusConnection::sessionBus();
+
+    auto service = new AccountPolld::PollService();
+    connection.registerObject(ACCOUNT_POLLD_OBJECT_PATH, service,
+                              QDBusConnection::ExportAllContents);
+    connection.registerService(ACCOUNT_POLLD_SERVICE_NAME);
+
+    int ret = app.exec();
+
+    connection.unregisterService(ACCOUNT_POLLD_SERVICE_NAME);
+    connection.unregisterObject(ACCOUNT_POLLD_OBJECT_PATH);
+    delete service;
+
+    return ret;
+}
+

=== added file 'account-polld/plugin.cpp'
--- account-polld/plugin.cpp	1970-01-01 00:00:00 +0000
+++ account-polld/plugin.cpp	2016-09-21 07:16:22 +0000
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "plugin.h"
+
+#include "debug.h"
+
+#include <QByteArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonParseError>
+#include <QProcess>
+#include <QTimer>
+#include <signal.h>
+#include <sys/types.h>
+
+using namespace AccountPolld;
+
+namespace AccountPolld {
+
+class PluginPrivate: public QProcess
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(Plugin)
+
+public:
+    PluginPrivate(Plugin *q, const QString &execLine, const QString &profile);
+    ~PluginPrivate() {};
+
+public Q_SLOTS:
+    void onReadyRead();
+    void killPlugin();
+
+private:
+    QString m_execLine;
+    QString m_profile;
+    QTimer m_timer;
+    QByteArray m_inputBuffer;
+    bool m_sigtermSent;
+    Plugin *q_ptr;
+};
+
+} // namespace
+
+PluginPrivate::PluginPrivate(Plugin *q,
+                             const QString &execLine,
+                             const QString &profile):
+    QProcess(q),
+    m_execLine(execLine),
+    m_profile(profile),
+    m_sigtermSent(false),
+    q_ptr(q)
+{
+    int killTime = 10;
+    QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
+    if (environment.contains("AP_PLUGIN_TIMEOUT")) {
+        killTime = environment.value("AP_PLUGIN_TIMEOUT").toInt();
+    }
+    m_timer.setInterval(killTime * 1000);
+    m_timer.setSingleShot(true);
+
+    setProcessChannelMode(QProcess::ForwardedErrorChannel);
+    QObject::connect(this, SIGNAL(started()), &m_timer, SLOT(start()));
+    QObject::connect(this, SIGNAL(started()), q, SIGNAL(ready()));
+    QObject::connect(this, SIGNAL(finished(int,QProcess::ExitStatus)),
+                     q, SIGNAL(finished()));
+    QObject::connect(this, SIGNAL(readyReadStandardOutput()),
+                     this, SLOT(onReadyRead()));
+    QObject::connect(&m_timer, SIGNAL(timeout()), this, SLOT(killPlugin()));
+}
+
+void PluginPrivate::onReadyRead()
+{
+    Q_Q(Plugin);
+
+    m_inputBuffer.append(readAllStandardOutput());
+    QJsonParseError error;
+    auto doc = QJsonDocument::fromJson(m_inputBuffer, &error);
+    if (error.error == QJsonParseError::NoError) {
+        m_inputBuffer.clear();
+        Q_EMIT q->response(doc.object());
+    }
+
+    /* otherwise continue reasing, the object is probably uncomplete */
+}
+
+void PluginPrivate::killPlugin()
+{
+    pid_t pid = processId();
+    DEBUG() << "killing plugin" << pid;
+    if (!m_sigtermSent) {
+        ::kill(pid, SIGTERM);
+        m_sigtermSent = true;
+        m_timer.setInterval(1 * 1000);
+        m_timer.start();
+    } else {
+        ::kill(pid, SIGKILL);
+    }
+}
+
+Plugin::Plugin(const QString &execLine, const QString &profile,
+               QObject *parent):
+    QObject(parent),
+    d_ptr(new PluginPrivate(this, execLine, profile))
+{
+}
+
+Plugin::~Plugin()
+{
+    delete d_ptr;
+}
+
+void Plugin::run()
+{
+    Q_D(Plugin);
+
+    QString command;
+
+    if (d->m_profile != "unconfined") {
+        command = QString("aa-exec-click -p %1 -- ").arg(d->m_profile);
+    }
+
+    command.append(d->m_execLine);
+
+    DEBUG() << "Starting" << command;
+    d->start(command);
+}
+
+void Plugin::poll(const QJsonObject &pollData)
+{
+    Q_D(Plugin);
+
+    DEBUG() << "Plugin input:" << pollData;
+    d->write(QJsonDocument(pollData).toJson(QJsonDocument::Compact));
+    d->write("\n");
+}
+
+#include "plugin.moc"

=== added file 'account-polld/plugin.h'
--- account-polld/plugin.h	1970-01-01 00:00:00 +0000
+++ account-polld/plugin.h	2016-09-21 07:16:22 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#ifndef AP_PLUGIN_H
+#define AP_PLUGIN_H
+
+#include <QObject>
+
+class QJsonObject;
+
+namespace AccountPolld {
+
+class PluginPrivate;
+class Plugin: public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit Plugin(const QString &execLine, const QString &profile,
+                    QObject *parent = 0);
+    ~Plugin();
+
+    void run();
+    void poll(const QJsonObject &pollData);
+
+Q_SIGNALS:
+    void ready();
+    void response(const QJsonObject &resp);
+    void finished();
+
+private:
+    PluginPrivate *d_ptr;
+    Q_DECLARE_PRIVATE(Plugin)
+};
+
+} // namespace
+
+#endif // AP_PLUGIN_H

=== added file 'account-polld/poll_service.cpp'
--- account-polld/poll_service.cpp	1970-01-01 00:00:00 +0000
+++ account-polld/poll_service.cpp	2016-09-21 07:16:22 +0000
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "debug.h"
+#include "account_manager.h"
+#include "app_manager.h"
+#include "poll_service.h"
+#include "plugin.h"
+#include "push_client.h"
+
+#include <QDateTime>
+#include <QDBusArgument>
+#include <QDBusConnection>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QVariantMap>
+
+using namespace AccountPolld;
+
+namespace AccountPolld {
+
+class PollServicePrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(PollService)
+
+    struct PollData {
+        QDateTime lastPolled;
+    };
+
+public:
+    PollServicePrivate(PollService *q);
+    ~PollServicePrivate() {};
+
+    QJsonObject preparePluginInput(const AccountData &accountData,
+                                   const AppData &appData);
+    void handleResponse(const QJsonObject &response, const QString &appId,
+                        const AccountData &accountData);
+
+private Q_SLOTS:
+    void poll();
+    void onAccountReady(const AccountData &data);
+    void operationFinished();
+
+private:
+    AppManager m_appManager;
+    AccountManager m_accountManager;
+    PushClient m_pushClient;
+    QHash<AccountData,PollData> m_polls;
+    int m_pendingOperations;
+    PollService *q_ptr;
+};
+
+} // namespace
+
+PollServicePrivate::PollServicePrivate(PollService *q):
+    QObject(q),
+    m_accountManager(&m_appManager),
+    m_pendingOperations(0),
+    q_ptr(q)
+{
+    QObject::connect(&m_accountManager,
+                     SIGNAL(accountReady(const AccountData&)),
+                     this,
+                     SLOT(onAccountReady(const AccountData&)));
+    QObject::connect(&m_accountManager, SIGNAL(finished()),
+                     this, SLOT(operationFinished()));
+}
+
+void PollServicePrivate::operationFinished()
+{
+    Q_Q(PollService);
+    m_pendingOperations--;
+    if (m_pendingOperations == 0) {
+        Q_EMIT q->Done();
+    }
+}
+
+QJsonObject
+PollServicePrivate::preparePluginInput(const AccountData &accountData,
+                                       const AppData &appData)
+{
+    QJsonObject object;
+    object["helperId"] = accountData.pluginId;
+    object["appId"] = appData.appId;
+    object["accountId"] = int(accountData.accountId);
+    if (appData.needsAuthData) {
+        object["auth"] = QJsonObject::fromVariantMap(accountData.auth);
+    }
+    return object;
+}
+
+void PollServicePrivate::handleResponse(const QJsonObject &response,
+                                        const QString &appId,
+                                        const AccountData &accountData)
+{
+    DEBUG() << "Plugin response:" << response;
+    QJsonObject error = response["error"].toObject();
+    if (error["code"].toString() == "ERR_INVALID_AUTH") {
+        m_accountManager.markAuthFailure(accountData);
+        return;
+    }
+
+    QJsonArray notifications = response["notifications"].toArray();
+    for (const QJsonValue &v: notifications) {
+        m_pushClient.post(appId, v.toObject());
+    }
+}
+
+void PollServicePrivate::poll()
+{
+    m_pendingOperations++;
+    m_accountManager.listAccounts();
+}
+
+void PollServicePrivate::onAccountReady(const AccountData &accountData)
+{
+    Applications apps = m_appManager.applications();
+    const auto i = apps.find(accountData.pluginId);
+    if (i == apps.end()) {
+        qWarning() << "Got account for plugin, but no app linked:" << accountData.pluginId;
+        return;
+    }
+
+    const AppData &appData = i.value();
+
+    /* Check that we are not polling more often than what the application
+     * wishes to */
+    PollData &pollData = m_polls[accountData];
+    QDateTime now = QDateTime::currentDateTime();
+    if (pollData.lastPolled.isValid() &&
+        pollData.lastPolled.secsTo(now) < appData.interval) {
+        DEBUG() << "Skipping poll, interval not yet expired:" << accountData.pluginId;
+        return;
+    }
+    pollData.lastPolled = now;
+
+    QJsonObject pluginInput = preparePluginInput(accountData, appData);
+
+    Plugin *plugin = new Plugin(appData.execLine, appData.profile, this);
+    QObject::connect(plugin, SIGNAL(finished()), plugin, SLOT(deleteLater()));
+    QObject::connect(plugin, SIGNAL(finished()), this, SLOT(operationFinished()));
+    QObject::connect(plugin, &Plugin::ready,
+                     [plugin, pluginInput]() { plugin->poll(pluginInput); });
+    QObject::connect(plugin, &Plugin::response,
+                     [this, accountData, appData](const QJsonObject &resp) {
+        handleResponse(resp, appData.appId, accountData);
+    });
+
+    m_pendingOperations++;
+    plugin->run();
+}
+
+PollService::PollService(QObject *parent):
+    QObject(parent),
+    d_ptr(new PollServicePrivate(this))
+{
+}
+
+PollService::~PollService()
+{
+    delete d_ptr;
+}
+
+void PollService::Poll()
+{
+    Q_D(PollService);
+
+    DEBUG() << "Got Poll";
+    QMetaObject::invokeMethod(d, "poll", Qt::QueuedConnection);
+}
+
+#include "poll_service.moc"

=== added file 'account-polld/poll_service.h'
--- account-polld/poll_service.h	1970-01-01 00:00:00 +0000
+++ account-polld/poll_service.h	2016-09-21 07:16:22 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#ifndef AP_POLL_SERVICE_H
+#define AP_POLL_SERVICE_H
+
+#include <QDBusContext>
+#include <QDBusMessage>
+#include <QObject>
+
+namespace AccountPolld {
+
+#define ACCOUNT_POLLD_OBJECT_PATH \
+    QStringLiteral("/com/ubuntu/AccountPolld")
+#define ACCOUNT_POLLD_SERVICE_NAME \
+    QStringLiteral("com.ubuntu.AccountPolld")
+
+class PollServicePrivate;
+
+class PollService: public QObject, protected QDBusContext
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "com.ubuntu.AccountPolld")
+    Q_CLASSINFO("D-Bus Introspection", ""
+"  <interface name=\"com.ubuntu.AccountPolld\">\n"
+"    <method name=\"Poll\" />\n"
+"    <signal name=\"Done\" />\n"
+"  </interface>\n"
+        "")
+
+public:
+    explicit PollService(QObject *parent = 0);
+    ~PollService();
+
+public Q_SLOTS:
+    void Poll();
+
+Q_SIGNALS:
+    void Done();
+
+private:
+    PollServicePrivate *d_ptr;
+    Q_DECLARE_PRIVATE(PollService)
+};
+
+} // namespace
+
+#endif // AP_POLL_SERVICE_H

=== added file 'account-polld/push_client.cpp'
--- account-polld/push_client.cpp	1970-01-01 00:00:00 +0000
+++ account-polld/push_client.cpp	2016-09-21 07:16:22 +0000
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "push_client.h"
+
+#include "debug.h"
+
+#include <QByteArray>
+#include <QDBusConnection>
+#include <QDBusMessage>
+#include <QJsonDocument>
+#include <QJsonObject>
+
+using namespace AccountPolld;
+
+namespace AccountPolld {
+
+class PushClientPrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(PushClient)
+
+public:
+    PushClientPrivate(PushClient *q);
+    ~PushClientPrivate() {};
+
+    static QByteArray makeObjectPath(const QString &appId);
+
+private:
+    QDBusConnection m_conn;
+    PushClient *q_ptr;
+};
+
+} // namespace
+
+PushClientPrivate::PushClientPrivate(PushClient *q):
+    QObject(q),
+    m_conn(QDBusConnection::sessionBus()),
+    q_ptr(q)
+{
+}
+
+QByteArray PushClientPrivate::makeObjectPath(const QString &appId)
+{
+    QByteArray path(QByteArrayLiteral("/com/ubuntu/Postal/"));
+
+    QByteArray pkg = appId.split('_').first().toUtf8();
+    for (int i = 0; i < pkg.count(); i++) {
+        char buffer[10];
+        char c = pkg[i];
+        switch (c) {
+        case '+':
+        case '.':
+        case '-':
+        case ':':
+        case '~':
+        case '_':
+            sprintf(buffer, "_%.2x", c);
+            path += buffer;
+            break;
+        default:
+            path += c;
+        }
+    }
+    return path;
+}
+
+PushClient::PushClient(QObject *parent):
+    QObject(parent),
+    d_ptr(new PushClientPrivate(this))
+{
+}
+
+PushClient::~PushClient()
+{
+    delete d_ptr;
+}
+
+void PushClient::post(const QString &appId, const QJsonObject &message)
+{
+    Q_D(PushClient);
+
+    QByteArray objectPath = d->makeObjectPath(appId);
+    QDBusMessage msg = QDBusMessage::createMethodCall("com.ubuntu.Postal",
+                                                      objectPath,
+                                                      "com.ubuntu.Postal",
+                                                      "Post");
+    msg << appId;
+    QByteArray data = QJsonDocument(message).toJson(QJsonDocument::Compact);
+    msg << QString::fromUtf8(data);
+
+    d->m_conn.send(msg);
+}
+
+#include "push_client.moc"

=== added file 'account-polld/push_client.h'
--- account-polld/push_client.h	1970-01-01 00:00:00 +0000
+++ account-polld/push_client.h	2016-09-21 07:16:22 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of account-polld
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#ifndef AP_PUSH_CLIENT_H
+#define AP_PUSH_CLIENT_H
+
+#include <QObject>
+
+class QJsonObject;
+
+namespace AccountPolld {
+
+class PushClientPrivate;
+class PushClient: public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit PushClient(QObject *parent = 0);
+    ~PushClient();
+
+    void post(const QString &appId, const QJsonObject &message);
+
+private:
+    PushClientPrivate *d_ptr;
+    Q_DECLARE_PRIVATE(PushClient)
+};
+
+} // namespace
+
+#endif // AP_PUSH_CLIENT_H

=== removed directory 'accounts'
=== removed file 'accounts/account-watcher.c'
--- accounts/account-watcher.c	2016-08-02 14:34:52 +0000
+++ accounts/account-watcher.c	1970-01-01 00:00:00 +0000
@@ -1,302 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-#include <stdio.h>
-
-#include <glib.h>
-#include <libaccounts-glib/accounts-glib.h>
-#include <libsignon-glib/signon-glib.h>
-
-#include "account-watcher.h"
-
-/* #define DEBUG */
-#ifdef DEBUG
-#  define trace(...) fprintf(stderr, __VA_ARGS__)
-#else
-#  define trace(...)
-#endif
-
-struct _AccountWatcher {
-    AgManager *manager;
-    /* A hash table of the enabled accounts we know of.
-     * Keys are "<accountId>/<serviceName>", and AccountInfo structs as values.
-     */
-    GHashTable *services;
-
-    /* List of supported services' IDs */
-    GSList *supported_services;
-
-    AccountEnabledCallback callback;
-    void *user_data;
-};
-
-typedef struct _AccountInfo AccountInfo;
-struct _AccountInfo {
-    AccountWatcher *watcher;
-    /* Manage signin session for account */
-    AgAccountService *account_service;
-    SignonAuthSession *session;
-    GVariant *auth_params;
-    GVariant *session_data;
-
-    AgAccountId account_id;
-};
-
-static void account_info_clear_login(AccountInfo *info) {
-    if (info->session_data) {
-        g_variant_unref(info->session_data);
-        info->session_data = NULL;
-    }
-    if (info->auth_params) {
-        g_variant_unref(info->auth_params);
-        info->auth_params = NULL;
-    }
-    if (info->session) {
-        signon_auth_session_cancel(info->session);
-        g_object_unref(info->session);
-        info->session = NULL;
-    }
-}
-
-static void account_info_free(AccountInfo *info) {
-    account_info_clear_login(info);
-    if (info->account_service) {
-        g_object_unref(info->account_service);
-        info->account_service = NULL;
-    }
-    g_free(info);
-}
-
-static void account_info_notify(AccountInfo *info, GError *error) {
-    AgService *service = ag_account_service_get_service(info->account_service);
-    const char *service_name = ag_service_get_name(service);
-    const char *service_type = ag_service_get_service_type(service);
-    char *client_id = NULL;
-    char *client_secret = NULL;
-    char *access_token = NULL;
-    char *token_secret = NULL;
-    char *secret = NULL;
-    char *user_name = NULL;
-
-    if (info->auth_params != NULL) {
-        /* Look up OAuth 2 parameters, falling back to OAuth 1 names */
-        g_variant_lookup(info->auth_params, "ClientId", "&s", &client_id);
-        g_variant_lookup(info->auth_params, "ClientSecret", "&s", &client_secret);
-        if (client_id == NULL) {
-            g_variant_lookup(info->auth_params, "ConsumerKey", "&s", &client_id);
-        }
-        if (client_secret == NULL) {
-            g_variant_lookup(info->auth_params, "ConsumerSecret", "&s", &client_secret);
-        }
-    }
-    if (info->session_data != NULL) {
-        g_variant_lookup(info->session_data, "AccessToken", "&s", &access_token);
-        g_variant_lookup(info->session_data, "TokenSecret", "&s", &token_secret);
-        g_variant_lookup(info->session_data, "Secret", "&s", &secret);
-        g_variant_lookup(info->session_data, "UserName", "&s", &user_name);
-    }
-
-    info->watcher->callback(info->watcher,
-                            info->account_id,
-                            service_type,
-                            service_name,
-                            error,
-                            TRUE,
-                            client_id,
-                            client_secret,
-                            access_token,
-                            token_secret,
-                            user_name,
-                            secret,
-                            info->watcher->user_data);
-}
-
-static void account_info_login_cb(GObject *source, GAsyncResult *result, void *user_data) {
-    SignonAuthSession *session = (SignonAuthSession *)source;
-    AccountInfo *info = (AccountInfo *)user_data;
-
-    trace("Authentication for account %u complete\n", info->account_id);
-
-    GError *error = NULL;
-    info->session_data = signon_auth_session_process_finish(session, result, &error);
-    account_info_notify(info, error);
-
-    if (error != NULL) {
-        trace("Authentication failed: %s\n", error->message);
-        g_error_free(error);
-    }
-}
-
-static void account_info_login(AccountInfo *info) {
-    account_info_clear_login(info);
-
-    AgAuthData *auth_data = ag_account_service_get_auth_data(info->account_service);
-    GError *error = NULL;
-    trace("Starting authentication session for account %u\n", info->account_id);
-    info->session = signon_auth_session_new(
-        ag_auth_data_get_credentials_id(auth_data),
-        ag_auth_data_get_method(auth_data), &error);
-    if (error != NULL) {
-        trace("Could not set up auth session: %s\n", error->message);
-        account_info_notify(info, error);
-        g_error_free(error);
-        g_object_unref(auth_data);
-        return;
-    }
-
-    /* Tell libsignon-glib not to open a trust session as we have no UI */
-    GVariantBuilder builder;
-    g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);
-    g_variant_builder_add(&builder, "{sv}",
-        SIGNON_SESSION_DATA_UI_POLICY,
-        g_variant_new_int32(SIGNON_POLICY_NO_USER_INTERACTION));
-
-    info->auth_params = g_variant_ref_sink(
-        ag_auth_data_get_login_parameters(
-            auth_data,
-            g_variant_builder_end(&builder)));
-
-    signon_auth_session_process_async(
-        info->session,
-        info->auth_params,
-        ag_auth_data_get_mechanism(auth_data),
-        NULL, /* cancellable */
-        account_info_login_cb, info);
-    ag_auth_data_unref(auth_data);
-}
-
-static AccountInfo *account_info_new(AccountWatcher *watcher, AgAccountService *account_service) {
-    AccountInfo *info = g_new0(AccountInfo, 1);
-    info->watcher = watcher;
-    info->account_service = g_object_ref(account_service);
-
-    AgAccount *account = ag_account_service_get_account(account_service);
-    g_object_get(account, "id", &info->account_id, NULL);
-
-    return info;
-}
-
-static gboolean service_is_supported(AccountWatcher *watcher,
-                                     const char *service_id)
-{
-    GSList *node = g_slist_find_custom(watcher->supported_services,
-                                       service_id,
-                                       (GCompareFunc)g_strcmp0);
-    return node != NULL;
-}
-
-static gboolean account_watcher_setup(void *user_data) {
-    AccountWatcher *watcher = (AccountWatcher *)user_data;
-
-    /* Now check initial state */
-    GList *enabled_accounts =
-        ag_manager_get_enabled_account_services(watcher->manager);
-    GList *old_services = g_hash_table_get_keys(watcher->services);
-
-    /* Update the services table */
-    GList *l;
-    for (l = enabled_accounts; l != NULL; l = l->next) {
-        AgAccountService *account_service = l->data;
-        AgAccountId id = ag_account_service_get_account(account_service)->id;
-        AgService *service = ag_account_service_get_service(account_service);
-        const char *service_id = ag_service_get_name(service);
-
-        if (!service_is_supported(watcher, service_id)) continue;
-
-        char *key = g_strdup_printf("%d/%s", id, service_id);
-
-        AccountInfo *info = g_hash_table_lookup(watcher->services, key);
-        if (info) {
-            GList *node = g_list_find_custom(old_services, key,
-                                             (GCompareFunc)g_strcmp0);
-            old_services = g_list_remove_link(old_services, node);
-            g_free(key);
-        } else {
-            trace("adding account %s\n", key);
-            info = account_info_new(watcher, account_service);
-            g_hash_table_insert(watcher->services, key, info);
-        }
-        account_info_login(info);
-    }
-    g_list_free_full(enabled_accounts, g_object_unref);
-
-    /* Remove from the table the accounts which are no longer enabled */
-    for (l = old_services; l != NULL; l = l->next) {
-        char *key = l->data;
-        trace("removing account %s\n", key);
-        g_hash_table_remove(watcher->services, key);
-    }
-    g_list_free(old_services);
-
-    return G_SOURCE_REMOVE;
-}
-
-AccountWatcher *account_watcher_new(AccountEnabledCallback callback,
-                                    void *user_data) {
-    AccountWatcher *watcher = g_new0(AccountWatcher, 1);
-
-    watcher->manager = ag_manager_new();
-    watcher->services = g_hash_table_new_full(
-        g_str_hash, g_str_equal, g_free, (GDestroyNotify)account_info_free);
-    watcher->supported_services = NULL;
-    watcher->callback = callback;
-    watcher->user_data = user_data;
-
-    return watcher;
-}
-
-void account_watcher_add_service(AccountWatcher *watcher,
-                                 char *serviceId) {
-    watcher->supported_services =
-        g_slist_prepend(watcher->supported_services, serviceId);
-}
-
-void account_watcher_run(AccountWatcher *watcher) {
-    /* Make sure main setup occurs within the mainloop thread */
-    g_idle_add(account_watcher_setup, watcher);
-}
-
-struct refresh_info {
-    AccountWatcher *watcher;
-    AgAccountId account_id;
-    char *service_name;
-};
-
-static void refresh_info_free(struct refresh_info *data) {
-    g_free(data->service_name);
-    g_free(data);
-}
-
-static gboolean account_watcher_refresh_cb(void *user_data) {
-    struct refresh_info *data = (struct refresh_info *)user_data;
-
-    char *key = g_strdup_printf("%d/%s", data->account_id, data->service_name);
-    AccountInfo *info = g_hash_table_lookup(data->watcher->services, key);
-    if (info != NULL) {
-        account_info_login(info);
-    }
-
-    return G_SOURCE_REMOVE;
-}
-
-void account_watcher_refresh(AccountWatcher *watcher, unsigned int account_id,
-                             const char *service_name) {
-    struct refresh_info *data = g_new(struct refresh_info, 1);
-    data->watcher = watcher;
-    data->account_id = account_id;
-    data->service_name = g_strdup(service_name);
-    g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, account_watcher_refresh_cb,
-                    data, (GDestroyNotify)refresh_info_free);
-}

=== removed file 'accounts/account-watcher.h'
--- accounts/account-watcher.h	2016-08-02 14:34:52 +0000
+++ accounts/account-watcher.h	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-#ifndef ACCOUNT_WATCHER_H
-#define ACCOUNT_WATCHER_H
-
-#include <glib.h>
-
-typedef struct _AccountWatcher AccountWatcher;
-
-typedef void (*AccountEnabledCallback)(AccountWatcher *watcher,
-                                       unsigned int account_id,
-                                       const char *service_type,
-                                       const char *service_name,
-                                       GError *error,
-                                       int enabled,
-                                       const char *client_id,
-                                       const char *client_secret,
-                                       const char *access_token,
-                                       const char *token_secret,
-                                       const char *user_name,
-                                       const char *secret,
-                                       void *user_data);
-
-AccountWatcher *account_watcher_new(AccountEnabledCallback callback,
-                                    void *user_data);
-void account_watcher_add_service(AccountWatcher *watcher,
-                                 char *serviceId);
-void account_watcher_run(AccountWatcher *watcher);
-
-void account_watcher_refresh(AccountWatcher *watcher,
-                             unsigned int account_id,
-                             const char *service_name);
-
-#endif

=== removed file 'accounts/accounts.c'
--- accounts/accounts.c	2016-08-02 14:34:52 +0000
+++ accounts/accounts.c	1970-01-01 00:00:00 +0000
@@ -1,26 +0,0 @@
-#include "_cgo_export.h"
-
-AccountWatcher *watch() {
-    /* Transfer service names to hash table */
-    if (FALSE) {
-        /* The Go callback doesn't quite match the
-         * AccountEnabledCallback function prototype, so we cast the
-         * argument in the account_watcher_new() call below.
-         *
-         * This is just a check to see that the function still has the
-         * prototype we expect.
-         */
-        void (*unused)(void *watcher,
-                       unsigned int account_id, 
-                       char *service_type, char *service_name,
-                       GError *error, int enabled,
-                       char *client_id, char *client_secret,
-                       char *access_token, char *token_secret,
-                       char *user_name, char *secret, 
-                       void *user_data) = authCallback;
-    }
-
-    AccountWatcher *watcher = account_watcher_new(
-        (AccountEnabledCallback)authCallback, NULL);
-    return watcher;
-}

=== removed file 'accounts/accounts.go'
--- accounts/accounts.go	2016-08-02 14:34:52 +0000
+++ accounts/accounts.go	1970-01-01 00:00:00 +0000
@@ -1,130 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package accounts
-
-/*
-#cgo pkg-config: glib-2.0 libaccounts-glib libsignon-glib
-#include <stdlib.h>
-#include <glib.h>
-#include "account-watcher.h"
-
-AccountWatcher *watch();
-*/
-import "C"
-import (
-	"errors"
-	"sync"
-	"unsafe"
-)
-
-type Watcher struct {
-	C       <-chan AuthData
-	watcher *C.AccountWatcher
-}
-
-type AuthData struct {
-	AccountId   uint
-	ServiceName string
-	ServiceType string
-	Error       error
-	Enabled     bool
-
-	ClientId     string
-	ClientSecret string
-	AccessToken  string
-	TokenSecret  string
-	Secret       string
-	UserName     string
-}
-
-var (
-	authChannels     = make(map[*C.AccountWatcher]chan<- AuthData)
-	authChannelsLock sync.Mutex
-)
-
-// NewWatcher creates a new account watcher
-func NewWatcher() *Watcher {
-	w := new(Watcher)
-	w.watcher = C.watch()
-
-	ch := make(chan AuthData)
-	w.C = ch
-	authChannelsLock.Lock()
-	authChannels[w.watcher] = ch
-	authChannelsLock.Unlock()
-
-	return w
-}
-
-func (w *Watcher) AddService(serviceId string) {
-	C.account_watcher_add_service(w.watcher, C.CString(serviceId))
-}
-
-// Walk through the enabled accounts, and get auth tokens for each of them.
-// The new access token will be delivered over the watcher's channel.
-func (w *Watcher) Run() {
-	C.account_watcher_run(w.watcher)
-}
-
-// Refresh requests that the token for the given account be refreshed.
-// The new access token will be delivered over the watcher's channel.
-func (w *Watcher) Refresh(accountId uint, serviceName string) {
-	C.account_watcher_refresh(w.watcher, C.uint(accountId), C.CString(serviceName))
-}
-
-//export authCallback
-func authCallback(watcher unsafe.Pointer, accountId C.uint, serviceType *C.char, serviceName *C.char, error *C.GError, enabled C.int, clientId, clientSecret, accessToken, tokenSecret *C.char, userName *C.char, secret *C.char, userData unsafe.Pointer) {
-	// Ideally the first argument would be of type
-	// *C.AccountWatcher, but that fails with Go 1.2.
-	authChannelsLock.Lock()
-	ch := authChannels[(*C.AccountWatcher)(watcher)]
-	authChannelsLock.Unlock()
-	if ch == nil {
-		// Log the error
-		return
-	}
-
-	var data AuthData
-	data.AccountId = uint(accountId)
-	data.ServiceName = C.GoString(serviceName)
-	data.ServiceType = C.GoString(serviceType)
-	if error != nil {
-		data.Error = errors.New(C.GoString((*C.char)(error.message)))
-	}
-	if enabled != 0 {
-		data.Enabled = true
-	}
-	if clientId != nil {
-		data.ClientId = C.GoString(clientId)
-	}
-	if clientSecret != nil {
-		data.ClientSecret = C.GoString(clientSecret)
-	}
-	if accessToken != nil {
-		data.AccessToken = C.GoString(accessToken)
-	}
-	if tokenSecret != nil {
-		data.TokenSecret = C.GoString(tokenSecret)
-	}
-	if secret != nil {
-		data.Secret = C.GoString(secret)
-	}
-	if userName != nil {
-		data.UserName = C.GoString(userName)
-	}
-	ch <- data
-}

=== added directory 'click-hook'
=== added file 'click-hook/account-polld.hook.in'
--- click-hook/account-polld.hook.in	1970-01-01 00:00:00 +0000
+++ click-hook/account-polld.hook.in	2016-09-21 07:16:22 +0000
@@ -0,0 +1,4 @@
+Pattern: ${home}/.local/share/account-polld/plugins/${id}.json
+User-Level: yes
+Hook-Name: account-polld
+Exec: $${hook_helper.path}/$${hook_helper.files}

=== added file 'click-hook/click-hook'
--- click-hook/click-hook	1970-01-01 00:00:00 +0000
+++ click-hook/click-hook	2016-09-21 07:16:22 +0000
@@ -0,0 +1,108 @@
+#!/usr/bin/python3
+# -*- python -*-
+"""Collect helpers hook data into a single json file"""
+
+import json
+import os
+import sys
+import time
+
+import xdg.BaseDirectory
+
+hook_ext = '.json'
+
+
+class HookProcessor:
+    def __init__(self):
+        self.xdg_data_home = xdg.BaseDirectory.xdg_data_home
+        self.xdg_data_dirs = xdg.BaseDirectory.xdg_data_dirs
+        self.plugins_data_path = os.path.join(self.xdg_data_home, 'account-polld',
+                                              'plugin_data.json')
+        self.plugins_data_path_tmp = os.path.join(self.xdg_data_home, 'account-polld',
+                                                  '.plugin_data_%s.tmp')
+        os.makedirs(os.path.join(self.xdg_data_home, 'account-polld'), exist_ok=True)
+
+
+    def write_plugin_data(self):
+        plugin_data = {}
+        for path in self.xdg_data_dirs:
+            data = self.collect_plugins(path)
+            plugin_data.update(data)
+
+        # write the collected data to a temp file and rename the original once
+        # everything is on disk
+        try:
+            tmp_filename = self.plugins_data_path_tmp % (time.time(),)
+            with open(tmp_filename, 'w') as dest:
+                json.dump(plugin_data, dest)
+                dest.flush()
+            os.rename(tmp_filename, self.plugins_data_path)
+        except Exception as e:
+            print('Writing file %s failed: %s' % (self.plugins_data_path, e), file=sys.stderr)
+            return False
+        return True
+
+
+    def collect_plugins(self, base_path):
+        trusted = False if base_path == self.xdg_data_home else True
+        hooks_path = os.path.join(base_path, 'account-polld', 'plugins')
+        plugins_data = {}
+        if not os.path.isdir(hooks_path):
+            return plugins_data
+        for hook_fname in os.listdir(hooks_path):
+            if not hook_fname.endswith(hook_ext):
+                continue
+            try:
+                with open(os.path.join(hooks_path, hook_fname), 'r') as fd:
+                    data = json.load(fd)
+            except Exception:
+                print('Unable to parse JSON from %s' % (hook_fname,), file=sys.stderr)
+                continue
+
+            helper_id = os.path.splitext(hook_fname)[0]
+            profile = 'unconfined' if trusted else helper_id
+            if helper_id.count('_') == 2:
+                helper_short_id = '_'.join(helper_id.split('_')[0:2])
+            else:
+                helper_short_id = helper_id
+
+            exec_path = data['exec']
+            if exec_path != "":
+                realpath = os.path.realpath(os.path.join(hooks_path,
+                                                         hook_fname))
+                exec_path = os.path.join(os.path.dirname(realpath), exec_path)
+            app_id = data.get('app_id', None)
+            if app_id is None:
+                # no app_id, use the package name from the helper_id
+                app_id = helper_short_id
+            elif app_id.count('_') >= 2:
+                # remove the version from the app_id
+                app_id = '_'.join(app_id.split('_')[0:2])
+            if not trusted:
+                # check that the plugin comes from the same package as the app
+                plugin_package = helper_id.split('_')[0]
+                app_package = app_id.split('_')[0]
+                if plugin_package != app_package:
+                    print('Skipping %s as it\'s unrelated to package %s' % (hook_fname, app_package), file=sys.stderr)
+                    continue
+
+            parsed = {
+                'exec': exec_path,
+                'appId': app_id,
+                'profile': profile,
+            }
+            parsed['needsAuthData'] = data.get('needs_authentication_data', False)
+            if 'service_ids' in data:
+                parsed['services'] = data['service_ids']
+            if 'interval' in data:
+                parsed['interval'] = data['interval']
+            plugins_data[helper_short_id] = parsed
+
+        return plugins_data
+
+
+if __name__ == "__main__":
+    processor = HookProcessor()
+    ok = processor.write_plugin_data()
+
+    sys.exit(0 if ok else 1)

=== added file 'click-hook/click-hook.pro'
--- click-hook/click-hook.pro	1970-01-01 00:00:00 +0000
+++ click-hook/click-hook.pro	2016-09-21 07:16:22 +0000
@@ -0,0 +1,20 @@
+include(../common-project-config.pri)
+
+TEMPLATE = aux
+TARGET = ""
+
+QMAKE_SUBSTITUTES += \
+    account-polld.hook.in
+
+OTHER_FILES += \
+    click-hook
+
+hook_helper.files = \
+    click-hook
+hook_helper.path = $${INSTALL_PREFIX}/lib/account-polld
+INSTALLS += hook_helper
+
+hooks.files = \
+    account-polld.hook
+hooks.path = $${INSTALL_PREFIX}/share/click/hooks
+INSTALLS += hooks

=== removed directory 'cmd'
=== removed directory 'cmd/account-polld'
=== removed file 'cmd/account-polld/account_service.go'
--- cmd/account-polld/account_service.go	2016-08-02 14:34:52 +0000
+++ cmd/account-polld/account_service.go	1970-01-01 00:00:00 +0000
@@ -1,186 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package main
-
-import (
-	"errors"
-	"log"
-	"time"
-
-	"launchpad.net/account-polld/accounts"
-	"launchpad.net/account-polld/plugins"
-	"launchpad.net/ubuntu-push/click"
-)
-
-type AccountService struct {
-	watcher          *accounts.Watcher
-	authData         accounts.AuthData
-	plugin           plugins.Plugin
-	interval         time.Duration
-	postWatch        chan *PostWatch
-	authChan         chan accounts.AuthData
-	doneChan         chan error
-	penaltyCount     int
-	authFailureCount int
-}
-
-var (
-	pollTimeout           = time.Duration(30 * time.Second)
-	bootstrapPollTimeout  = time.Duration(4 * time.Minute)
-	maxCounter            = 4
-	authTriesUntilPenalty = 3
-	authFailurePenalty    = 10
-)
-
-var (
-	authError              = errors.New("Skipped account")
-	clickNotInstalledError = errors.New("Click not installed")
-)
-
-func NewAccountService(watcher *accounts.Watcher, postWatch chan *PostWatch, plugin plugins.Plugin) *AccountService {
-	return &AccountService{
-		watcher:   watcher,
-		plugin:    plugin,
-		postWatch: postWatch,
-		authChan:  make(chan accounts.AuthData, 1),
-		doneChan:  make(chan error, 1),
-	}
-}
-
-func (a *AccountService) Delete() {
-	close(a.authChan)
-	close(a.doneChan)
-}
-
-// Poll() always needs to be called asynchronously as otherwise qtcontacs' GetAvatar()
-// will raise an error: "QSocketNotifier: Can only be used with threads started with QThread"
-func (a *AccountService) Poll(bootstrap bool) {
-	gotNewAuthData := false
-	if a.authData, gotNewAuthData = <-a.authChan; !gotNewAuthData {
-		log.Println("Account", a.authData.AccountId, "no longer enabled")
-		return
-	}
-
-	if a.penaltyCount > 0 {
-		log.Printf("Leaving poll for account %d as penalty count is %d", a.authData.AccountId, a.penaltyCount)
-		a.penaltyCount--
-		return
-	} else if !gotNewAuthData && a.authData.Error != nil {
-		// Retry to poll the account with a previous auth failure as that results in reauthentication in case of token expiry and in ignoring temporary network issues
-		log.Println("Retrying to poll account with previous auth failure and id", a.authData.AccountId, "(results in reauthentication in case of token expiry and in ignoring temporary network issues)")
-		a.authData.Error = nil
-	}
-
-	timeout := pollTimeout
-	if bootstrap {
-		timeout = bootstrapPollTimeout
-	}
-
-	log.Printf("Starting poll for account %d", a.authData.AccountId)
-	go a.poll()
-
-	select {
-	case <-time.After(timeout):
-		log.Println("Poll for account", a.authData.AccountId, "has timed out out after", timeout)
-		a.penaltyCount++
-	case err := <-a.doneChan:
-		if err == nil {
-			log.Println("Poll for account", a.authData.AccountId, "was successful")
-			a.authFailureCount = 0
-			a.penaltyCount = 0
-		} else {
-			if err != clickNotInstalledError && err != authError { // Do not log the error twice
-				log.Println("Poll for account", a.authData.AccountId, "has failed:", err)
-			}
-			if err == authError || err == plugins.ErrTokenExpired {
-				// Increase the authFailureCount counter, except for when we did a poll which
-				// raised a token expiry error when we did not get any new auth data this time.
-				if err != plugins.ErrTokenExpired || gotNewAuthData {
-					log.Println("Increasing the auth failure counter for account", a.authData.AccountId)
-					a.authFailureCount++
-				} else {
-					log.Println("Not increasing the auth failure counter for account", a.authData.AccountId, "as we do not have new auth data")
-				}
-				if a.authFailureCount >= authTriesUntilPenalty {
-					a.penaltyCount = authFailurePenalty
-					a.authFailureCount = 0
-					log.Println(authTriesUntilPenalty, "auth failures in a row for account", a.authData.AccountId, "-> skipping it for the next", a.penaltyCount, "poll cycles")
-				} else if err == plugins.ErrTokenExpired && !gotNewAuthData {
-					// If the error indicates that the authentication token has expired, request reauthentication
-					// and mark the data as disabled.
-					// Do not refresh immediately when we just got new (faulty) auth data as immediately trying
-					// again is probably not going to help. Instead, we wait for the next poll cycle.
-					a.watcher.Refresh(a.authData.AccountId, a.authData.ServiceName)
-					a.authData.Enabled = false
-					a.authData.Error = err
-				}
-			} else if a.penaltyCount < maxCounter {
-				a.authFailureCount = 0
-				a.penaltyCount++
-			}
-		}
-	}
-	log.Printf("Ending poll for account %d", a.authData.AccountId)
-}
-
-func (a *AccountService) poll() {
-	log.Println("Polling account", a.authData.AccountId)
-	if !isClickInstalled(a.plugin.ApplicationId()) {
-		log.Println(
-			"Skipping account", a.authData.AccountId, "as target click",
-			a.plugin.ApplicationId(), "is not installed")
-		a.doneChan <- clickNotInstalledError
-		return
-	}
-
-	if a.authData.Error != nil {
-		log.Println("Account", a.authData.AccountId, "failed to authenticate:", a.authData.Error)
-		a.doneChan <- authError
-		return
-	}
-
-	if bs, err := a.plugin.Poll(&a.authData); err != nil {
-		log.Print("Error while polling ", a.authData.AccountId, ": ", err)
-		a.doneChan <- err
-	} else {
-		for _, b := range bs {
-			log.Println("Account", a.authData.AccountId, "has", len(b.Messages), b.Tag, "updates to report")
-		}
-		a.postWatch <- &PostWatch{batches: bs, appId: a.plugin.ApplicationId()}
-		a.doneChan <- nil
-	}
-}
-
-func (a *AccountService) updateAuthData(authData accounts.AuthData) {
-	a.authChan <- authData
-}
-
-func isClickInstalled(appId plugins.ApplicationId) bool {
-	user, err := click.User()
-	if err != nil {
-		log.Println("User instance for click cannot be created to determine if click application", appId, "was installed")
-		return false
-	}
-
-	app, err := click.ParseAppId(string(appId))
-	if err != nil {
-		log.Println("Could not parse APP_ID for", appId)
-		return false
-	}
-
-	return user.Installed(app, false)
-}

=== removed file 'cmd/account-polld/main.go'
--- cmd/account-polld/main.go	2016-08-02 14:34:52 +0000
+++ cmd/account-polld/main.go	1970-01-01 00:00:00 +0000
@@ -1,260 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-	"sync"
-
-	"log"
-
-	"launchpad.net/account-polld/accounts"
-	"launchpad.net/account-polld/gettext"
-	"launchpad.net/account-polld/plugins"
-	"launchpad.net/account-polld/plugins/caldav"
-	"launchpad.net/account-polld/plugins/dekko"
-	"launchpad.net/account-polld/plugins/gcalendar"
-	"launchpad.net/account-polld/plugins/gmail"
-	"launchpad.net/account-polld/plugins/twitter"
-	"launchpad.net/account-polld/pollbus"
-	"launchpad.net/account-polld/qtcontact"
-	"launchpad.net/go-dbus/v1"
-)
-
-type PostWatch struct {
-	appId   plugins.ApplicationId
-	batches []*plugins.PushMessageBatch
-}
-
-type AccountKey struct {
-	serviceId   string
-	accountId   uint
-}
-
-/* Use identifiers and API keys provided by the respective webapps which are the official
-   end points for the notifications */
-const (
-	SERVICENAME_DEKKO     = "dekko.dekkoproject_dekko"
-	SERVICENAME_GMAIL     = "com.ubuntu.developer.webapps.webapp-gmail_webapp-gmail"
-	SERVICENAME_TWITTER   = "com.ubuntu.developer.webapps.webapp-twitter_webapp-twitter"
-	SERVICENAME_GCALENDAR = "google-caldav"
-	SERVICENAME_OCALENDAR = "owncloud-caldav"
-)
-
-const (
-	POSTAL_SERVICE          = "com.ubuntu.Postal"
-	POSTAL_INTERFACE        = "com.ubuntu.Postal"
-	POSTAL_OBJECT_PATH_PART = "/com/ubuntu/Postal/"
-)
-
-var mainLoopOnce sync.Once
-
-func init() {
-	startMainLoop()
-}
-
-func startMainLoop() {
-	mainLoopOnce.Do(func() {
-		go qtcontact.MainLoopStart()
-	})
-}
-
-func main() {
-	// TODO NewAccount called here is just for playing purposes.
-	postWatch := make(chan *PostWatch)
-
-	// Initialize i18n
-	gettext.SetLocale(gettext.LC_ALL, "")
-	gettext.Textdomain("account-polld")
-	gettext.BindTextdomain("account-polld", "/usr/share/locale")
-
-	bus, err := dbus.Connect(dbus.SessionBus)
-	if err != nil {
-		log.Fatal("Cannot connect to bus", err)
-	}
-
-	pollBus := pollbus.New(bus)
-	go postOffice(bus, postWatch)
-	go monitorAccounts(postWatch, pollBus)
-
-	if err := pollBus.Init(); err != nil {
-		log.Fatal("Issue while setting up the poll bus:", err)
-	}
-
-	done := make(chan bool)
-	<-done
-}
-
-func monitorAccounts(postWatch chan *PostWatch, pollBus *pollbus.PollBus) {
-	watcher := accounts.NewWatcher()
-	watcher.AddService(SERVICENAME_DEKKO)
-	watcher.AddService(SERVICENAME_GMAIL)
-	watcher.AddService(SERVICENAME_GCALENDAR)
-	watcher.AddService(SERVICENAME_TWITTER)
-
-	mgr := make(map[AccountKey]*AccountService)
-
-	var wg sync.WaitGroup
-
-	pullAccount := func(data accounts.AuthData) bool {
-		accountKey := AccountKey{data.ServiceName, data.AccountId}
-		if account, ok := mgr[accountKey]; ok {
-			if data.Enabled {
-				log.Println("New account data for existing account with id", data.AccountId)
-				account.penaltyCount = 0
-				account.updateAuthData(data)
-				wg.Add(1)
-				go func() {
-					defer wg.Done()
-					// Poll() needs to be called asynchronously as otherwise qtcontacs' GetAvatar() will
-					// raise an error: "QSocketNotifier: Can only be used with threads started with QThread"
-					account.Poll(false)
-				}()
-				// No wg.Wait() here as it would break GetAvatar() again.
-				// Instead we have a wg.Wait() before the PollChan polling below.
-			} else {
-				account.Delete()
-				delete(mgr, accountKey)
-			}
-		} else if data.Enabled {
-			var plugin plugins.Plugin
-			log.Println("Creating plugin for service: ", data.ServiceName)
-			switch data.ServiceName {
-			case SERVICENAME_DEKKO:
-				log.Println("Creating account with id", data.AccountId, "for", data.ServiceName)
-				plugin = dekko.New(data.AccountId)
-			case SERVICENAME_GMAIL:
-				log.Println("Creating account with id", data.AccountId, "for", data.ServiceName)
-				plugin = gmail.New(data.AccountId)
-			case SERVICENAME_GCALENDAR:
-				log.Println("Creating account with id", data.AccountId, "for", data.ServiceName)
-				plugin = gcalendar.New(data.AccountId)
-			case SERVICENAME_TWITTER:
-				// This is just stubbed until the plugin exists.
-				log.Println("Creating account with id", data.AccountId, "for", data.ServiceName)
-				plugin = twitter.New()
-			case SERVICENAME_OCALENDAR:
-				log.Println("Creating account with id", data.AccountId, "for", data.ServiceName)
-				plugin = caldav.New(data.AccountId)
-			default:
-				log.Println("Unhandled account with id", data.AccountId, "for", data.ServiceName)
-				return false
-			}
-			mgr[accountKey] = NewAccountService(watcher, postWatch, plugin)
-			mgr[accountKey].updateAuthData(data)
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				// Poll() needs to be called asynchronously as otherwise qtcontacs' GetAvatar() will
-				// raise an error: "QSocketNotifier: Can only be used with threads started with QThread"
-				mgr[accountKey].Poll(true)
-			}()
-			// No wg.Wait() here as it would break GetAvatar() again.
-			// Instead we have a wg.Wait() before the PollChan polling below.
-		}
-		return true
-	}
-
-L:
-	for {
-		select {
-		case data := <-watcher.C:
-			if pullAccount(data) == false {
-				log.Println("pullAccount returned false, continuing")
-				continue L
-			}
-		case <-pollBus.PollChan:
-			wg.Wait() // Finish all running Poll() calls before potentially polling the same accounts again
-			watcher.Run()
-			wg.Wait()
-			pollBus.SignalDone()
-		}
-	}
-}
-
-func postOffice(bus *dbus.Connection, postWatch chan *PostWatch) {
-	for post := range postWatch {
-		obj := bus.Object(POSTAL_SERVICE, pushObjectPath(post.appId))
-
-		for _, batch := range post.batches {
-
-			notifs := batch.Messages
-			overflowing := len(notifs) > batch.Limit
-
-			for i, n := range notifs {
-				// Play sound and vibrate on first notif only.
-				if i > 0 {
-					n.Notification.Vibrate = false
-					n.Notification.Sound = ""
-				}
-
-				// We're overflowing, so no popups.
-				// See LP: #1527171
-				if overflowing {
-					n.Notification.Card.Popup = false
-				}
-			}
-
-			if overflowing {
-				n := batch.OverflowHandler(notifs)
-				n.Notification.Card.Persist = false
-				n.Notification.Vibrate = false
-				notifs = append(notifs, n)
-			}
-
-			for _, n := range notifs {
-				var pushMessage string
-				if out, err := json.Marshal(n); err == nil {
-					pushMessage = string(out)
-				} else {
-					log.Printf("Cannot marshall %#v to json: %s", n, err)
-					continue
-				}
-				if _, err := obj.Call(POSTAL_INTERFACE, "Post", post.appId, pushMessage); err != nil {
-					log.Println("Cannot call the Post Office:", err)
-					log.Println("Message missed posting:", pushMessage)
-				}
-			}
-		}
-	}
-}
-
-// pushObjectPath returns the object path of the ApplicationId
-// for Push Notifications with the Quoted Package Name in the form of
-// /com/ubuntu/PushNotifications/QUOTED_PKGNAME
-//
-// e.g.; if the APP_ID is com.ubuntu.music", the returned object path
-// would be "/com/ubuntu/PushNotifications/com_2eubuntu_2eubuntu_2emusic
-func pushObjectPath(id plugins.ApplicationId) dbus.ObjectPath {
-	idParts := strings.Split(string(id), "_")
-	if len(idParts) < 2 {
-		panic(fmt.Sprintf("APP_ID '%s' is not valid", id))
-	}
-
-	pkg := POSTAL_OBJECT_PATH_PART
-	for _, c := range idParts[0] {
-		switch c {
-		case '+', '.', '-', ':', '~', '_':
-			pkg += fmt.Sprintf("_%x", string(c))
-		default:
-			pkg += string(c)
-		}
-	}
-	return dbus.ObjectPath(pkg)
-}

=== removed directory 'cmd/account-watcher-test'
=== removed file 'cmd/account-watcher-test/main.go'
--- cmd/account-watcher-test/main.go	2016-06-17 13:51:55 +0000
+++ cmd/account-watcher-test/main.go	1970-01-01 00:00:00 +0000
@@ -1,17 +0,0 @@
-package main
-
-import (
-	"fmt"
-
-	"launchpad.net/account-polld/accounts"
-)
-
-func main() {
-	for data := range accounts.NewWatcher().C {
-		if data.Error != nil {
-			fmt.Println("Failed to authenticate account", data.AccountId, ":", data.Error)
-		} else {
-			fmt.Printf("%#v\n", data)
-		}
-	}
-}

=== removed directory 'cmd/qtcontact-test'
=== removed file 'cmd/qtcontact-test/main.go'
--- cmd/qtcontact-test/main.go	2015-03-20 14:34:48 +0000
+++ cmd/qtcontact-test/main.go	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package main
-
-import (
-	"fmt"
-	"os"
-
-	"launchpad.net/account-polld/qtcontact"
-)
-
-func main() {
-	qtcontact.MainLoopStart()
-
-	if len(os.Args) != 2 {
-		fmt.Println("usage:", os.Args[0], "[email address]")
-		os.Exit(1)
-	}
-
-	path := qtcontact.GetAvatar(os.Args[1])
-	fmt.Println("Avatar found:", path)
-}

=== added file 'common-installs-config.pri'
--- common-installs-config.pri	1970-01-01 00:00:00 +0000
+++ common-installs-config.pri	2016-09-21 07:16:22 +0000
@@ -0,0 +1,43 @@
+#-----------------------------------------------------------------------------
+# Common installation configuration for all projects.
+#-----------------------------------------------------------------------------
+
+
+#-----------------------------------------------------------------------------
+# default installation target for applications
+#-----------------------------------------------------------------------------
+contains(TEMPLATE, app) {
+    target.path  = $${INSTALL_PREFIX}/bin
+    INSTALLS    += target
+    message("====")
+    message("==== INSTALLS += target")
+}
+
+
+#-----------------------------------------------------------------------------
+# default installation target for libraries
+#-----------------------------------------------------------------------------
+contains(TEMPLATE, lib) {
+    isEmpty(target.path) {
+        target.path  = $${INSTALL_LIBDIR}
+    }
+    INSTALLS    += target
+    message("====")
+    message("==== INSTALLS += target")
+}
+
+#-----------------------------------------------------------------------------
+# target for header files
+#-----------------------------------------------------------------------------
+!isEmpty(headers.files) {
+    headers.path  = $${INSTALL_PREFIX}/include/$${TARGET}
+    INSTALLS     += headers
+    message("====")
+    message("==== INSTALLS += headers")
+} else {
+    message("====")
+    message("==== NOTE: Remember to add your API headers into `headers.files' for installation!")
+}
+
+
+# End of File

=== added file 'common-pkgconfig.pri'
--- common-pkgconfig.pri	1970-01-01 00:00:00 +0000
+++ common-pkgconfig.pri	2016-09-21 07:16:22 +0000
@@ -0,0 +1,12 @@
+# Include this file after defining the pkgconfig.files variable
+
+!isEmpty(pkgconfig.files) {
+    QMAKE_SUBSTITUTES += $${pkgconfig.files}.in
+    pkgconfig.CONFIG = no_check_exist
+    pkgconfig.path  = $${INSTALL_LIBDIR}/pkgconfig
+    QMAKE_EXTRA_TARGETS += pkgconfig
+
+    INSTALLS += pkgconfig
+
+    QMAKE_CLEAN += $${pkgconfig.files}
+}

=== added file 'common-project-config.pri'
--- common-project-config.pri	1970-01-01 00:00:00 +0000
+++ common-project-config.pri	2016-09-21 07:16:22 +0000
@@ -0,0 +1,36 @@
+#-----------------------------------------------------------------------------
+# Common configuration for all projects.
+#-----------------------------------------------------------------------------
+
+# we don't like warnings...
+QMAKE_CXXFLAGS += -Werror
+# Disable RTTI
+QMAKE_CXXFLAGS += -fno-exceptions -fno-rtti
+
+CONFIG += c++11
+
+!defined(TOP_SRC_DIR, var) {
+    TOP_SRC_DIR = $$PWD
+    TOP_BUILD_DIR = $${TOP_SRC_DIR}/$(BUILD_DIR)
+}
+
+include(coverage.pri)
+
+#-----------------------------------------------------------------------------
+# setup the installation prefix
+#-----------------------------------------------------------------------------
+INSTALL_PREFIX = /usr  # default installation prefix
+
+# default prefix can be overriden by defining PREFIX when running qmake
+isEmpty(PREFIX) {
+    message("====")
+    message("==== NOTE: To override the installation path run: `qmake PREFIX=/custom/path'")
+    message("==== (current installation path is `$${INSTALL_PREFIX}')")
+} else {
+    INSTALL_PREFIX = $${PREFIX}
+    message("====")
+    message("==== install prefix set to `$${INSTALL_PREFIX}'")
+}
+
+I18N_DOMAIN="account-polld"
+PLUGIN_DATA_FILE="account-polld/plugin_data.json"

=== added file 'common-vars.pri'
--- common-vars.pri	1970-01-01 00:00:00 +0000
+++ common-vars.pri	2016-09-21 07:16:22 +0000
@@ -0,0 +1,18 @@
+#-----------------------------------------------------------------------------
+# Common variables for all projects.
+#-----------------------------------------------------------------------------
+
+
+#-----------------------------------------------------------------------------
+# Project name (used e.g. in include file and doc install path).
+# remember to update debian/* files if you changes this
+#-----------------------------------------------------------------------------
+PROJECT_NAME = account-polld
+
+#-----------------------------------------------------------------------------
+# Project version
+# remember to update debian/* files if you changes this
+#-----------------------------------------------------------------------------
+PROJECT_VERSION = 0.2
+
+# End of File

=== added file 'coverage.pri'
--- coverage.pri	1970-01-01 00:00:00 +0000
+++ coverage.pri	2016-09-21 07:16:22 +0000
@@ -0,0 +1,48 @@
+# Coverage
+CONFIG(coverage) {
+    OBJECTS_DIR =
+    MOC_DIR =
+
+    LIBS += -lgcov
+    QMAKE_CXXFLAGS += --coverage
+    QMAKE_LDFLAGS += --coverage
+
+    QMAKE_EXTRA_TARGETS += coverage cov
+    QMAKE_EXTRA_TARGETS += clean-gcno clean-gcda coverage-html \
+        generate-coverage-html clean-coverage-html coverage-gcovr \
+        generate-gcovr generate-coverage-gcovr clean-coverage-gcovr
+
+    clean-gcno.commands = \
+        "@echo Removing old coverage instrumentation"; \
+        "find -name '*.gcno' -print | xargs -r rm"
+
+    clean-gcda.commands = \
+        "@echo Removing old coverage results"; \
+        "find -name '*.gcda' -print | xargs -r rm"
+  
+    coverage-html.depends = clean-gcda check generate-coverage-html
+  
+    generate-coverage-html.commands = \
+        "@echo Collecting coverage data"; \
+        "lcov --directory $${TOP_SRC_DIR} --capture --output-file coverage.info --no-checksum --compat-libtool"; \
+        "lcov --extract coverage.info \"*/account-polld/*.cpp\" -o coverage.info"; \
+        "lcov --remove coverage.info \"moc_*.cpp\" --remove coverage.info \"tests/*.cpp\" -o coverage.info"; \
+        "LANG=C genhtml --prefix $${TOP_SRC_DIR} --output-directory coverage-html --title \"Code Coverage\" --legend --show-details coverage.info"
+  
+    clean-coverage-html.depends = clean-gcda
+    clean-coverage-html.commands = \
+        "lcov --directory $${TOP_SRC_DIR} -z"; \
+        "rm -rf coverage.info coverage-html"
+
+    coverage-gcovr.depends = clean-gcda check generate-coverage-gcovr
+
+    generate-coverage-gcovr.commands = \
+        "@echo Generating coverage GCOVR report"; \
+        "gcovr -x -r $${TOP_SRC_DIR} -o $${TOP_SRC_DIR}/coverage.xml -e \".*/moc_.*\" -e \"tests/.*\" -e \".*\\.h\""
+
+    clean-coverage-gcovr.depends = clean-gcda
+    clean-coverage-gcovr.commands = \
+        "rm -rf $${TOP_SRC_DIR}/coverage.xml"
+
+    QMAKE_CLEAN += *.gcda *.gcno coverage.info coverage.xml
+}

=== modified file 'debian/control'
--- debian/control	2015-09-09 08:50:05 +0000
+++ debian/control	2016-09-21 07:16:22 +0000
@@ -3,22 +3,19 @@
 Priority: optional
 Maintainer: Ubuntu Developers <[e-mail]>
 Build-Depends: debhelper (>= 9),
-               dh-golang,
                dh-translations,
-               golang-go,
-               golang-go-dbus-dev,
-               golang-go-xdg-dev,
-               golang-gocheck-dev,
-               golang-ubuntu-push-dev,
-               libaccounts-glib-dev,
-               libclick-0.4-dev,
-               libsignon-glib-dev,
+               libaccounts-qt5-dev,
+               libqtdbusmock1-dev,
+               libqtdbustest1-dev,
+               libsignon-qt5-dev,
+               pkg-config,
                qt5-default,
                qtbase5-dev,
-               qtpim5-dev,
+               python3,
+               python3-xdg,
 Standards-Version: 3.9.5
 Homepage: https://launchpad.net/account-polld
-Vcs-Browser: http://bazaar.launchpad.net/~phablet-team/account-polld/trunk/files
+Vcs-Browser: http://bazaar.launchpad.net/~online-accounts/account-polld/trunk/files
 Vcs-Bzr: lp:account-polld
 
 Package: account-polld
@@ -27,10 +24,8 @@
          ${misc:Depends},
          ${shlibs:Depends},
 Built-Using: ${misc:Built-Using}
-Recommends: accountsservice,
+Recommends: account-polld-plugins-go,
 Description: Poll daemon for notifications though the Ubuntu Push Client
- This component polls twitter and gmail for updates and
- communicates with the postal service provided by the ubuntu push client
- to expose notifications for the click webapps for the aforementioned
- services.
-X-Ubuntu-Use-Langpack: yes
+ This component polls remote services for updates and communicates with the
+ postal service provided by the ubuntu push client to expose notifications for
+ the click webapps for the aforementioned services.

=== modified file 'debian/rules'
--- debian/rules	2014-10-01 13:02:24 +0000
+++ debian/rules	2016-09-21 07:16:22 +0000
@@ -2,38 +2,7 @@
 # -*- makefile -*-
 
 export DH_OPTIONS
-export DH_GOPKG := launchpad.net/account-polld
-export DH_GOLANG_INSTALL_ALL := 1
+
 
 %:
-	dh $@ \
-		--buildsystem=golang \
-		--with=golang \
-		--with=translations \
-		--fail-missing
-
-override_dh_auto_install:
-	dh_auto_install -O--buildsystem=golang
-	rm \
-		${CURDIR}/debian/account-polld/usr/bin/account-watcher-test
-	# all our libs are private
-	rm -r \
-		${CURDIR}/debian/account-polld/usr/share/gocode
-	# setup online accounts service files
-	mkdir -p \
-		${CURDIR}/debian/account-polld/usr/share/applications
-	cp ${CURDIR}/data/account-polld.desktop \
-		${CURDIR}/debian/account-polld/usr/share/applications/
-	# translations
-	appname=account-polld; \
-	for pofile in po/*.po; do \
-		pofilename="$${pofile##*/}"; \
-		langcode="$${pofilename%.*}"; \
-		localedir="debian/$$appname/usr/share/locale/$$langcode/LC_MESSAGES"; \
-		mkdir -p $$localedir; \
-		mofile="$$localedir/$$appname.mo"; \
-		msgfmt -o $$mofile $$pofile; \
-	done
-
-override_dh_strip:
-	echo "Skipping strip (LP: #1318027)"
+	dh $@

=== removed directory 'gettext'
=== removed file 'gettext/LICENSE'
--- gettext/LICENSE	2014-07-29 18:02:58 +0000
+++ gettext/LICENSE	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-Copyright (c) 2012-2013 José Carlos Nieto, http://xiam.menteslibres.org/
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

=== removed file 'gettext/README.md'
--- gettext/README.md	2014-07-29 18:02:58 +0000
+++ gettext/README.md	1970-01-01 00:00:00 +0000
@@ -1,94 +0,0 @@
-# gosexy/gettext
-
-Go bindings for [GNU gettext][1], an internationalization and localization
-library for writing multilingual systems.
-
-## Requeriments
-
-The GNU C library. If you're using GNU/Linux, FreeBSD or OSX you should already
-have it.
-
-## Installation
-
-Use `go get` to download and install the binding:
-
-```sh
-go get github.com/gosexy/gettext
-```
-
-## Usage
-
-```go
-package main
-
-import (
-	"github.com/gosexy/gettext"
-	"fmt"
-	"os"
-)
-
-func main() {
-	gettext.BindTextdomain("example", ".")
-	gettext.Textdomain("example")
-
-	os.Setenv("LANGUAGE", "es_MX.utf8")
-
-	gettext.SetLocale(gettext.LC_ALL, "")
-
-	fmt.Println(gettext.Gettext("Hello, world!"))
-}
-```
-
-You can use `os.Setenv` to set the `LANGUAGE` environment variable or set it
-on a terminal:
-
-```sh
-export LANGUAGE="es_MX.utf8"
-./gettext-program
-```
-
-Note that `xgettext` does not officially support Go syntax yet, however, you
-can generate a valid `.pot` file by forcing `xgettest` to use the C++
-syntax:
-
-```sh
-xgettext -d example -s gettext_test.go -o example.pot -L c++ -i \
---keyword=NGettext:1,2 --keyword=Gettext
-```
-
-This will generate a `example.pot` file.
-
-After translating the `.pot` file, you must generate `.po` and `.mo` files and
-remember to set the UTF-8 charset.
-
-```sh
-msginit -l es_MX -o example.po -i example.pot
-msgfmt -c -v -o example.mo example.po
-```
-
-Finally, move the `.mo` file to an appropriate location.
-
-```sh
-mv example.mo examples/es_MX.utf8/LC_MESSAGES/example.mo
-```
-
-## Documentation
-
-You can read `gosexy/gettext` documentation from a terminal
-
-```sh
-go doc github.com/gosexy/gettext
-```
-
-Or you can [browse it](http://godoc.org/github.com/gosexy/gettext) online.
-
-The original gettext documentation could be very useful as well:
-
-```sh
-man 3 gettext
-```
-
-Here's another [good tutorial][2] on using gettext.
-
-[1]: http://www.gnu.org/software/gettext/
-[2]: http://oriya.sarovar.org/docs/gettext_single.html

=== removed file 'gettext/gettext.go'
--- gettext/gettext.go	2014-07-29 18:02:58 +0000
+++ gettext/gettext.go	1970-01-01 00:00:00 +0000
@@ -1,207 +0,0 @@
-/*
-  Copyright (c) 2012 José Carlos Nieto, http://xiam.menteslibres.org/
-
-  Permission is hereby granted, free of charge, to any person obtaining
-  a copy of this software and associated documentation files (the
-  "Software"), to deal in the Software without restriction, including
-  without limitation the rights to use, copy, modify, merge, publish,
-  distribute, sublicense, and/or sell copies of the Software, and to
-  permit persons to whom the Software is furnished to do so, subject to
-  the following conditions:
-
-  The above copyright notice and this permission notice shall be
-  included in all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package gettext
-
-/*
-
-#include <libintl.h>
-#include <locale.h>
-#include <stdlib.h>
-*/
-import "C"
-
-import (
-	"fmt"
-	"strings"
-	"unsafe"
-)
-
-var (
-	// For all of the locale.
-	LC_ALL = uint(C.LC_ALL)
-
-	// For regular expression matching (it determines the meaning of range
-	// expressions and equivalence classes) and string collation.
-	LC_COLATE = uint(C.LC_ALL)
-
-	// For regular expression matching, character classification, conversion,
-	// case-sensitive comparison, and wide character functions.
-	LC_CTYPE = uint(C.LC_CTYPE)
-
-	// For localizable natural-language messages.
-	LC_MESSAGES = uint(C.LC_MESSAGES)
-
-	// For monetary formatting.
-	LC_MONETARY = uint(C.LC_MONETARY)
-
-	// For number formatting (such as the decimal point and the thousands
-	// separator).
-	LC_NUMERIC = uint(C.LC_NUMERIC)
-
-	// For time and date formatting.
-	LC_TIME = uint(C.LC_TIME)
-)
-
-// Sets or queries the program's current locale.
-func SetLocale(category uint, locale string) string {
-	clocale := C.CString(locale)
-
-	res := C.GoString(C.setlocale(C.int(category), clocale))
-
-	C.free(unsafe.Pointer(clocale))
-	return res
-}
-
-// Sets directory containing message catalogs.
-func BindTextdomain(domainname string, dirname string) string {
-	cdirname := C.CString(dirname)
-	cdomainname := C.CString(domainname)
-
-	res := C.GoString(C.bindtextdomain(cdomainname, cdirname))
-
-	C.free(unsafe.Pointer(cdirname))
-	C.free(unsafe.Pointer(cdomainname))
-	return res
-}
-
-// Sets the output codeset for message catalogs for domain domainname.
-func BindTextdomainCodeset(domainname string, codeset string) string {
-	cdomainname := C.CString(domainname)
-	ccodeset := C.CString(codeset)
-
-	res := C.GoString(C.bind_textdomain_codeset(cdomainname, ccodeset))
-
-	C.free(unsafe.Pointer(cdomainname))
-	C.free(unsafe.Pointer(ccodeset))
-	return res
-}
-
-// Sets or retrieves the current message domain.
-func Textdomain(domainname string) string {
-	cdomainname := C.CString(domainname)
-
-	res := C.GoString(C.textdomain(cdomainname))
-
-	C.free(unsafe.Pointer(cdomainname))
-	return res
-}
-
-// Attempt to translate a text string into the user's native language, by
-// looking up the translation in a message catalog.
-func Gettext(msgid string) string {
-	cmsgid := C.CString(msgid)
-
-	res := C.GoString(C.gettext(cmsgid))
-
-	C.free(unsafe.Pointer(cmsgid))
-	return res
-}
-
-// Like Gettext(), but looking up the message in the specified domain.
-func DGettext(domain string, msgid string) string {
-	cdomain := C.CString(domain)
-	cmsgid := C.CString(msgid)
-
-	res := C.GoString(C.dgettext(cdomain, cmsgid))
-
-	C.free(unsafe.Pointer(cdomain))
-	C.free(unsafe.Pointer(cmsgid))
-	return res
-}
-
-// Like Gettext(), but looking up the message in the specified domain and
-// category.
-func DCGettext(domain string, msgid string, category uint) string {
-	cdomain := C.CString(domain)
-	cmsgid := C.CString(msgid)
-
-	res := C.GoString(C.dcgettext(cdomain, cmsgid, C.int(category)))
-
-	C.free(unsafe.Pointer(cdomain))
-	C.free(unsafe.Pointer(cmsgid))
-	return res
-}
-
-// Attempt to translate a text string into the user's native language, by
-// looking up the appropriate plural form of the translation in a message
-// catalog.
-func NGettext(msgid string, msgid_plural string, n uint64) string {
-	cmsgid := C.CString(msgid)
-	cmsgid_plural := C.CString(msgid_plural)
-
-	res := C.GoString(C.ngettext(cmsgid, cmsgid_plural, C.ulong(n)))
-
-	C.free(unsafe.Pointer(cmsgid))
-	C.free(unsafe.Pointer(cmsgid_plural))
-
-	return res
-}
-
-// Like fmt.Sprintf() but without %!(EXTRA) errors.
-func Sprintf(format string, a ...interface{}) string {
-	expects := strings.Count(format, "%") - strings.Count(format, "%%")
-
-	if expects > 0 {
-		arguments := make([]interface{}, expects)
-		for i := 0; i < expects; i++ {
-			if len(a) > i {
-				arguments[i] = a[i]
-			}
-		}
-		return fmt.Sprintf(format, arguments...)
-	}
-
-	return format
-}
-
-// Like NGettext(), but looking up the message in the specified domain.
-func DNGettext(domainname string, msgid string, msgid_plural string, n uint64) string {
-	cdomainname := C.CString(domainname)
-	cmsgid := C.CString(msgid)
-	cmsgid_plural := C.CString(msgid_plural)
-
-	res := C.GoString(C.dngettext(cdomainname, cmsgid, cmsgid_plural, C.ulong(n)))
-
-	C.free(unsafe.Pointer(cdomainname))
-	C.free(unsafe.Pointer(cmsgid))
-	C.free(unsafe.Pointer(cmsgid_plural))
-
-	return res
-}
-
-// Like NGettext(), but looking up the message in the specified domain and
-// category.
-func DCNGettext(domainname string, msgid string, msgid_plural string, n uint64, category uint) string {
-	cdomainname := C.CString(domainname)
-	cmsgid := C.CString(msgid)
-	cmsgid_plural := C.CString(msgid_plural)
-
-	res := C.GoString(C.dcngettext(cdomainname, cmsgid, cmsgid_plural, C.ulong(n), C.int(category)))
-
-	C.free(unsafe.Pointer(cdomainname))
-	C.free(unsafe.Pointer(cmsgid))
-	C.free(unsafe.Pointer(cmsgid_plural))
-
-	return res
-}

=== removed directory 'plugins'
=== removed directory 'plugins/caldav'
=== removed file 'plugins/caldav/api.go'
--- plugins/caldav/api.go	2016-07-12 19:40:07 +0000
+++ plugins/caldav/api.go	1970-01-01 00:00:00 +0000
@@ -1,54 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package caldav
-
-import (
-	"fmt"
-)
-
-// eventList holds a response to call to Calendar.events: list
-// defined in https://developers.google.com/google-apps/calendar/v3/reference/events/list#response
-type eventList struct {
-	// Messages holds a list of message.
-	Events []event `json:"items"`
-}
-
-// event holds the event data response for a Calendar.event.
-// The full definition of a message is defined in
-// https://developers.google.com/google-apps/calendar/v3/reference/events#resource-representations
-type event struct {
-	// Id is the immutable ID of the message.
-	Etag string `json:"etag"`
-	// ThreadId is the ID of the thread the message belongs to.
-	Summary string `json:"summary"`
-}
-
-func (e event) String() string {
-	return fmt.Sprintf("Id: %s, snippet: '%s'\n", e.Etag, e.Summary)
-}
-
-type errorResp struct {
-	Err struct {
-		Code    uint64 `json:"code"`
-		Message string `json:"message"`
-		Errors  []struct {
-			Domain  string `json:"domain"`
-			Reason  string `json:"reason"`
-			Message string `json:"message"`
-		} `json:"errors"`
-	} `json:"error"`
-}

=== removed file 'plugins/caldav/caldav.go'
--- plugins/caldav/caldav.go	2016-08-03 11:59:28 +0000
+++ plugins/caldav/caldav.go	1970-01-01 00:00:00 +0000
@@ -1,201 +0,0 @@
-/*
- Copyright 2016 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package caldav
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"net/url"
-	"os"
-	"strings"
-	"time"
-
-	"launchpad.net/account-polld/accounts"
-	"launchpad.net/account-polld/plugins"
-	"launchpad.net/account-polld/syncmonitor"
-)
-
-const (
-	APP_ID     = "com.ubuntu.calendar_calendar"
-	pluginName = "caldav"
-)
-
-type CalDavPlugin struct {
-	accountId uint
-}
-
-func New(accountId uint) *CalDavPlugin {
-	return &CalDavPlugin{accountId: accountId}
-}
-
-func (p *CalDavPlugin) ApplicationId() plugins.ApplicationId {
-	return plugins.ApplicationId(APP_ID)
-}
-
-func (p *CalDavPlugin) Poll(authData *accounts.AuthData) ([]*plugins.PushMessageBatch, error) {
-	// This envvar check is to ease testing.
-	if token := os.Getenv("ACCOUNT_POLLD_TOKEN_CALDAV"); token != "" {
-		log.Print("Using token from: ACCOUNT_POLLD_TOKEN_CALDAV env var")
-		authData.AccessToken = token
-	}
-
-	log.Print("Check calendar changes for account:", p.accountId)
-
-	syncMonitor := syncmonitor.NewSyncMonitor()
-	if syncMonitor == nil {
-		log.Print("Sync monitor not available yet.")
-		return nil, nil
-	}
-
-	state, err := syncMonitor.State()
-	if err != nil {
-		log.Print("Fail to retrieve sync monitor state ", err)
-		return nil, nil
-	}
-	if state != "idle" {
-		log.Print("Sync monitor is not on 'idle' state, try later!")
-		return nil, nil
-	}
-
-	calendars, err := syncMonitor.ListCalendarsByAccount(p.accountId)
-	if err != nil {
-		log.Print("Calendar plugin ", p.accountId, ": cannot load calendars: ", err)
-		return nil, nil
-	}
-
-	var calendarsToSync []string
-	log.Print("Number of calendars for account:", p.accountId, " size:", len(calendars))
-
-	for id, calendar := range calendars {
-		lastSyncDate, err := syncMonitor.LastSyncDate(p.accountId, id)
-		if err != nil {
-			log.Print("\tcalendar: ", id, ", cannot load previous sync date: ", err, ". Try next time.")
-			continue
-		} else {
-			log.Print("\tcalendar: ", id, " Url: ", calendar, " last sync date: ", lastSyncDate)
-		}
-
-		var needSync bool
-		needSync = (len(lastSyncDate) == 0)
-
-		if !needSync {
-			resp, err := p.requestChanges(authData, calendar, lastSyncDate)
-			if err != nil {
-				log.Print("\tERROR: Fail to query for changes: ", err)
-				continue
-			}
-
-			needSync, err = p.containEvents(resp)
-			if err != nil {
-				log.Print("\tERROR: Fail to parse changes: ", err)
-				if err == plugins.ErrTokenExpired {
-					log.Print("\t\tAbort poll")
-					return nil, err
-				} else {
-					continue
-				}
-			}
-		}
-
-		if needSync {
-			log.Print("\tCalendar needs sync: ", id)
-			calendarsToSync = append(calendarsToSync, id)
-		} else {
-			log.Print("\tFound no calendar updates for account: ", p.accountId, " calendar: ", id)
-		}
-	}
-
-	if len(calendarsToSync) > 0 {
-		log.Print("Request account sync")
-		err = syncMonitor.SyncAccount(p.accountId, calendarsToSync)
-		if err != nil {
-			log.Print("ERROR: Fail to start account sync ", p.accountId, " message: ", err)
-		}
-	}
-
-	return nil, nil
-}
-
-func (p *CalDavPlugin) containEvents(resp *http.Response) (bool, error) {
-	defer resp.Body.Close()
-	log.Print("RESPONSE CODE ----:", resp.StatusCode)
-
-	if resp.StatusCode != 207 {
-		var errResp errorResp
-		log.Print("Invalid response:", errResp.Err.Code)
-		return false, nil
-	} else {
-		data, err := ioutil.ReadAll(resp.Body)
-		if err != nil {
-			return false, err
-		}
-		fmt.Printf("DATA: %s", data)
-		return strings.Contains(string(data), "BEGIN:VEVENT"), nil
-	}
-
-	return false, nil
-}
-
-func (p *CalDavPlugin) requestChanges(authData *accounts.AuthData, calendar string, lastSyncDate string) (*http.Response, error) {
-	u, err := url.Parse(calendar)
-	if err != nil {
-		return nil, err
-	}
-	startDate, err := time.Parse(time.RFC3339, lastSyncDate)
-	if err != nil {
-		log.Print("Fail to parse date: ", lastSyncDate)
-		return nil, err
-	}
-
-	// Start date will be one minute before last sync
-	startDate = startDate.Add(time.Duration(-1) * time.Minute)
-
-	// End Date will be one year in the future from now
-	endDate := time.Now().AddDate(1, 0, 0).UTC()
-
-	log.Print("Calendar Url:", calendar)
-
-	query := "<c:calendar-query xmlns:d=\"DAV:\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\">\n"
-	query += "<d:prop>\n"
-	query += "<d:getetag />\n"
-	query += "<c:calendar-data />\n"
-	query += "</d:prop>\n"
-	query += "<c:filter>\n"
-	query += "<c:comp-filter name=\"VCALENDAR\">\n"
-	query += "<c:comp-filter name=\"VEVENT\">\n"
-	query += "<c:prop-filter name=\"LAST-MODIFIED\">\n"
-	query += "<c:time-range start=\"" + startDate.Format("20060102T150405Z") + "\" end=\"" + endDate.Format("20060102T150405Z") + "\"/>\n"
-	query += "</c:prop-filter>\n"
-	query += "</c:comp-filter>\n"
-	query += "</c:comp-filter>\n"
-	query += "</c:filter>\n"
-	query += "</c:calendar-query>\n"
-	log.Print("Query: ", query)
-	req, err := http.NewRequest("REPORT", u.String(), bytes.NewBufferString(query))
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Depth", "1")
-	req.Header.Set("Prefer", "return-minimal")
-	req.Header.Set("Content-Type", "application/xml; charset=utf-8")
-	req.SetBasicAuth(authData.UserName, authData.Secret)
-
-	return http.DefaultClient.Do(req)
-}

=== removed directory 'plugins/dekko'
=== removed file 'plugins/dekko/api.go'
--- plugins/dekko/api.go	2016-06-15 14:41:33 +0000
+++ plugins/dekko/api.go	1970-01-01 00:00:00 +0000
@@ -1,127 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package dekko
-
-import (
-	"fmt"
-	"time"
-
-	"launchpad.net/account-polld/plugins"
-)
-
-const gmailTime = "Mon, 2 Jan 2006 15:04:05 -0700"
-
-type pushes map[string]*plugins.PushMessage
-type headers map[string]string
-
-// messageList holds a response to call to Users.messages: list
-// defined in https://developers.google.com/gmail/api/v1/reference/users/messages/list
-type messageList struct {
-	// Messages holds a list of message.
-	Messages []message `json:"messages"`
-	// NextPageToken is used to retrieve the next page of results in the list.
-	NextPageToken string `json:"nextPageToken"`
-	// ResultSizeEstimage is the estimated total number of results.
-	ResultSizeEstimage uint64 `json:"resultSizeEstimate"`
-}
-
-// message holds a partial response for a Users.messages.
-// The full definition of a message is defined in
-// https://developers.google.com/gmail/api/v1/reference/users/messages#resource
-type message struct {
-	// Id is the immutable ID of the message.
-	Id string `json:"id"`
-	// ThreadId is the ID of the thread the message belongs to.
-	ThreadId string `json:"threadId"`
-	// HistoryId is the ID of the last history record that modified
-	// this message.
-	HistoryId string `json:"historyId"`
-	// Snippet is a short part of the message text. This text is
-	// used for the push message summary.
-	Snippet string `json:"snippet"`
-	// Payload represents the message payload.
-	Payload payload `json:"payload"`
-}
-
-func (m message) String() string {
-	return fmt.Sprintf("Id: %d, snippet: '%s'\n", m.Id, m.Snippet[:10])
-}
-
-// ById implements sort.Interface for []message based on
-// the Id field.
-type byId []message
-
-func (m byId) Len() int           { return len(m) }
-func (m byId) Swap(i, j int)      { m[i], m[j] = m[j], m[i] }
-func (m byId) Less(i, j int) bool { return m[i].Id < m[j].Id }
-
-// payload represents the message payload.
-type payload struct {
-	Headers []messageHeader `json:"headers"`
-}
-
-func (p *payload) mapHeaders() headers {
-	headers := make(map[string]string)
-	for _, hdr := range p.Headers {
-		headers[hdr.Name] = hdr.Value
-	}
-	return headers
-}
-
-func (hdr headers) getTimestamp() time.Time {
-	timestamp, ok := hdr[hdrDATE]
-	if !ok {
-		return time.Now()
-	}
-
-	if t, err := time.Parse(gmailTime, timestamp); err == nil {
-		return t
-	}
-	return time.Now()
-}
-
-func (hdr headers) getEpoch() int64 {
-	return hdr.getTimestamp().Unix()
-}
-
-// messageHeader represents the message headers.
-type messageHeader struct {
-	Name  string `json:"name"`
-	Value string `json:"value"`
-}
-
-type errorResp struct {
-	Err struct {
-		Code    uint64 `json:"code"`
-		Message string `json:"message"`
-		Errors  []struct {
-			Domain  string `json:"domain"`
-			Reason  string `json:"reason"`
-			Message string `json:"message"`
-		} `json:"errors"`
-	} `json:"error"`
-}
-
-func (err *errorResp) Error() string {
-	return fmt.Sprint("backend response:", err.Err.Message)
-}
-
-const (
-	hdrDATE    = "Date"
-	hdrSUBJECT = "Subject"
-	hdrFROM    = "From"
-)

=== removed file 'plugins/dekko/dekko.go'
--- plugins/dekko/dekko.go	2016-07-22 09:46:36 +0000
+++ plugins/dekko/dekko.go	1970-01-01 00:00:00 +0000
@@ -1,346 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package dekko
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/mail"
-	"net/url"
-	"os"
-	"regexp"
-	"sort"
-	"strings"
-	"time"
-
-	"log"
-
-	"launchpad.net/account-polld/accounts"
-	"launchpad.net/account-polld/gettext"
-	"launchpad.net/account-polld/plugins"
-	"launchpad.net/account-polld/qtcontact"
-)
-
-const (
-	APP_ID           = "dekko.dekkoproject_dekko"
-	dekkoDispatchUrl = "dekko://notify/%d/%s/%s"
-	// If there's more than 10 emails in one batch, we don't show 10 notification
-	// bubbles, but instead show one summary. We always show all notifications in the
-	// indicator.
-	individualNotificationsLimit = 10
-	pluginName                   = "dekko"
-)
-
-type reportedIdMap map[string]time.Time
-
-var baseUrl, _ = url.Parse("https://www.googleapis.com/gmail/v1/users/me/")
-
-// timeDelta defines how old messages can be to be reported.
-var timeDelta = time.Duration(time.Hour * 24)
-
-// trackDelta defines how old messages can be before removed from tracking
-var trackDelta = time.Duration(time.Hour * 24 * 7)
-
-// relativeTimeDelta is the same as timeDelta
-var relativeTimeDelta string = "1d"
-
-// regexp for identifying non-ascii characters
-var nonAsciiChars, _ = regexp.Compile("[^\x00-\x7F]")
-
-type GmailPlugin struct {
-	// reportedIds holds the messages that have already been notified. This
-	// approach is taken against timestamps as it avoids needing to call
-	// get on the message.
-	reportedIds reportedIdMap
-	accountId   uint
-}
-
-func idsFromPersist(accountId uint) (ids reportedIdMap, err error) {
-	err = plugins.FromPersist(pluginName, accountId, &ids)
-	if err != nil {
-		return nil, err
-	}
-	// discard old ids
-	timestamp := time.Now()
-	for k, v := range ids {
-		delta := timestamp.Sub(v)
-		if delta > trackDelta {
-			log.Print("gmail plugin ", accountId, ": deleting ", k, " as ", delta, " is greater than ", trackDelta)
-			delete(ids, k)
-		}
-	}
-	return ids, nil
-}
-
-func (ids reportedIdMap) persist(accountId uint) (err error) {
-	err = plugins.Persist(pluginName, accountId, ids)
-	if err != nil {
-		log.Print("gmail plugin ", accountId, ": failed to save state: ", err)
-	}
-	return nil
-}
-
-func New(accountId uint) *GmailPlugin {
-	reportedIds, err := idsFromPersist(accountId)
-	if err != nil {
-		log.Print("gmail plugin ", accountId, ": cannot load previous state from storage: ", err)
-	} else {
-		log.Print("gmail plugin ", accountId, ": last state loaded from storage")
-	}
-	return &GmailPlugin{reportedIds: reportedIds, accountId: accountId}
-}
-
-func (p *GmailPlugin) ApplicationId() plugins.ApplicationId {
-	return plugins.ApplicationId(APP_ID)
-}
-
-func (p *GmailPlugin) Poll(authData *accounts.AuthData) ([]*plugins.PushMessageBatch, error) {
-	// This envvar check is to ease testing.
-	if token := os.Getenv("ACCOUNT_POLLD_TOKEN_GMAIL"); token != "" {
-		authData.AccessToken = token
-	}
-
-	resp, err := p.requestMessageList(authData.AccessToken)
-	if err != nil {
-		return nil, err
-	}
-	messages, err := p.parseMessageListResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO use the batching API defined in https://developers.google.com/gmail/api/guides/batch
-	for i := range messages {
-		resp, err := p.requestMessage(messages[i].Id, authData.AccessToken)
-		if err != nil {
-			return nil, err
-		}
-		messages[i], err = p.parseMessageResponse(resp)
-		if err != nil {
-			return nil, err
-		}
-	}
-	notif, err := p.createNotifications(messages)
-	if err != nil {
-		return nil, err
-	}
-	return []*plugins.PushMessageBatch{
-		&plugins.PushMessageBatch{
-			Messages:        notif,
-			Limit:           individualNotificationsLimit,
-			OverflowHandler: p.handleOverflow,
-			Tag:             "dekko",
-		}}, nil
-
-}
-
-func (p *GmailPlugin) reported(id string) bool {
-	_, ok := p.reportedIds[id]
-	return ok
-}
-
-func (p *GmailPlugin) createNotifications(messages []message) ([]*plugins.PushMessage, error) {
-	timestamp := time.Now()
-	pushMsgMap := make(pushes)
-
-	for _, msg := range messages {
-		hdr := msg.Payload.mapHeaders()
-
-		from := hdr[hdrFROM]
-		var avatarPath string
-
-		emailAddress, err := mail.ParseAddress(from)
-		if err != nil {
-			// If the email address contains non-ascii characters, we get an
-			// error so we're going to try again, this time mangling the name
-			// by removing all non-ascii characters. We only care about the email
-			// address here anyway.
-			// XXX: We can't check the error message due to [1]: the error
-			// message is different in go < 1.3 and > 1.5.
-			// [1] https://github.com/golang/go/issues/12492
-			mangledAddr := nonAsciiChars.ReplaceAllString(from, "")
-			mangledEmail, mangledParseError := mail.ParseAddress(mangledAddr)
-			if mangledParseError == nil {
-				emailAddress = mangledEmail
-			}
-		} else if emailAddress.Name != "" {
-			// We only want the Name if the first ParseAddress
-			// call was successful. I.e. we do not want the name
-			// from a mangled email address.
-			from = emailAddress.Name
-		}
-
-		if emailAddress != nil {
-			avatarPath = qtcontact.GetAvatar(emailAddress.Address)
-			// If icon path starts with a path separator, assume local file path,
-			// encode it and prepend file scheme defined in RFC 1738.
-			if strings.HasPrefix(avatarPath, string(os.PathSeparator)) {
-				avatarPath = url.QueryEscape(avatarPath)
-				avatarPath = "file://" + avatarPath
-			}
-		}
-
-		msgStamp := hdr.getTimestamp()
-
-		if _, ok := pushMsgMap[msg.ThreadId]; ok {
-			// TRANSLATORS: the %s is an appended "from" corresponding to an specific email thread
-			pushMsgMap[msg.ThreadId].Notification.Card.Summary += fmt.Sprintf(gettext.Gettext(", %s"), from)
-		} else if timestamp.Sub(msgStamp) < timeDelta {
-			// TRANSLATORS: the %s is the "from" header corresponding to a specific email
-			summary := fmt.Sprintf(gettext.Gettext("%s"), from)
-			// TRANSLATORS: the first %s refers to the email "subject", the second %s refers "from"
-			body := fmt.Sprintf(gettext.Gettext("%s\n%s"), hdr[hdrSUBJECT], msg.Snippet)
-			// fmt with label personal and threadId
-			action := fmt.Sprintf(dekkoDispatchUrl, p.accountId, "INBOX", msg.Id)
-			epoch := hdr.getEpoch()
-			pushMsgMap[msg.ThreadId] = plugins.NewStandardPushMessage(summary, body, action, avatarPath, epoch)
-		} else {
-			log.Print("gmail plugin ", p.accountId, ": skipping message id ", msg.Id, " with date ", msgStamp, " older than ", timeDelta)
-		}
-	}
-	pushMsg := make([]*plugins.PushMessage, 0, len(pushMsgMap))
-	for _, v := range pushMsgMap {
-		pushMsg = append(pushMsg, v)
-	}
-	return pushMsg, nil
-
-}
-func (p *GmailPlugin) handleOverflow(pushMsg []*plugins.PushMessage) *plugins.PushMessage {
-	// TODO it would probably be better to grab the estimate that google returns in the message list.
-	approxUnreadMessages := len(pushMsg)
-
-	// TRANSLATORS: the %d refers to the number of new email messages.
-	summary := fmt.Sprintf(gettext.Gettext("You have %d new messages"), approxUnreadMessages)
-
-	body := ""
-
-	// fmt with label personal and no threadId
-	action := fmt.Sprintf(dekkoDispatchUrl, p.accountId, "INBOX")
-	epoch := time.Now().Unix()
-
-	return plugins.NewStandardPushMessage(summary, body, action, "", epoch)
-}
-
-func (p *GmailPlugin) parseMessageListResponse(resp *http.Response) ([]message, error) {
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	if resp.StatusCode != http.StatusOK {
-		var errResp errorResp
-		if err := decoder.Decode(&errResp); err != nil {
-			return nil, err
-		}
-		if errResp.Err.Code == 401 {
-			return nil, plugins.ErrTokenExpired
-		}
-		return nil, &errResp
-	}
-
-	var messages messageList
-	if err := decoder.Decode(&messages); err != nil {
-		return nil, err
-	}
-
-	filteredMsg := p.messageListFilter(messages.Messages)
-
-	return filteredMsg, nil
-}
-
-// messageListFilter returns a subset of unread messages where the subset
-// depends on not being in reportedIds. Before returning, reportedIds is
-// updated with the new list of unread messages.
-func (p *GmailPlugin) messageListFilter(messages []message) []message {
-	sort.Sort(byId(messages))
-	var reportMsg []message
-	var ids = make(reportedIdMap)
-
-	for _, msg := range messages {
-		if !p.reported(msg.Id) {
-			reportMsg = append(reportMsg, msg)
-		}
-		ids[msg.Id] = time.Now()
-	}
-	p.reportedIds = ids
-	p.reportedIds.persist(p.accountId)
-	return reportMsg
-}
-
-func (p *GmailPlugin) parseMessageResponse(resp *http.Response) (message, error) {
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	if resp.StatusCode != http.StatusOK {
-		var errResp errorResp
-		if err := decoder.Decode(&errResp); err != nil {
-			return message{}, err
-		}
-		return message{}, &errResp
-	}
-
-	var msg message
-	if err := decoder.Decode(&msg); err != nil {
-		return message{}, err
-	}
-
-	return msg, nil
-}
-
-func (p *GmailPlugin) requestMessage(id, accessToken string) (*http.Response, error) {
-	u, err := baseUrl.Parse("messages/" + id)
-	if err != nil {
-		return nil, err
-	}
-
-	query := u.Query()
-	// only request specific fields
-	query.Add("fields", "snippet,threadId,id,payload/headers")
-	// get the full message to get From and Subject from headers
-	query.Add("format", "full")
-	u.RawQuery = query.Encode()
-
-	req, err := http.NewRequest("GET", u.String(), nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Authorization", "Bearer "+accessToken)
-
-	return http.DefaultClient.Do(req)
-}
-
-func (p *GmailPlugin) requestMessageList(accessToken string) (*http.Response, error) {
-	u, err := baseUrl.Parse("messages")
-	if err != nil {
-		return nil, err
-	}
-
-	query := u.Query()
-
-	// get all unread inbox emails received after
-	// the last time we checked. If this is the first
-	// time we check, get unread emails after timeDelta
-	query.Add("q", fmt.Sprintf("is:unread in:inbox newer_than:%s", relativeTimeDelta))
-	u.RawQuery = query.Encode()
-
-	req, err := http.NewRequest("GET", u.String(), nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Authorization", "Bearer "+accessToken)
-
-	return http.DefaultClient.Do(req)
-}

=== removed directory 'plugins/gcalendar'
=== removed file 'plugins/gcalendar/api.go'
--- plugins/gcalendar/api.go	2016-04-14 14:58:10 +0000
+++ plugins/gcalendar/api.go	1970-01-01 00:00:00 +0000
@@ -1,54 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package gcalendar
-
-import (
-	"fmt"
-)
-
-// eventList holds a response to call to Calendar.events: list
-// defined in https://developers.google.com/google-apps/calendar/v3/reference/events/list#response
-type eventList struct {
-	// Messages holds a list of message.
-	Events []event `json:"items"`
-}
-
-// event holds the event data response for a Calendar.event.
-// The full definition of a message is defined in
-// https://developers.google.com/google-apps/calendar/v3/reference/events#resource-representations
-type event struct {
-	// Id is the immutable ID of the message.
-	Etag string `json:"etag"`
-	// ThreadId is the ID of the thread the message belongs to.
-	Summary string `json:"summary"`
-}
-
-func (e event) String() string {
-	return fmt.Sprintf("Id: %s, snippet: '%s'\n", e.Etag, e.Summary)
-}
-
-type errorResp struct {
-	Err struct {
-		Code    uint64 `json:"code"`
-		Message string `json:"message"`
-		Errors  []struct {
-			Domain  string `json:"domain"`
-			Reason  string `json:"reason"`
-			Message string `json:"message"`
-		} `json:"errors"`
-	} `json:"error"`
-}

=== removed file 'plugins/gcalendar/gcalendar.go'
--- plugins/gcalendar/gcalendar.go	2016-08-02 14:16:26 +0000
+++ plugins/gcalendar/gcalendar.go	1970-01-01 00:00:00 +0000
@@ -1,189 +0,0 @@
-/*
- Copyright 2016 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package gcalendar
-
-import (
-	"encoding/json"
-	"log"
-	"net/http"
-	"net/url"
-	"os"
-
-	"launchpad.net/account-polld/accounts"
-	"launchpad.net/account-polld/plugins"
-	"launchpad.net/account-polld/syncmonitor"
-)
-
-const (
-	APP_ID     = "com.ubuntu.calendar_calendar"
-	pluginName = "gcalendar"
-)
-
-var baseUrl, _ = url.Parse("https://www.googleapis.com/calendar/v3/calendars/")
-
-type GCalendarPlugin struct {
-	accountId uint
-}
-
-func New(accountId uint) *GCalendarPlugin {
-	return &GCalendarPlugin{accountId: accountId}
-}
-
-func (p *GCalendarPlugin) ApplicationId() plugins.ApplicationId {
-	return plugins.ApplicationId(APP_ID)
-}
-
-func (p *GCalendarPlugin) Poll(authData *accounts.AuthData) ([]*plugins.PushMessageBatch, error) {
-	// This envvar check is to ease testing.
-	if token := os.Getenv("ACCOUNT_POLLD_TOKEN_GCALENDAR"); token != "" {
-		log.Print("calendar: Using token from: ACCOUNT_POLLD_TOKEN_GCALENDAR env var")
-		authData.AccessToken = token
-	}
-
-	log.Print("calendar: Check calendar changes for account:", p.accountId)
-
-	syncMonitor := syncmonitor.NewSyncMonitor()
-	if syncMonitor == nil {
-		log.Print("calendar: Sync monitor not available yet.")
-		return nil, nil
-	}
-
-	state, err := syncMonitor.State()
-	if err != nil {
-		log.Print("calendar: Fail to retrieve sync monitor state ", err)
-		return nil, nil
-	}
-	if state != "idle" {
-		log.Print("calendar: Sync monitor is not on 'idle' state, try later!")
-		return nil, nil
-	}
-
-	calendars, err := syncMonitor.ListCalendarsByAccount(p.accountId)
-	if err != nil {
-		log.Print("calendar: Calendar plugin ", p.accountId, ": cannot load calendars: ", err)
-		return nil, nil
-	}
-
-	var calendarsToSync []string
-	log.Print("calendar: Number of calendars for account:", p.accountId, " size:", len(calendars))
-
-	for id, calendar := range calendars {
-		lastSyncDate, err := syncMonitor.LastSyncDate(p.accountId, id)
-		if err != nil {
-			log.Print("\tcalendar: ", calendar, ", cannot load previous sync date: ", err, ". Try next time.")
-			continue
-		} else {
-			log.Print("\tcalendar: ", calendar, " Id: ", id, ": last sync date: ", lastSyncDate)
-		}
-
-		var needSync bool
-		needSync = (len(lastSyncDate) == 0)
-
-		if !needSync {
-			resp, err := p.requestChanges(authData.AccessToken, id, lastSyncDate)
-			if err != nil {
-				log.Print("\tcalendar: ERROR: Fail to query for changes: ", err)
-				continue
-			}
-
-			messages, err := p.parseChangesResponse(resp)
-			if err != nil {
-				log.Print("\tcalendar: ERROR: Fail to parse changes: ", err)
-				if err == plugins.ErrTokenExpired {
-					log.Print("\t\tcalendar: Abort poll")
-					return nil, err
-				} else {
-					continue
-				}
-			}
-			needSync = (len(messages) > 0)
-		}
-
-		if needSync {
-			log.Print("\tcalendar: Calendar needs sync: ", calendar)
-			calendarsToSync = append(calendarsToSync, id)
-		} else {
-			log.Print("\tcalendar: Found no calendar updates for account: ", p.accountId, " calendar: ", calendar)
-		}
-	}
-
-	if len(calendarsToSync) > 0 {
-		log.Print("calendar: Request account sync")
-		err = syncMonitor.SyncAccount(p.accountId, calendarsToSync)
-		if err != nil {
-			log.Print("calendar: ERROR: Fail to start account sync ", p.accountId, " message: ", err)
-		}
-	}
-
-	return nil, nil
-}
-
-func (p *GCalendarPlugin) parseChangesResponse(resp *http.Response) ([]event, error) {
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	if resp.StatusCode != http.StatusOK {
-		var errResp errorResp
-		log.Print("calendar: Invalid response:", errResp.Err.Code)
-		if err := decoder.Decode(&errResp); err != nil {
-			return nil, err
-		}
-		if errResp.Err.Code == 401 {
-			return nil, plugins.ErrTokenExpired
-		}
-		return nil, nil
-	}
-
-	var events eventList
-	if err := decoder.Decode(&events); err != nil {
-		log.Print("calendar: Fail to decode")
-		return nil, err
-	}
-
-	for _, ev := range events.Events {
-		log.Print("calendar: Found event: ", ev.Etag, ev.Summary)
-	}
-
-	return events.Events, nil
-}
-
-func (p *GCalendarPlugin) requestChanges(accessToken string, calendar string, lastSyncDate string) (*http.Response, error) {
-	u, err := baseUrl.Parse("")
-	if err != nil {
-		return nil, err
-	}
-	u.Path += calendar + "/events"
-
-	//GET https://www.googleapis.com/calendar/v3/calendars/<calendar>/events?showDeleted=true&singleEvents=true&updatedMin=2016-04-06T10%3A00%3A00.00Z&fields=description%2Citems(description%2Cetag%2Csummary)&key={YOUR_API_KEY}
-	query := u.Query()
-	query.Add("showDeleted", "true")
-	query.Add("singleEvents", "true")
-	query.Add("fields", "description,items(summary,etag)")
-	query.Add("maxResults", "1")
-	if len(lastSyncDate) > 0 {
-		query.Add("updatedMin", lastSyncDate)
-	}
-	u.RawQuery = query.Encode()
-
-	req, err := http.NewRequest("GET", u.String(), nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Authorization", "Bearer "+accessToken)
-
-	return http.DefaultClient.Do(req)
-}

=== removed directory 'plugins/gmail'
=== removed file 'plugins/gmail/api.go'
--- plugins/gmail/api.go	2015-03-20 14:34:48 +0000
+++ plugins/gmail/api.go	1970-01-01 00:00:00 +0000
@@ -1,127 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package gmail
-
-import (
-	"fmt"
-	"time"
-
-	"launchpad.net/account-polld/plugins"
-)
-
-const gmailTime = "Mon, 2 Jan 2006 15:04:05 -0700"
-
-type pushes map[string]*plugins.PushMessage
-type headers map[string]string
-
-// messageList holds a response to call to Users.messages: list
-// defined in https://developers.google.com/gmail/api/v1/reference/users/messages/list
-type messageList struct {
-	// Messages holds a list of message.
-	Messages []message `json:"messages"`
-	// NextPageToken is used to retrieve the next page of results in the list.
-	NextPageToken string `json:"nextPageToken"`
-	// ResultSizeEstimage is the estimated total number of results.
-	ResultSizeEstimage uint64 `json:"resultSizeEstimate"`
-}
-
-// message holds a partial response for a Users.messages.
-// The full definition of a message is defined in
-// https://developers.google.com/gmail/api/v1/reference/users/messages#resource
-type message struct {
-	// Id is the immutable ID of the message.
-	Id string `json:"id"`
-	// ThreadId is the ID of the thread the message belongs to.
-	ThreadId string `json:"threadId"`
-	// HistoryId is the ID of the last history record that modified
-	// this message.
-	HistoryId string `json:"historyId"`
-	// Snippet is a short part of the message text. This text is
-	// used for the push message summary.
-	Snippet string `json:"snippet"`
-	// Payload represents the message payload.
-	Payload payload `json:"payload"`
-}
-
-func (m message) String() string {
-	return fmt.Sprintf("Id: %d, snippet: '%s'\n", m.Id, m.Snippet[:10])
-}
-
-// ById implements sort.Interface for []message based on
-// the Id field.
-type byId []message
-
-func (m byId) Len() int           { return len(m) }
-func (m byId) Swap(i, j int)      { m[i], m[j] = m[j], m[i] }
-func (m byId) Less(i, j int) bool { return m[i].Id < m[j].Id }
-
-// payload represents the message payload.
-type payload struct {
-	Headers []messageHeader `json:"headers"`
-}
-
-func (p *payload) mapHeaders() headers {
-	headers := make(map[string]string)
-	for _, hdr := range p.Headers {
-		headers[hdr.Name] = hdr.Value
-	}
-	return headers
-}
-
-func (hdr headers) getTimestamp() time.Time {
-	timestamp, ok := hdr[hdrDATE]
-	if !ok {
-		return time.Now()
-	}
-
-	if t, err := time.Parse(gmailTime, timestamp); err == nil {
-		return t
-	}
-	return time.Now()
-}
-
-func (hdr headers) getEpoch() int64 {
-	return hdr.getTimestamp().Unix()
-}
-
-// messageHeader represents the message headers.
-type messageHeader struct {
-	Name  string `json:"name"`
-	Value string `json:"value"`
-}
-
-type errorResp struct {
-	Err struct {
-		Code    uint64 `json:"code"`
-		Message string `json:"message"`
-		Errors  []struct {
-			Domain  string `json:"domain"`
-			Reason  string `json:"reason"`
-			Message string `json:"message"`
-		} `json:"errors"`
-	} `json:"error"`
-}
-
-func (err *errorResp) Error() string {
-	return fmt.Sprint("backend response:", err.Err.Message)
-}
-
-const (
-	hdrDATE    = "Date"
-	hdrSUBJECT = "Subject"
-	hdrFROM    = "From"
-)

=== removed file 'plugins/gmail/gmail.go'
--- plugins/gmail/gmail.go	2016-04-20 11:10:17 +0000
+++ plugins/gmail/gmail.go	1970-01-01 00:00:00 +0000
@@ -1,346 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package gmail
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/mail"
-	"net/url"
-	"os"
-	"regexp"
-	"sort"
-	"strings"
-	"time"
-
-	"log"
-
-	"launchpad.net/account-polld/accounts"
-	"launchpad.net/account-polld/gettext"
-	"launchpad.net/account-polld/plugins"
-	"launchpad.net/account-polld/qtcontact"
-)
-
-const (
-	APP_ID           = "com.ubuntu.developer.webapps.webapp-gmail_webapp-gmail"
-	gmailDispatchUrl = "https://mail.google.com/mail/mu/mp/#cv/priority/^smartlabel_%s/%s"
-	// If there's more than 10 emails in one batch, we don't show 10 notification
-	// bubbles, but instead show one summary. We always show all notifications in the
-	// indicator.
-	individualNotificationsLimit = 10
-	pluginName                   = "gmail"
-)
-
-type reportedIdMap map[string]time.Time
-
-var baseUrl, _ = url.Parse("https://www.googleapis.com/gmail/v1/users/me/")
-
-// timeDelta defines how old messages can be to be reported.
-var timeDelta = time.Duration(time.Hour * 24)
-
-// trackDelta defines how old messages can be before removed from tracking
-var trackDelta = time.Duration(time.Hour * 24 * 7)
-
-// relativeTimeDelta is the same as timeDelta
-var relativeTimeDelta string = "1d"
-
-// regexp for identifying non-ascii characters
-var nonAsciiChars, _ = regexp.Compile("[^\x00-\x7F]")
-
-type GmailPlugin struct {
-	// reportedIds holds the messages that have already been notified. This
-	// approach is taken against timestamps as it avoids needing to call
-	// get on the message.
-	reportedIds reportedIdMap
-	accountId   uint
-}
-
-func idsFromPersist(accountId uint) (ids reportedIdMap, err error) {
-	err = plugins.FromPersist(pluginName, accountId, &ids)
-	if err != nil {
-		return nil, err
-	}
-	// discard old ids
-	timestamp := time.Now()
-	for k, v := range ids {
-		delta := timestamp.Sub(v)
-		if delta > trackDelta {
-			log.Print("gmail plugin ", accountId, ": deleting ", k, " as ", delta, " is greater than ", trackDelta)
-			delete(ids, k)
-		}
-	}
-	return ids, nil
-}
-
-func (ids reportedIdMap) persist(accountId uint) (err error) {
-	err = plugins.Persist(pluginName, accountId, ids)
-	if err != nil {
-		log.Print("gmail plugin ", accountId, ": failed to save state: ", err)
-	}
-	return nil
-}
-
-func New(accountId uint) *GmailPlugin {
-	reportedIds, err := idsFromPersist(accountId)
-	if err != nil {
-		log.Print("gmail plugin ", accountId, ": cannot load previous state from storage: ", err)
-	} else {
-		log.Print("gmail plugin ", accountId, ": last state loaded from storage")
-	}
-	return &GmailPlugin{reportedIds: reportedIds, accountId: accountId}
-}
-
-func (p *GmailPlugin) ApplicationId() plugins.ApplicationId {
-	return plugins.ApplicationId(APP_ID)
-}
-
-func (p *GmailPlugin) Poll(authData *accounts.AuthData) ([]*plugins.PushMessageBatch, error) {
-	// This envvar check is to ease testing.
-	if token := os.Getenv("ACCOUNT_POLLD_TOKEN_GMAIL"); token != "" {
-		authData.AccessToken = token
-	}
-
-	resp, err := p.requestMessageList(authData.AccessToken)
-	if err != nil {
-		return nil, err
-	}
-	messages, err := p.parseMessageListResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO use the batching API defined in https://developers.google.com/gmail/api/guides/batch
-	for i := range messages {
-		resp, err := p.requestMessage(messages[i].Id, authData.AccessToken)
-		if err != nil {
-			return nil, err
-		}
-		messages[i], err = p.parseMessageResponse(resp)
-		if err != nil {
-			return nil, err
-		}
-	}
-	notif, err := p.createNotifications(messages)
-	if err != nil {
-		return nil, err
-	}
-	return []*plugins.PushMessageBatch{
-		&plugins.PushMessageBatch{
-			Messages:        notif,
-			Limit:           individualNotificationsLimit,
-			OverflowHandler: p.handleOverflow,
-			Tag:             "gmail",
-		}}, nil
-
-}
-
-func (p *GmailPlugin) reported(id string) bool {
-	_, ok := p.reportedIds[id]
-	return ok
-}
-
-func (p *GmailPlugin) createNotifications(messages []message) ([]*plugins.PushMessage, error) {
-	timestamp := time.Now()
-	pushMsgMap := make(pushes)
-
-	for _, msg := range messages {
-		hdr := msg.Payload.mapHeaders()
-
-		from := hdr[hdrFROM]
-		var avatarPath string
-
-		emailAddress, err := mail.ParseAddress(from)
-		if err != nil {
-			// If the email address contains non-ascii characters, we get an
-			// error so we're going to try again, this time mangling the name
-			// by removing all non-ascii characters. We only care about the email
-			// address here anyway.
-			// XXX: We can't check the error message due to [1]: the error
-			// message is different in go < 1.3 and > 1.5.
-			// [1] https://github.com/golang/go/issues/12492
-			mangledAddr := nonAsciiChars.ReplaceAllString(from, "")
-			mangledEmail, mangledParseError := mail.ParseAddress(mangledAddr)
-			if mangledParseError == nil {
-				emailAddress = mangledEmail
-			}
-		} else if emailAddress.Name != "" {
-			// We only want the Name if the first ParseAddress
-			// call was successful. I.e. we do not want the name
-			// from a mangled email address.
-			from = emailAddress.Name
-		}
-
-		if emailAddress != nil {
-			avatarPath = qtcontact.GetAvatar(emailAddress.Address)
-			// If icon path starts with a path separator, assume local file path,
-			// encode it and prepend file scheme defined in RFC 1738.
-			if strings.HasPrefix(avatarPath, string(os.PathSeparator)) {
-				avatarPath = url.QueryEscape(avatarPath)
-				avatarPath = "file://" + avatarPath
-			}
-		}
-
-		msgStamp := hdr.getTimestamp()
-
-		if _, ok := pushMsgMap[msg.ThreadId]; ok {
-			// TRANSLATORS: the %s is an appended "from" corresponding to an specific email thread
-			pushMsgMap[msg.ThreadId].Notification.Card.Summary += fmt.Sprintf(gettext.Gettext(", %s"), from)
-		} else if timestamp.Sub(msgStamp) < timeDelta {
-			// TRANSLATORS: the %s is the "from" header corresponding to a specific email
-			summary := fmt.Sprintf(gettext.Gettext("%s"), from)
-			// TRANSLATORS: the first %s refers to the email "subject", the second %s refers "from"
-			body := fmt.Sprintf(gettext.Gettext("%s\n%s"), hdr[hdrSUBJECT], msg.Snippet)
-			// fmt with label personal and threadId
-			action := fmt.Sprintf(gmailDispatchUrl, "personal", msg.ThreadId)
-			epoch := hdr.getEpoch()
-			pushMsgMap[msg.ThreadId] = plugins.NewStandardPushMessage(summary, body, action, avatarPath, epoch)
-		} else {
-			log.Print("gmail plugin ", p.accountId, ": skipping message id ", msg.Id, " with date ", msgStamp, " older than ", timeDelta)
-		}
-	}
-	pushMsg := make([]*plugins.PushMessage, 0, len(pushMsgMap))
-	for _, v := range pushMsgMap {
-		pushMsg = append(pushMsg, v)
-	}
-	return pushMsg, nil
-
-}
-func (p *GmailPlugin) handleOverflow(pushMsg []*plugins.PushMessage) *plugins.PushMessage {
-	// TODO it would probably be better to grab the estimate that google returns in the message list.
-	approxUnreadMessages := len(pushMsg)
-
-	// TRANSLATORS: the %d refers to the number of new email messages.
-	summary := fmt.Sprintf(gettext.Gettext("You have %d new messages"), approxUnreadMessages)
-
-	body := ""
-
-	// fmt with label personal and no threadId
-	action := fmt.Sprintf(gmailDispatchUrl, "personal")
-	epoch := time.Now().Unix()
-
-	return plugins.NewStandardPushMessage(summary, body, action, "", epoch)
-}
-
-func (p *GmailPlugin) parseMessageListResponse(resp *http.Response) ([]message, error) {
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	if resp.StatusCode != http.StatusOK {
-		var errResp errorResp
-		if err := decoder.Decode(&errResp); err != nil {
-			return nil, err
-		}
-		if errResp.Err.Code == 401 {
-			return nil, plugins.ErrTokenExpired
-		}
-		return nil, &errResp
-	}
-
-	var messages messageList
-	if err := decoder.Decode(&messages); err != nil {
-		return nil, err
-	}
-
-	filteredMsg := p.messageListFilter(messages.Messages)
-
-	return filteredMsg, nil
-}
-
-// messageListFilter returns a subset of unread messages where the subset
-// depends on not being in reportedIds. Before returning, reportedIds is
-// updated with the new list of unread messages.
-func (p *GmailPlugin) messageListFilter(messages []message) []message {
-	sort.Sort(byId(messages))
-	var reportMsg []message
-	var ids = make(reportedIdMap)
-
-	for _, msg := range messages {
-		if !p.reported(msg.Id) {
-			reportMsg = append(reportMsg, msg)
-		}
-		ids[msg.Id] = time.Now()
-	}
-	p.reportedIds = ids
-	p.reportedIds.persist(p.accountId)
-	return reportMsg
-}
-
-func (p *GmailPlugin) parseMessageResponse(resp *http.Response) (message, error) {
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	if resp.StatusCode != http.StatusOK {
-		var errResp errorResp
-		if err := decoder.Decode(&errResp); err != nil {
-			return message{}, err
-		}
-		return message{}, &errResp
-	}
-
-	var msg message
-	if err := decoder.Decode(&msg); err != nil {
-		return message{}, err
-	}
-
-	return msg, nil
-}
-
-func (p *GmailPlugin) requestMessage(id, accessToken string) (*http.Response, error) {
-	u, err := baseUrl.Parse("messages/" + id)
-	if err != nil {
-		return nil, err
-	}
-
-	query := u.Query()
-	// only request specific fields
-	query.Add("fields", "snippet,threadId,id,payload/headers")
-	// get the full message to get From and Subject from headers
-	query.Add("format", "full")
-	u.RawQuery = query.Encode()
-
-	req, err := http.NewRequest("GET", u.String(), nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Authorization", "Bearer "+accessToken)
-
-	return http.DefaultClient.Do(req)
-}
-
-func (p *GmailPlugin) requestMessageList(accessToken string) (*http.Response, error) {
-	u, err := baseUrl.Parse("messages")
-	if err != nil {
-		return nil, err
-	}
-
-	query := u.Query()
-
-	// get all unread inbox emails received after
-	// the last time we checked. If this is the first
-	// time we check, get unread emails after timeDelta
-	query.Add("q", fmt.Sprintf("is:unread in:inbox newer_than:%s", relativeTimeDelta))
-	u.RawQuery = query.Encode()
-
-	req, err := http.NewRequest("GET", u.String(), nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Authorization", "Bearer "+accessToken)
-
-	return http.DefaultClient.Do(req)
-}

=== removed file 'plugins/plugins.go'
--- plugins/plugins.go	2016-02-08 19:21:31 +0000
+++ plugins/plugins.go	1970-01-01 00:00:00 +0000
@@ -1,239 +0,0 @@
-/*
- Copyright 2014 Canonical Ltd.
-
- This program is free software: you can redistribute it and/or modify it
- under the terms of the GNU 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 warranties of
- MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-*/
-
-package plugins
-
-import (
-	"bufio"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"reflect"
-
-	"launchpad.net/account-polld/accounts"
-	"launchpad.net/go-xdg/v0"
-)
-
-func init() {
-	cmdName = filepath.Base(os.Args[0])
-}
-
-// Plugin is an interface which the plugins will adhere to for the poll
-// daemon to interact with.
-//
-// Poll interacts with the backend service with the means the plugin defines
-// and  returns a list of Notifications to send to the Push service. If an
-// error occurs and is returned the daemon can decide to throttle the service.
-//
-// ApplicationId returns the APP_ID of the delivery target for Post Office.
-type Plugin interface {
-	ApplicationId() ApplicationId
-	Poll(*accounts.AuthData) ([]*PushMessageBatch, error)
-}
-
-// AuthTokens is a map with tokens the plugins are to use to make requests.
-type AuthTokens map[string]interface{}
-
-// ApplicationId represents the application id to direct posts to.
-// e.g.: com.ubuntu.diaspora_diaspora or com.ubuntu.diaspora_diaspora_1.0
-type ApplicationId string
-
-// NewStandardPushMessage creates a base Notification with common
-// components (members) setup.
-func NewStandardPushMessage(summary, body, action, icon string, epoch int64) *PushMessage {
-	pm := &PushMessage{
-		Notification: Notification{
-			Card: &Card{
-				Summary:   summary,
-				Body:      body,
-				Actions:   []string{action},
-				Icon:      icon,
-				Timestamp: epoch,
-				Popup:     true,
-				Persist:   true,
-			},
-			Sound:   DefaultSound(),
-			Vibrate: true,
-			Tag:     cmdName,
-		},
-	}
-	return pm
-}
-
-// PushMessageBatch represents a logical grouping of PushMessages that
-// have a limit on the number of their notifications that want to be
-// presented to the user at the same time, and a way to handle the
-// overflow. All Notifications that are part of a Batch share the same
-// tag (Tag).  ${Tag}-overflow is the overflow notification tag.
-//
-// TODO: support notifications sharing just the prefix (so the app can
-// tell them apart by tag).
-type PushMessageBatch struct {
-	Messages        []*PushMessage
-	Limit           int
-	OverflowHandler func([]*PushMessage) *PushMessage
-	Tag             string
-}
-
-// PushMessage represents a data structure to be sent over to the
-// Post Office. It consists of a Notification and a Message.
-type PushMessage struct {
-	// Message represents a JSON object that is passed as-is to the
-	// application
-	Message string `json:"message,omitempty"`
-	// Notification (optional) describes the user-facing notifications
-	// triggered by this push message.
-	Notification Notification `json:"notification,omitempty"`
-}
-
-// Notification (optional) describes the user-facing notifications
-// triggered by this push message.
-type Notification struct {
-	// Sound (optional) is the path to a sound file which can or
-	// cannot be played depending on user preferences.
-	Sound string `json:"sound,omitempty"`
-	// Card represents a specific bubble to give to the user
-	Card *Card `json:"card,omitempty"`
-	// Vibrate is the haptic feedback part of a notification.
-	Vibrate bool `json:"vibrate,omitempty"`
-	// EmblemCounter represents and application counter hint
-	// related to the notification.
-	EmblemCounter *EmblemCounter `json:"emblem-counter,omitempty"`
-	// Tag represents a tag to identify persistent notifications
-	Tag string `json:"tag,omitempty"`
-}
-
-// Card is part of a notification and represents the user visible hints for
-// a specific notification.
-type Card struct {
-	// Summary is a required title. The card will not be presented if this is missing.
-	Summary string `json:"summary"`
-	// Body is the longer text.
-	Body string `json:"body,omitempty"`
-	// Whether to show a bubble. Users can disable this, and can easily miss
-	// them, so don’t rely on it exclusively.
-	Popup bool `json:"popup,omitempty"`
-	// Actions provides actions for the bubble's snap decissions.
-	Actions []string `json:"actions,omitempty"`
-	// Icon is a path to an icon to display with the notification bubble.
-	Icon string `json:"icon,omitempty"`
-	// Whether to show in notification centre.
-	Persist bool `json:"persist,omitempty"`
-	// Seconds since the unix epoch, useful for persistent cards.
-	Timestamp int64 `json:"Timestamp,omitempty"`
-}
-
-// EmblemCounter is part of a notification and represents the application visual
-// hints related to a notification.
-type EmblemCounter struct {
-	// Count is a number to be displayed over the application’s icon in the
-	// launcher.
-	Count uint `json:"count"`
-	// Visible determines if the counter is visible or not.
-	Visible bool `json:"visible"`
-}
-
-// The constanst defined here determine the polling aggressivenes with the following criteria
-// MAXIMUM: calls, health warning
-// HIGH: SMS, chat message, new email
-// DEFAULT: social media updates
-// LOW: software updates, junk email
-const (
-	PRIORITY_MAXIMUM = 0
-	PRIORITY_HIGH
-	PRIORITY_DEFAULT
-	PRIORITY_LOW
-)
-
-const (
-	PLUGIN_EMAIL = 0
-	PLUGIN_SOCIAL
-)
-
-// ErrTokenExpired is the error returned by a plugin to indicate that
-// the web service reported that the authentication token has expired.
-var ErrTokenExpired = errors.New("Token expired")
-
-var cmdName string
-
-var XdgDataFind = xdg.Data.Find
-var XdgDataEnsure = xdg.Data.Ensure
-
-// Persist stores the plugins data in a common location to a json file
-// from which it can recover later
-func Persist(pluginName string, accountId uint, data interface{}) (err error) {
-	var p string
-	defer func() {
-		if err != nil && p != "" {
-			os.Remove(p)
-		}
-	}()
-	p, err = XdgDataEnsure(filepath.Join(cmdName, fmt.Sprintf("%s-%d.json", pluginName, accountId)))
-	if err != nil {
-		return err
-	}
-	file, err := os.Create(p)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-	w := bufio.NewWriter(file)
-	defer w.Flush()
-	jsonWriter := json.NewEncoder(w)
-	if err := jsonWriter.Encode(data); err != nil {
-		return err
-	}
-	return nil
-}
-
-// FromPersist restores the plugins data from a common location which
-// was stored in a json file
-func FromPersist(pluginName string, accountId uint, data interface{}) (err error) {
-	if reflect.ValueOf(data).Kind() != reflect.Ptr {
-		return errors.New("decode target is not a pointer")
-	}
-	var p string
-	defer func() {
-		if err != nil {
-			if p != "" {
-				os.Remove(p)
-			}
-		}
-	}()
-	p, err = XdgDataFind(filepath.Join(cmdName, fmt.Sprintf("%s-%d.json", pluginName, accountId)))
-	if err != nil {
-		return err
-	}
-	file, err := os.Open(p)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-	jsonReader := json.NewDecoder(file)
-	if err := jsonReader.Decode(&data); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// DefaultSound returns the path to the default sound for a Notification