Merge lp:~sforshee/powerd/register-ack-api into lp:powerd

[Seth Forshee]

Add support for registering clients to acknowledge system state changes

Add support for registering clients to acknowledge system state changes

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:84
http://jenkins.qa.ubuntu.com/job/powerd-ci/95/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/49
        deb: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/49/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/powerd-ci/95/rebuild

review: Approve (continuous-integration)

[lp:~sforshee/powerd/register-ack-api]

85. By Seth Forshee on 2013-07-24

powerd-object: Remove unneeded argument from ack dbus handler

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:85
http://jenkins.qa.ubuntu.com/job/powerd-ci/96/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/50
        deb: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/50/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/powerd-ci/96/rebuild

review: Approve (continuous-integration)

[lp:~sforshee/powerd/register-ack-api]

86. By Seth Forshee on 2013-07-24

Add state argument to ackStateChange dbus API

Without any arguments to the ackStateChange API we have a
possibility for races. If two state changes happen back-to-back,
a client who sends the ack late for the first state change might
inadvertantly acknowledge the second state change. Explicilty
specifying which state change is being acknowledge will help
avoid such issues.

Also add a test to verify that acking with the wrong state fails
as expected.

[Matt Fischer (mfisch)]

Comments so far:

488 + powerd_warn("Timeout waiting for acks on state transition");

Should we list the offenders here?

powerd-client.c is a confusing name since it's still part of the service, but I'm okay keeping it if you like the name.

583 + powerd_error("Client needs ack while global state is %d", acks_needed);

Either the text here or the variable you are printing does not make sense. Are you trying to print the state?

Should we drop a client from the ack list if they don't send acks? What if they don't respond to 10 in a row for example?

Should we drop the name argument (this is pending some investigation by me)

[Seth Forshee (sforshee)]

On Wed, Jul 24, 2013 at 05:39:29PM -0000, Matthew Fischer wrote:
> Comments so far:
>
> 488 + powerd_warn("Timeout waiting for acks on state transition");
>
> Should we list the offenders here?

powerd_client_transition_finish() will print out the offenders.

> powerd-client.c is a confusing name since it's still part of the service, but I'm okay keeping it if you like the name.

I'm open to suggestions ;-)

> 583 + powerd_error("Client needs ack while global state is %d", acks_needed);
>
> Either the text here or the variable you are printing does not make sense. Are you trying to print the state?

The text is the problem. I'll change it.

> Should we drop a client from the ack list if they don't send acks? What if they don't respond to 10 in a row for example?

This might be a good idea. Could we go ahead and get it in without this
feature and make a work item for it?

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:86
http://jenkins.qa.ubuntu.com/job/powerd-ci/97/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/51
        deb: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/51/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/powerd-ci/97/rebuild

review: Approve (continuous-integration)

[lp:~sforshee/powerd/register-ack-api]

87. By Seth Forshee on 2013-07-24

powerd-cli: Print results for more client tests

powerd-cli still can't print results for every test, but it
should print resulsts whenever possible.

88. By Seth Forshee on 2013-07-24

powerd-cli: Remove some debug prints in client-test

89. By Seth Forshee on 2013-07-24

powerd-client: Reword confusing error message

[Matt Fischer (mfisch)]

Looks good.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:89
http://jenkins.qa.ubuntu.com/job/powerd-ci/98/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/52
        deb: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/52/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/powerd-ci/98/rebuild

review: Approve (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-07-10 21:39:32 +0000
+++ CMakeLists.txt	2013-07-24 20:12:24 +0000
@@ -41,9 +41,10 @@
   src/display.c
   src/display-request.c
   src/log.c
-  src/powerd-object.c
   src/power-request.c
   src/power-source.c
+  src/powerd-client.c
+  src/powerd-object.c
   src/powerd-sensors.cpp
   src/util.c
   src/${GDBUS_NAME}.c

=== modified file 'cli/CMakeLists.txt'
--- cli/CMakeLists.txt	2013-06-06 21:43:31 +0000
+++ cli/CMakeLists.txt	2013-07-24 20:12:24 +0000
@@ -2,6 +2,7 @@
   SRCS
 
   powerd-cli.c
+  client-test.c
 )
 
 link_directories(

=== added file 'cli/client-test.c'
--- cli/client-test.c	1970-01-01 00:00:00 +0000
+++ cli/client-test.c	2013-07-24 20:12:24 +0000
@@ -0,0 +1,310 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * powerd is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+
+#include "powerd-cli.h"
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+
+static struct client_test_data {
+    GDBusProxy *proxy;
+    int state;
+    int ack_delay;
+    guint ack_timeout_id;
+    powerd_cookie_t cookie;
+} test_data;
+
+enum ack_status {
+    NOT_ACKED,
+    ACK_SUCCESS,
+    ACK_FAILURE,
+    ACK_TIMEOUT,
+} ack_status;;
+
+static GMainLoop *main_loop;
+
+static gboolean run_next_test_handler(gpointer unused);
+
+static void reset_test_state(void)
+{
+    ack_status = NOT_ACKED;
+}
+
+static void run_next_test(void)
+{
+    g_timeout_add(0, run_next_test_handler, NULL);
+}
+
+static gboolean register_client(GDBusProxy *proxy)
+{
+    GVariant *ret;
+    GError *error = NULL;
+
+    ret = g_dbus_proxy_call_sync(proxy, "registerClient",
+                                 g_variant_new("(s)", "powerd-cli"),
+                                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+    if (!ret) {
+        cli_warn("registerClient failed: %s", error->message);
+        g_error_free(error);
+        return FALSE;
+    }
+
+    g_variant_unref(ret);
+    return TRUE;
+}
+
+static gboolean unregister_client(GDBusProxy *proxy)
+{
+    GVariant *ret;
+    GError *error = NULL;
+
+    ret = g_dbus_proxy_call_sync(proxy, "unregisterClient",
+                                 g_variant_new("(s)", "powerd-cli"),
+                                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+    if (!ret) {
+        cli_warn("unregisterClient failed: %s", error->message);
+        g_error_free(error);
+        return FALSE;
+    }
+
+    g_variant_unref(ret);
+    return TRUE;
+}
+
+static gboolean ack_state_change(GDBusProxy *proxy, int state)
+{
+    GVariant *ret;
+    GError *error = NULL;
+
+    ret = g_dbus_proxy_call_sync(proxy, "ackStateChange",
+                                 g_variant_new("(i)", state),
+                                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+    if (!ret) {
+        cli_warn("ackStateChange failed: %s", error->message);
+        g_error_free(error);
+        ack_status = ACK_FAILURE;
+        return FALSE;
+    }
+
+    g_variant_unref(ret);
+    ack_status = ACK_SUCCESS;
+    return TRUE;
+}
+
+static gboolean send_ack_handler(gpointer unused)
+{
+    if (ack_state_change(test_data.proxy, test_data.state))
+        run_next_test();
+    return FALSE;
+}
+
+static gboolean ack_timeout_handler(gpointer unused)
+{
+    test_data.ack_timeout_id = 0;
+    ack_status = ACK_TIMEOUT;
+    run_next_test();
+    return FALSE;
+}
+
+static void powerd_signal_handler(GDBusProxy *proxy, gchar *sender,
+                                  gchar *signal, GVariant *params,
+                                  gpointer unused)
+{
+    cli_debug("Received signal %s\n", signal);
+    if (strcmp(signal, "SysPowerStateChange"))
+        return;
+
+    /* Check if we're trying to time out */
+    if (test_data.ack_delay < 0)
+        return;
+
+    if (test_data.ack_timeout_id > 0) {
+        g_source_remove(test_data.ack_timeout_id);
+        test_data.ack_timeout_id = 0;
+    }
+
+    if (test_data.ack_delay == 0) {
+        /* immediate ack */
+        ack_state_change(proxy, test_data.state);
+        run_next_test();
+    } else {
+        /* delayed ack */
+        g_timeout_add(test_data.ack_delay, send_ack_handler, NULL);
+    }
+}
+
+static gboolean register_test(gpointer unused)
+{
+    gboolean result;
+
+    result = do_test(register_client(test_data.proxy) == TRUE);
+    if (!result)
+        g_main_loop_quit(main_loop);
+    else {
+        run_next_test();
+    }
+    return FALSE;
+}
+
+static gboolean ack_test_part1(gpointer unused)
+{
+    printf("Testing ack on active state transition\n");
+
+    test_data.state = POWERD_SYS_STATE_ACTIVE;
+    test_data.ack_delay = 0;
+    reset_test_state();
+    test_data.ack_timeout_id = g_timeout_add(5000, ack_timeout_handler, NULL);
+    requestSysState(test_data.state, &test_data.cookie);
+    return FALSE;
+}
+
+static gboolean ack_test_part2(gpointer unused)
+{
+    /* Check result of part 1 */
+    do_test(ack_status == ACK_SUCCESS);
+
+    reset_test_state();
+    printf("Testing ack on suspend state transition\n");
+    test_data.state = POWERD_SYS_STATE_SUSPEND;
+    test_data.ack_delay = 0;
+    test_data.ack_timeout_id = g_timeout_add(5000, ack_timeout_handler, NULL);
+    clearSysState(test_data.cookie);
+    return FALSE;
+}
+
+static gboolean ack_test_check_result(gpointer unused)
+{
+    do_test(ack_status == ACK_SUCCESS);
+    run_next_test();
+    return FALSE;
+}
+
+static gboolean no_ack_test_part1(gpointer unused)
+{
+    printf("Testing active state transition with no ack\n");
+
+    reset_test_state();
+    test_data.state = POWERD_SYS_STATE_ACTIVE;
+    test_data.ack_delay = -1;
+    test_data.ack_timeout_id = g_timeout_add(5000, ack_timeout_handler, NULL);
+    requestSysState(test_data.state, &test_data.cookie);
+    return FALSE;
+}
+
+static gboolean no_ack_test_part2(gpointer unused)
+{
+    printf("Testing suspend state transition with no ack\n");
+
+    reset_test_state();
+    test_data.state = POWERD_SYS_STATE_SUSPEND;
+    test_data.ack_delay = -1;
+    test_data.ack_timeout_id = g_timeout_add(5000, ack_timeout_handler, NULL);
+    clearSysState(test_data.cookie);
+    return FALSE;
+}
+
+static gboolean bad_ack_test(gpointer unused)
+{
+    printf("Testing acknowledge of wrong state\n");
+
+    reset_test_state();
+    test_data.state = POWERD_SYS_STATE_SUSPEND;
+    test_data.ack_delay = 0;
+    test_data.ack_timeout_id = g_timeout_add(5000, ack_timeout_handler, NULL);
+    requestSysState(POWERD_SYS_STATE_ACTIVE, &test_data.cookie);
+    return FALSE;
+}
+
+static gboolean bad_ack_test_result(gpointer unused)
+{
+    do_test(ack_status == ACK_FAILURE);
+    run_next_test();
+    return FALSE;
+}
+
+static gboolean unregister_test(gpointer unused)
+{
+    gboolean result;
+
+    result = do_test(unregister_client(test_data.proxy) == TRUE);
+    if (!result)
+        g_main_loop_quit(main_loop);
+    else
+        run_next_test();
+    return FALSE;
+}
+
+static gboolean no_unregister_test(gpointer unused)
+{
+    printf("Testing exit without unregistering\n");
+    run_next_test();
+    return FALSE;
+}
+
+static GSourceFunc client_tests[] = {
+    register_test,
+    ack_test_part1,
+    ack_test_part2,
+    ack_test_check_result,
+    no_ack_test_part1,
+    no_ack_test_part2,
+    bad_ack_test,
+    bad_ack_test_result,
+    unregister_test,
+    register_test,
+    no_unregister_test,
+};
+
+static gboolean run_next_test_handler(gpointer unused)
+{
+    static int test_num = 0;
+
+    if (test_data.ack_timeout_id > 0) {
+        g_source_remove(test_data.ack_timeout_id);
+        test_data.ack_timeout_id = 0;
+    }
+
+    if (test_num >= ARRAY_SIZE(client_tests)) {
+        test_num = 0;
+        g_main_loop_quit(main_loop);
+        return FALSE;
+    }
+
+    g_timeout_add(0, client_tests[test_num], NULL);
+    test_num++;
+    return FALSE;
+}
+
+void powerd_cli_client_test(GDBusProxy *proxy)
+{
+    printf("Running client tests, cannot verify all results\n");
+
+    silent_errors = TRUE;
+    test_data.proxy = proxy;
+    main_loop = g_main_loop_new(NULL, FALSE);
+    g_signal_connect(proxy, "g-signal", G_CALLBACK(powerd_signal_handler), NULL);
+    g_timeout_add(0, run_next_test_handler, NULL);
+    g_main_loop_run(main_loop);
+    g_main_loop_unref(main_loop);
+    silent_errors = FALSE;
+}

=== modified file 'cli/powerd-cli.c'
--- cli/powerd-cli.c	2013-07-19 20:01:31 +0000
+++ cli/powerd-cli.c	2013-07-24 20:12:24 +0000
@@ -29,23 +29,13 @@
 #include <uuid/uuid.h>
 #include <powerd.h>
 
-#define do_test(test)                                               \
-    ({                                                              \
-        gboolean result;                                            \
-        printf("Test: " #test "\n");                                \
-        result = (test);                                            \
-        printf("    result: %s\n", result ? "PASSED" : "FAILED");   \
-        result;                                                     \
-    })
+#include "powerd-cli.h"
 
 #define TEST_NUM_SYS_REQUESTS 5
 #define TEST_NUM_DISP_REQUESTS (POWERD_NUM_DISPLAY_STATES * 2)
 
 /* Set to TRUE during tests to silence expected errors */
-static gboolean silent_errors = FALSE;
-
-#define cli_warn(f, a...)   do { if (!silent_errors) g_warning(f, ##a); } while (0)
-#define cli_debug(f, a...)  g_debug(f, ##a)
+gboolean silent_errors = FALSE;
 
 GDBusProxy *powerd_proxy = NULL;
 char test_dbusname[128] = "";
@@ -102,7 +92,7 @@
     }
 }
 
-static gboolean
+gboolean
 requestSysState(int state,
         powerd_cookie_t *cookie)
 {
@@ -312,7 +302,7 @@
     }
 }
 
-static gboolean
+gboolean
 clearSysState(powerd_cookie_t cookie)
 {
     GVariant *ret = NULL;
@@ -717,6 +707,7 @@
             "exit, causing the request to be dropped.\n");
     printf("clear-sys <cookie> - clear a System state request given a cookie\n");
     printf("clear-disp <cookie> - clear a Display state request given a cookie\n");
+    printf("client-test - test powerd registration / ack API\n");
     printf("display <on|dc> [bright] [proximity] [disableab]\n"\
            "\tMake a display state request with the input parameters.\n"\
            "\tThe first argument represents the state of the display:\n"\
@@ -763,7 +754,8 @@
        (strcmp(argv[1],"display")) &&
        (strcmp(argv[1],"help")) &&
        (strcmp(argv[1],"clear-disp")) &&
-       (strcmp(argv[1],"clear-sys"))) {
+       (strcmp(argv[1],"clear-sys")) &&
+       (strcmp(argv[1],"client-test"))) {
         fprintf(stderr,"Invalid option %s\n",argv[1]);
         usage(argv[0]);
         return -1;
@@ -905,5 +897,8 @@
         // Exit here without cleanup
         return 0;
     }
+    else if (!strcmp(argv[1], "client-test")) {
+        powerd_cli_client_test(powerd_proxy);
+    }
     return 0;
 }

=== added file 'cli/powerd-cli.h'
--- cli/powerd-cli.h	1970-01-01 00:00:00 +0000
+++ cli/powerd-cli.h	2013-07-24 20:12:24 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * powerd is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __POWERD_CLI_H__
+#define __POWERD_CLI_H__
+
+#include <powerd.h>
+
+#define do_test(test)                                               \
+    ({                                                              \
+        gboolean result;                                            \
+        printf("Test: " #test "\n");                                \
+        result = (test);                                            \
+        printf("    result: %s\n", result ? "PASSED" : "FAILED");   \
+        result;                                                     \
+    })
+
+extern gboolean silent_errors;
+
+#define cli_warn(f, a...)   do { if (!silent_errors) g_warning(f, ##a); } while (0)
+#define cli_debug(f, a...)  g_debug(f, ##a)
+
+gboolean requestSysState(int state, powerd_cookie_t *cookie);
+gboolean clearSysState(powerd_cookie_t cookie);
+void powerd_cli_client_test(GDBusProxy *proxy);
+
+#endif /* __POWERD_CLI_H__ */

=== modified file 'data/com.canonical.powerd.xml'
--- data/com.canonical.powerd.xml	2013-07-17 22:39:08 +0000
+++ data/com.canonical.powerd.xml	2013-07-24 20:12:24 +0000
@@ -25,6 +25,18 @@
       <arg type="u" name="flags" direction="in" />
     </method>
 
+    <method name="registerClient">
+        <arg type="s" name="name" direction="in" />
+    </method>
+
+    <method name="unregisterClient">
+        <arg type="s" name="name" direction="in" />
+    </method>
+
+    <method name="ackStateChange">
+        <arg type="i" name="state" direction="in" />
+    </method>
+
     <method name="clearDisplayState">
       <arg type="s" name="cookie" direction="in" />
     </method>

=== modified file 'src/power-request.c'
--- src/power-request.c	2013-07-19 22:55:17 +0000
+++ src/power-request.c	2013-07-24 20:12:24 +0000
@@ -36,7 +36,7 @@
 
 #include "libsuspend.h"
 
-#define NOTIFICATION_TIMEOUT_MSECS 100
+#define NOTIFICATION_TIMEOUT_MSECS 2000
 
 struct SysStateRequest {
     gchar *owner;
@@ -81,7 +81,9 @@
 #define INVALID_STATE -1
 static GQueue queued_state_changes;
 static enum SysPowerStates pending_system_state = INVALID_STATE;
+static guint state_machine_source_id;
 static gint update_pending;
+static gboolean ack_pending;
 
 static const char power_request_wakelock_name[] = "powerd_power_request";
 gint suspend_block_count;
@@ -410,14 +412,21 @@
         if (ret)
             powerd_warn("Failed to prepare for suspend: %d", ret);
     }
+    ack_pending = powerd_client_transition_start(pending_system_state);
     powerd_sys_state_signal_emit(pending_system_state);
 
-    *delay = NOTIFICATION_TIMEOUT_MSECS;
+    *delay = ack_pending ? NOTIFICATION_TIMEOUT_MSECS : 0;
     return STATE_TRANSITION_NOTIFY;
 }
 
 static enum state_transition_state process_state_notify(guint *delay)
 {
+    if (ack_pending) {
+        powerd_warn("Timeout waiting for acks on state transition");
+        ack_pending = FALSE;
+    }
+
+    powerd_client_transition_finish(pending_system_state);
     *delay = 0;
     return STATE_TRANSITION_COMPLETE;
 }
@@ -463,6 +472,7 @@
 {
     guint delay;
 
+    state_machine_source_id = 0;
     do {
         switch (cur_state_transition_state) {
         case STATE_TRANSITION_DEQUEUE:
@@ -480,9 +490,30 @@
     } while (delay == 0 &&
              cur_state_transition_state != STATE_TRANSITION_IDLE);
 
-    if (delay != 0 && cur_state_transition_state != STATE_TRANSITION_IDLE)
-        g_timeout_add(delay, delayed_state_transition_process, NULL);
-
+    if (delay != 0 && cur_state_transition_state != STATE_TRANSITION_IDLE) {
+        state_machine_source_id = g_timeout_add(delay,
+                                                delayed_state_transition_process,
+                                                NULL);
+    }
+
+}
+
+/* Must be called from main loop */
+void power_request_transition_acked(void)
+{
+    if (cur_state_transition_state != STATE_TRANSITION_NOTIFY) {
+        powerd_error("%s called while not waiting for acks", __func__);
+        return;
+    }
+
+    powerd_debug("All acks received for state transition");
+    ack_pending = FALSE;
+    if (state_machine_source_id) {
+        g_source_remove(state_machine_source_id);
+        state_machine_source_id = g_timeout_add(0,
+                                                delayed_state_transition_process,
+                                                NULL);
+    }
 }
 
 static void check_queued_state_changes(void)

=== added file 'src/powerd-client.c'
--- src/powerd-client.c	1970-01-01 00:00:00 +0000
+++ src/powerd-client.c	2013-07-24 20:12:24 +0000
@@ -0,0 +1,162 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * powerd is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <errno.h>
+#include <glib.h>
+#include "powerd-internal.h"
+#include "log.h"
+
+struct powerd_client {   
+    const char *dbus_name;
+    const char *name;
+    gboolean ack_pending;
+};
+
+static GHashTable *client_hash;
+static int acks_needed;
+static int ack_state;
+
+static void client_ack(struct powerd_client *client)
+{
+    if (!client->ack_pending)
+        return;
+    client->ack_pending = FALSE;
+
+    if (acks_needed <= 0) {
+        powerd_error("Client needs ack while total acks needed is %d",
+                     acks_needed);
+        return;
+    }
+    if (--acks_needed == 0)
+        power_request_transition_acked();
+}
+
+/* Must be called from main loop */
+int powerd_client_register(const char *dbus_name, const char *name)
+{
+    struct powerd_client *client;
+   
+    if (!dbus_name || !name)
+        return -EINVAL;
+
+    client = g_new0(struct powerd_client, 1);
+    if (!client)
+        return -ENOMEM;
+
+    client->dbus_name = g_strdup(dbus_name);
+    client->name = g_strdup(name);
+    g_hash_table_insert(client_hash, (gpointer)client->dbus_name, client);
+    powerd_dbus_name_watch_add(dbus_name);
+    return 0;
+}
+
+/* Must be called from main loop */
+void powerd_client_unregister(const char *dbus_name)
+{
+    struct powerd_client *client;
+
+    client = g_hash_table_lookup(client_hash, dbus_name);
+    if (!client)
+        return;
+
+    client_ack(client);
+    powerd_dbus_name_watch_remove(client->dbus_name);
+    g_hash_table_remove(client_hash, client->dbus_name);
+}
+
+/*
+ * Must be called from main loop. Returns TRUE if caller should
+ * wait for acks.
+ */
+gboolean powerd_client_transition_start(int state)
+{
+    GHashTableIter iter;
+    gpointer key, value;
+
+    acks_needed = 0;
+    ack_state = state;
+
+    g_hash_table_iter_init(&iter, client_hash);
+    while (g_hash_table_iter_next(&iter, &key, &value)) {
+        struct powerd_client *client = value;
+        client->ack_pending = TRUE;
+        acks_needed++;
+    }
+    return acks_needed != 0;
+}
+
+/* Must be called from main loop */
+void powerd_client_transition_finish(int state)
+{
+    GHashTableIter iter;
+    gpointer key, value;
+
+    if (state != ack_state) {
+        powerd_warn("Attempt to finish client transition with wrong state");
+        return;
+    }
+
+    if (acks_needed)
+        return;
+    acks_needed = 0;
+
+    g_hash_table_iter_init(&iter, client_hash);
+    while (g_hash_table_iter_next(&iter, &key, &value)) {
+        struct powerd_client *client = value;
+        if (client->ack_pending) {
+            powerd_warn("Client %s (%s) failed to acknowledge state change",
+                        client->name, client->dbus_name);
+            client->ack_pending = FALSE;
+        }
+    }
+}
+
+/* Must be called from main loop */
+int powerd_client_ack(const char *dbus_name, int state)
+{
+    struct powerd_client *client;
+
+    if (state != ack_state)
+        return -EINVAL;
+
+    client = g_hash_table_lookup(client_hash, dbus_name);
+    if (!client)
+        return -ENODEV;
+    client_ack(client);
+    return 0;
+}
+
+static void client_hash_destroy(gpointer data)
+{
+    struct powerd_client *client = data;
+    g_free((gpointer)client->dbus_name);
+    g_free((gpointer)client->name);
+    g_free(client);
+}
+
+int powerd_client_init(void)
+{
+    client_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
+                                        client_hash_destroy);
+    return 0;
+}
+
+void powerd_client_deinit(void)
+{
+    g_hash_table_destroy(client_hash);
+}

=== modified file 'src/powerd-internal.h'
--- src/powerd-internal.h	2013-07-19 23:09:47 +0000
+++ src/powerd-internal.h	2013-07-24 20:12:24 +0000
@@ -104,6 +104,7 @@
 gboolean request_sys_state_internal(int state, uuid_t *cookie,
                                     const gchar *owner);
 gboolean clear_sys_state_internal(uuid_t cookie);
+void power_request_transition_acked(void);
 void update_system_state(void);
 void power_request_init(void);
 void power_request_deinit(void);
@@ -149,6 +150,15 @@
 int powerd_ps_init(void);
 void powerd_ps_deinit(void);
 
+/* Client functions */
+int powerd_client_register(const char *dbus_name, const char *name);
+void powerd_client_unregister(const char *dbus_name);
+gboolean powerd_client_transition_start(int state);
+void powerd_client_transition_finish(int state);
+int powerd_client_ack(const char *dbus_name, int state);
+int powerd_client_init(void);
+void powerd_client_deinit(void);
+
 /* Utility functions */
 int powerd_run_mainloop_sync(int (*func)(gpointer), gpointer data);
 guint powerd_uuid_hash(gconstpointer key);

=== modified file 'src/powerd-object.c'
--- src/powerd-object.c	2013-07-17 22:39:08 +0000
+++ src/powerd-object.c	2013-07-24 20:12:24 +0000
@@ -21,6 +21,7 @@
 #include <gio/gio.h>
 #include <string.h>
 #include <stdio.h>
+#include <errno.h>
 #include "powerd-internal.h"
 #include "powerd-dbus.h"
 #include "log.h"
@@ -86,6 +87,54 @@
     return;
 }
 
+static gboolean handle_register_client(PowerdSource *obj,
+                                       GDBusMethodInvocation *invocation,
+                                       const gchar *name)
+{
+    const char *owner;
+    int ret;
+
+    owner = g_dbus_method_invocation_get_sender(invocation);
+    ret = powerd_client_register(owner, name);
+    if (ret)
+        g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR,
+                                              G_DBUS_ERROR_FAILED,
+                                              "Could not register client");
+    else
+        g_dbus_method_invocation_return_value(invocation, NULL);
+    return TRUE;
+}
+
+static gboolean handle_unregister_client(PowerdSource *obj,
+                                         GDBusMethodInvocation *invocation,
+                                         const gchar *name)
+{
+    const char *owner = g_dbus_method_invocation_get_sender(invocation);
+    powerd_client_unregister(owner);
+    g_dbus_method_invocation_return_value(invocation, NULL);
+    return TRUE;
+}
+
+static gboolean handle_ack_state_change(PowerdSource *obj,
+                                        GDBusMethodInvocation *invocation,
+                                        int state)
+{
+    const char *owner;
+    int ret;
+
+    owner = g_dbus_method_invocation_get_sender(invocation);
+    ret = powerd_client_ack(owner, state);
+    if (ret) {
+        const char *msg = (ret == -EINVAL) ? "Invalid state" :
+                                             "Client not registered";
+        g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR,
+                                              G_DBUS_ERROR_INVALID_ARGS, msg);
+    } else {
+        g_dbus_method_invocation_return_value(invocation, NULL);
+    }
+    return TRUE;
+}
+
 void
 powerd_bus_acquired_cb (GDBusConnection *connection,
                         const gchar     *name,
@@ -120,6 +169,12 @@
         G_CALLBACK(handle_update_display_request), powerd_source);
     g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-clear-display-state",
         G_CALLBACK(handle_clear_display_request), powerd_source);
+    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-register-client",
+        G_CALLBACK(handle_register_client), powerd_source);
+    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-unregister-client",
+        G_CALLBACK(handle_unregister_client), powerd_source);
+    g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-ack-state-change",
+        G_CALLBACK(handle_ack_state_change), powerd_source);
     g_signal_connect(G_OBJECT(powerd_source->priv->skel), "handle-list-display-requests",
         G_CALLBACK(handle_list_display_requests), powerd_source);
 
@@ -237,6 +292,7 @@
     powerd_warn("%s vanished from dbus, clearing associated requests", name);
     clear_sys_state_by_owner(name);
     clear_disp_state_by_owner(name);
+    powerd_client_unregister(name);
     // This can return false if the hash entry was removed because the
     // last request was dropped, in other words, this call will fail
     // if the callers cleaned-up properly, so ignore any FALSE return

=== modified file 'src/powerd.cpp'
--- src/powerd.cpp	2013-07-18 17:31:38 +0000
+++ src/powerd.cpp	2013-07-24 20:12:24 +0000
@@ -471,6 +471,7 @@
     powerd_debug("Auto-dim Timeout is %d seconds\n", dim_timeout);
 
     libsuspend_init(0);
+    powerd_client_init();
     power_request_init();
     display_request_init();
     dbus_name_watch_init();
@@ -509,5 +510,6 @@
     powerd_backlight_deinit();
     display_request_deinit();
     power_request_deinit();
+    powerd_client_deinit();
     return g_exit_code;
 }