tests/activationd_acceptance_checker.c
activationd_acceptance_checker_CFLAGS = $(AM_CFLAGS)
-activationd_acceptance_checker_LDFLAGS = $(VCONF_LIBS) $(LIBSYSTEMD_LIBS)
+activationd_acceptance_checker_LDFLAGS = $(VCONF_LIBS) $(LIBSYSTEMD_LIBS) $(GLIB_LIBS) $(GIO_LIBS)
bin_PROGRAMS += activationd_acceptance_service
epc_dbus_call_simple_async(SYSTEMD_SERVICE, OBJ, INTF, METHOD, CB, DATA, \
ARGS, ##__VA_ARGS__)
-int epc_acquire_systemd_bus(sd_bus **bus);
-void epc_set_systemd_private(bool);
-
#endif /* EPC_SYSTEMD_DBUS_H */
Summary: activationd test services
Group: System/Monitoring
BuildRequires: pkgconfig(vconf)
+BuildRequires: pkgconfig(glib-2.0)
Requires: event-processing-core
%description -n activationd-test-services
#include <systemd/sd-bus.h>
#include <json-c/json.h>
#include <unistd.h>
+#include <libsyscommon/dbus-system.h>
#include "log.h"
#include "service.h"
static int get_service_name(const char *dbus_path, char **service_name)
{
- _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
- _cleanup_free_ char *name = NULL;
- int ret;
+ GVariant *reply = dbus_handle_method_sync_with_reply_var("org.freedesktop.systemd1",
+ dbus_path,
+ "org.freedesktop.DBus.Properties",
+ "Get",
+ g_variant_new("ss", "org.freedesktop.systemd1.Unit", "Id"));
- ret = epc_acquire_systemd_bus(&bus);
- if (ret < 0) {
- log_error_errno(ret, "Failed to acquire the default system bus connection: %m.");
- return ret;
- }
- ret = sd_bus_get_property_string(bus,
- "org.freedesktop.systemd1",
- dbus_path,
- "org.freedesktop.systemd1.Unit",
- "Id",
- &error,
- &name);
- if (ret < 0) {
- log_error("Failed to get \"Id\" property of %s: %s",
- dbus_path, error.message);
- return ret;
+ if (!reply) {
+ log_error("Failed to get \"Id\" property of %s", dbus_path);
+ return -ENOMEM;
}
- log_debug("Service Id: %s", name);
+ g_variant_get(reply, "(s)", service_name);
+ g_variant_unref(reply);
- *service_name = strdup(name);
if (*service_name == NULL) {
log_error("Unable to allocate string");
return -ENOMEM;
int systemd_get_unit_by_pid(pid_t pid, const char **name)
{
- _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
- _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
- const char *unit;
- int rc;
+ GVariant *reply;
assert(name);
- rc = epc_acquire_systemd_bus(&bus);
- if (rc < 0) {
- log_error_errno(rc, "Failed to acquire the defult system bus connection: %m.");
- return rc;
- }
-
- rc = sd_bus_call_method(bus,
- SYSTEMD_SERVICE,
+ reply = dbus_handle_method_sync_with_reply_var(SYSTEMD_SERVICE,
SYSTEMD_OBJ,
SYSTEMD_MANAGER_INTERFACE,
- "GetUnitByPID", /* method */
- &error, /* place to store error */
- &m, /* place to store answer */
- "u", /* input signature */
- pid); /* input argument */
- if (rc < 0) {
- log_error("Failed to issue \"GetUnitByPID\" method call: %s.", error.message);
- return rc;
- }
+ "GetUnitByPID",
+ g_variant_new("u", pid));
- rc = sd_bus_message_read(m, "o", &unit);
- if (rc < 0) {
- log_error_errno(rc, "Failed to parse response message: %m.");
- return rc;
+ if (!reply) {
+ log_error("Failed to issue \"GetUnitByPID\" method call.");
+ return -1;
}
- *name = strdup(unit);
+ g_variant_get(reply, "(o)", name);
+ g_variant_unref(reply);
+
+ if (*name == NULL) {
+ log_error("Unable to allocate string");
+ return -ENOMEM;
+ }
return 0;
}
#include <json-c/json.h>
#include <stdio.h>
#include <poll.h>
-#include <systemd/sd-bus.h>
#include <systemd/sd-event.h>
#include <signal.h>
#include <syslog.h>
#include <unistd.h>
+#include <libsyscommon/dbus-system.h>
#include "log.h"
#include "module.h"
switch (running_mode) {
case EPC_MODE_NORMAL:
printf(" -d, --disable-module <module> Disable <module>\n"
- " --systemd-private Use private connection to systemd\n"
" --no-action Do not execute any action\n");
break;
enum {
ARG_LOG_LEVEL = 0x100,
ARG_NO_ACTION,
- ARG_PRIVATE,
};
static const struct option options[] = {
{"log-level", required_argument, NULL, ARG_LOG_LEVEL},
{"disable-module", required_argument, NULL, 'd'},
- {"systemd-private", no_argument, NULL, ARG_PRIVATE},
{"no-action", no_argument, NULL, ARG_NO_ACTION},
{"config-file", required_argument, NULL, 'c'},
{"help", no_argument, NULL, 'h'},
epc_disable_module_category(EPC_MODULE_TYPE_ACTION);
break;
- case ARG_PRIVATE:
- epc_set_systemd_private(true);
- break;
default:
print_help(av[0]);
int main(int ac, char *av[])
{
int rc;
- sd_bus *bus = NULL;
sd_event *loop;
sigset_t ss;
struct epc_config *modules_config = NULL;
return -1;
}
- rc = epc_acquire_systemd_bus(&bus);
- if (rc < 0) {
- log_error_errno(rc, "Failed to acquire the default system bus connection: %m");
- return -1;
- }
-
rc = sd_event_new(&loop);
if (rc < 0) {
log_error_errno(rc, "Failed to allocate the event loop.");
}
/* If there is way to register a catch-all handler */
- /* sd_bus_attach_event(bus, loop, SD_EVENT_PRIORITY_NORMAL); */
sigemptyset(&ss);
sigaddset(&ss, SIGINT);
sigaddset(&ss, SIGTERM);
epc_modules_cleanup();
epc_config_cleanup_global();
- sd_bus_close(bus);
-
rc = epc_call_at_exit();
epc_modules_unload();
if (!g_variant_is_of_type(param, STRING_VARIANT)) {
log_error("Invalid parameter type passed to %s method. "
- "Expected: (s), got: %s\n", method, g_variant_get_type_string(param));
+ "Expected: (s), got: %s - %s\n", method,
+ g_variant_get_type_string(param),
+ g_variant_print(param, TRUE));
r = -EINVAL;
goto fail;
}
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
-#include <libsyscommon/dbus-system.h>
#include "common.h"
#include "systemd_dbus.h"
#include "log.h"
-static sd_bus *systemd_bus = NULL;
-static bool epc_systemd_private = false;
int epc_dbus_call_async(char *service, char *obj, char *interface, char *method,
epc_dbus_handler_t cb,
return dbus_handle_method_sync_var(service, obj, interface, method, var);
}
-
-static int get_bus_by_address(const char *addr, sd_bus **bus)
-{
- _cleanup_(sd_bus_unrefp) sd_bus *rbus = NULL;
- int ret;
-
- ret = sd_bus_new(&rbus);
- if (ret < 0)
- return ret;
-
- ret = sd_bus_set_address(rbus, addr);
- if (ret < 0)
- return ret;
-
- ret = sd_bus_start(rbus);
- if (ret < 0)
- return ret;
-
- *bus = rbus;
- rbus = NULL;
- return 0;
-}
-
-int epc_acquire_systemd_bus(sd_bus **bus)
-{
- int ret;
-
- if (systemd_bus) {
- *bus = systemd_bus;
- sd_bus_ref(systemd_bus);
- return 0;
- }
-
- if (!epc_systemd_private) {
- ret = sd_bus_open_system(bus);
- if (ret < 0)
- return ret;
- } else {
- ret = get_bus_by_address(SYSTEMD_KERNEL_BUS, bus);
- if (ret < 0) {
- ret = get_bus_by_address(SYSTEMD_PRIVATE_BUS, bus);
- if (ret < 0)
- return ret;
- }
- }
-
- systemd_bus = *bus;
-
- return 0;
-}
-
-void epc_set_systemd_private(bool priv)
-{
- epc_systemd_private = priv;
-}
#include <stdlib.h>
#include <string.h>
#include <sys/timerfd.h>
+#include <glib.h>
+#include <glib-unix.h>
#include "common.h"
#include "systemd_dbus.h"
static void cleanup(struct test_data *data)
{
- for (int i = 0; i < data->tests_count; i++)
+ GError *err = NULL;
+
+ for (int i = 0; i < data->tests_count; i++) {
+ if (data->tests[i].subscription_id > 0)
+ g_dbus_connection_signal_unsubscribe(data->bus, data->tests[i].subscription_id);
free(data->tests[i].path);
+ }
+
+ for (int i = 0; i < 4; ++i) {
+ if (data->event_sources[i] > 0)
+ g_source_remove(data->event_sources[i]);
+ }
+
if (!data->bus)
return;
- sd_bus_flush(data->bus);
- sd_bus_unref(data->bus);
+
+ g_dbus_connection_close_sync(data->bus, NULL, &err);
+ if (err) {
+ fprintf(stderr, "error closing connection: %s\n", err->message);
+ g_error_free(err);
+ }
+ g_object_unref(data->bus); /* TODO: really necessary?? */
}
-static int signal_handler(sd_event_source *s,
- const struct signalfd_siginfo *si,
- void *userdata)
+
+static gboolean signal_handler (gpointer userdata)
{
- sd_event *loop = userdata;
- sd_event_exit(loop, EXIT_FAILURE);
- return 0;
+ struct test_data *data = (struct test_data*)userdata;
+ g_main_loop_quit(data->loop);
+ return G_SOURCE_CONTINUE;
}
-static int start(sd_event_source *s, uint64_t usec, void *userdata)
+static gboolean start(gpointer userdata)
{
struct test_data *data = (struct test_data*)userdata;
- return start_test(data);
+ start_test(data);
+ data->event_sources[2] = 0; /* reset event source as we won't use it anymore */
+ return FALSE;
}
-static int timeout_handler(sd_event_source *s, uint64_t usec, void *userdata)
+static gboolean timeout_handler(gpointer userdata)
{
struct test_data *data = (struct test_data*)userdata;
fprintf(stderr, "test timed out\n");
- sd_event_exit(data->loop, EXIT_FAILURE);
- return 0;
+ g_main_loop_quit(data->loop);
+ return G_SOURCE_CONTINUE;
}
static int call_subscribe(struct test_data *data)
{
- __attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL;
- __attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL;
- int ret;
+ GVariant *msg = NULL;
+ GError *error = NULL;
- ret = sd_bus_call_method(data->bus,
+ /* load unit/get path */
+ msg = g_dbus_connection_call_sync(data->bus,
SYSTEMD_SERVICE,
SYSTEMD_OBJ,
SYSTEMD_MANAGER_INTERFACE,
"Subscribe",
- &error,
- &reply,
- "");
-
- if (ret < 0) {
- fprintf(stderr, "Failed to issue Subscribe() call: %s\n", error.message);
- return -1;
+ NULL,
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ 10000,
+ NULL,
+ &error);
+ if (error) {
+ fprintf(stderr, "Subscribe method call error: %s\n", error->message);
+ g_error_free(error);
+ return -EINVAL;
}
+ g_variant_unref(msg);
return 0;
}
static int call_load_unit(struct test_data *data)
{
- __attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL;
- __attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL;
- int ret;
- const char *path = NULL;
- char err[512];
+ GVariant *msg = NULL;
+ GError *error = NULL;
+ gchar *path = NULL;
+ /*load unit/get path */
for (int i = 0; i < data->tests_count; i++) {
- ret = sd_bus_call_method(data->bus,
+ msg = g_dbus_connection_call_sync(data->bus,
SYSTEMD_SERVICE,
SYSTEMD_OBJ,
SYSTEMD_MANAGER_INTERFACE,
"LoadUnit",
- &error,
- &reply,
- "s",
- data->tests[i].unit);
-
- if (ret < 0) {
- fprintf(stderr, "Failed to issue LoadUnit() call: %s\n", error.message);
- return -1;
- }
-
- ret = sd_bus_message_read(reply, "o", &path);
- if (ret < 0) {
- if (strerror_r(-ret, err, sizeof err))
- fprintf(stderr, "Failed to read reply: %s\n", err);
- return -1;
+ g_variant_new("(s)", data->tests[i].unit),
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ 10000,
+ NULL,
+ &error);
+ if (error) {
+ fprintf(stderr, "Failed to issue LoadUnit() call: %s\n", error->message);
+ g_error_free(error);
+ return -EINVAL;
}
+ g_variant_get(msg, "(o)", &path);
if (!path) {
- fprintf(stderr, "could not get object path\n");
- return -1;
+ fprintf(stderr, "Failed to read LoadUnit() reply\n");
+ return -EINVAL;
}
data->tests[i].path = strdup(path);
+
+ g_free(path);
+ g_variant_unref(msg);
}
return 0;
}
struct test_data data = {
.bus = NULL,
.loop = NULL,
- .step_timer = NULL,
+ .step_timer = 0,
+ .event_sources = {0, 0, 0, 0},
.state = UNKNOWN,
.prev_state = UNKNOWN,
.current_test = 0
};
+ GError *g_err;
int test_type;
int r;
- uint64_t now;
sigset_t ss;
- char buf[512];
char err[512];
r = parse_cmdline(argc, argv, &test_type);
goto fail;
}
- r = sd_bus_open_system(&data.bus);
- if (r < 0) {
- if (strerror_r(-r, err, sizeof err))
- fprintf(stderr, "Failed to read reply: %s\n", err);
+ g_err = NULL;
+ data.bus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &g_err);
+ if (g_err) {
+ fprintf(stderr, "Failed to open bus: %s\n", g_err->message);
+ g_error_free(g_err);
goto fail;
}
goto fail;
for (int i = 0; i < data.tests_count; i++) {
- r = snprintf(buf, sizeof buf, "type='signal',interface='org.freedesktop.DBus.Properties',member='PropertiesChanged', path='%s'", data.tests[i].path);
- if (r < 0) {
- if (strerror_r(-r, err, sizeof err))
- fprintf(stderr, "Failed to create match rule: %s\n", err);
- goto fail;
- }
-
- r = sd_bus_add_match(data.bus, NULL, buf, on_properties_changed, &data);
- if (r < 0) {
- if (strerror_r(-r, err, sizeof err))
- fprintf(stderr, "Failed to add PropertiesChanged match: %s\n", err);
+ data.tests[i].subscription_id = g_dbus_connection_signal_subscribe(
+ data.bus,
+ NULL,
+ "org.freedesktop.DBus.Properties",
+ "PropertiesChanged",
+ data.tests[i].path,
+ NULL,
+ G_DBUS_SIGNAL_FLAGS_NONE,
+ on_properties_changed,
+ &data,
+ NULL
+ );
+
+ if (data.tests[i].subscription_id == 0) {
+ fprintf(stderr, "Failed to add PropertiesChanged match\n");
goto fail;
}
}
- r = sd_event_new(&data.loop);
- if (r < 0) {
- if (strerror_r(-r, err, sizeof err))
- fprintf(stderr, "Failed to create main loop: %s\n", err);
+ data.loop = g_main_loop_new (NULL, FALSE);
+ if (!data.loop) {
+ fprintf(stderr, "Failed to create main loop\n");
goto fail;
}
goto fail;
}
- r = sd_event_add_signal(data.loop, NULL, SIGINT, signal_handler, data.loop);
- if (r < 0) {
- if (strerror_r(-r, err, sizeof err))
- fprintf(stderr, "Failed to register SIGINT handler: %s\n", err);
+ data.event_sources[0] = g_unix_signal_add(SIGINT, signal_handler, &data);
+ if (data.event_sources[0] == 0) {
+ fprintf(stderr, "Failed to register SIGINT handler\n");
goto fail;
}
- r = sd_event_add_signal(data.loop, NULL, SIGTERM, signal_handler, data.loop);
- if (r < 0) {
- if (strerror_r(-r, err, sizeof err))
- fprintf(stderr, "Failed to register SIGTERM handler: %s\n", err);
+ data.event_sources[1] = g_unix_signal_add(SIGTERM, signal_handler, &data);
+ if (data.event_sources[1] == 0) {
+ fprintf(stderr, "Failed to register SIGTERM handler\n");
goto fail;
}
- r = sd_bus_attach_event(data.bus, data.loop, 0);
- if (r < 0) {
- if (strerror_r(-r, err, sizeof err))
- fprintf(stderr, "Failed to attach bus to event loop: %s\n", err);
- goto fail;
- }
-
- r = sd_event_add_time(data.loop, NULL, CLOCK_REALTIME, 0, 0, start, &data);
- if (r < 0) {
- if (strerror_r(-r, err, sizeof err))
- fprintf(stderr, "Failed to attach timer to event loop: %s\n", err);
+ data.event_sources[2] = g_timeout_add_seconds(1, start, &data);
+ if (data.event_sources[2] == 0) {
+ fprintf(stderr, "Failed to attach timer to event loop\n");
goto fail;
}
/* time out all tests after 30sec */
- sd_event_now(data.loop, CLOCK_REALTIME, &now);
-
- r = sd_event_add_time(data.loop, NULL, CLOCK_REALTIME, now+30000000, 0, timeout_handler, &data);
- if (r < 0) {
- if (strerror_r(-r, err, sizeof err))
- fprintf(stderr, "Failed to attach timer to event loop: %s\n", err);
+ data.event_sources[3] = g_timeout_add_seconds(30, timeout_handler, &data);
+ if (data.event_sources[3] == 0) {
+ fprintf(stderr, "Failed to attach timer to event loop\n");
goto fail;
}
- r = sd_event_loop(data.loop);
- if (r < 0) {
- if (strerror_r(-r, err, sizeof err))
- fprintf(stderr, "Failed to run main loop: %s\n", err);
- goto fail;
- }
+ g_main_loop_run(data.loop);
r = print_results(&data);
cleanup(&data);
static void stop_test_step_timeout(struct test_data *data)
{
- int enabled;
- sd_event_source_get_enabled(data->step_timer, &enabled);
-
- if (enabled != SD_EVENT_OFF)
- sd_event_source_set_enabled(data->step_timer, SD_EVENT_OFF);
+ if (data->step_timer != 0) {
+ g_source_remove(data->step_timer);
+ data->step_timer = 0;
+ }
}
-static int on_test_step_timeout(sd_event_source *s, uint64_t usec, void *userdata)
+static gboolean on_test_step_timeout(gpointer userdata)
{
struct test_data *data = (struct test_data *)userdata;
struct test_sequence *test = &data->tests[data->current_test];
-
test->result = TEST_FAIL;
next_test(data);
return 0;
static int start_test_step_timeout(struct test_data *data)
{
- int r;
- uint64_t now;
- char err[512];
-
- sd_event_now(data->loop, CLOCK_REALTIME, &now);
- r = sd_event_add_time(data->loop, &data->step_timer, CLOCK_REALTIME, now+2000000, 0, on_test_step_timeout, data);
- if (r < 0) {
- if (strerror_r(-r, err, sizeof err))
- fprintf(stderr, "Failed to attach timer to event loop: %s\n", err);
- return r;
+ data->step_timer = g_timeout_add_seconds(2, on_test_step_timeout, data);
+ if (data->step_timer == 0) {
+ fprintf(stderr, "Failed to init step timer\n");
+ return -EINVAL;
}
-
- return 0;
+ return FALSE;
}
static int check_test_result(struct test_data *data)
struct action *a = &test->actions[test->current_action];
enum unit_state exp_state = a->expected_states[a->current_state];
-
if (data->state != exp_state) {
fprintf(stderr, "test failed (%s instead of %s at step %d of action %d of test %d)\n",
from_unit_state(data->state),
/* last test */
if (data->current_test == data->tests_count) {
- sd_event_exit(data->loop, EXIT_SUCCESS);
+ g_main_loop_quit(data->loop);
return 0;
}
test = &data->tests[data->current_test];
return 0;
}
- //if (set_vconf_key(test->key, test->actions[test->current_action].action))
- // return -1;
if (!test->step || test->step(data) != 0)
return -1;
return test_step(data);
}
-
-int on_properties_changed(sd_bus_message *m, void *userdata, sd_bus_error *ret_error)
+void on_properties_changed(GDBusConnection *connection,
+ const gchar *sender_name,
+ const gchar *object_path,
+ const gchar *interface_name,
+ const gchar *signal_name,
+ GVariant *parameters,
+ gpointer user_data)
{
- int r;
- struct test_data *data = (struct test_data*)userdata;
- const char *iface;
- const char *member;
- const char *value = NULL;
- const char *contents;
-
- r = sd_bus_message_read(m, "s", &iface);
- if (r < 0) {
- fprintf(stderr, "Failed to parse PropertiesChanged\n");
- return r;
- }
-
- r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{sv}");
- if (r < 0)
- return r;
-
- while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
- char type;
-
- r = sd_bus_message_read(m, "s", &member);
- if (r < 0)
- return r;
-
- r = sd_bus_message_peek_type(m, &type, &contents);
- if (r < 0)
- return r;
-
- r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
- if (r < 0)
- return r;
-
- if (strcmp(member, "ActiveState") == 0) {
- r = sd_bus_message_read(m, "s", &value);
- if (r < 0)
- return r;
- } else {
- r = sd_bus_message_skip(m, contents);
- if (r < 0)
- return r;
+ GVariantIter iter, iter1;
+ char *value = NULL;
+ GVariant *variant;
+ GVariant *child;
+ gchar *key;
+ struct test_data *data = (struct test_data*)user_data;
+
+ g_variant_iter_init (&iter, parameters);
+
+ /* skip 's' - interface name */
+ child = g_variant_iter_next_value (&iter);
+ g_variant_unref(child);
+
+ /* next is 'a{sv}' where ActiveState is */
+ child = g_variant_iter_next_value (&iter);
+
+ g_variant_iter_init (&iter1, child);
+ while (g_variant_iter_loop (&iter1, "{sv}", &key, &variant)) {
+ if (!g_strcmp0(key, "ActiveState")) {
+ if (g_variant_is_of_type(variant, G_VARIANT_TYPE_STRING)) {
+ value = strdup(g_variant_get_string(variant, NULL));
+ break;
+ }
}
-
- r = sd_bus_message_exit_container(m);
- if (r < 0)
- return r;
-
- r = sd_bus_message_exit_container(m);
- if (r < 0)
- return r;
}
- r = sd_bus_message_exit_container(m);
- if (r < 0)
- return r;
+ g_variant_unref(child);
- if (value)
+ if (value) {
check_unit_state(data, value);
- return 0;
+ free(value);
+ }
+
}
#ifndef ACTIVATIOND_ACCEPTANCE_TESTS_H
#define ACTIVATIOND_ACCEPTANCE_TESTS_H
-#include <systemd/sd-bus.h>
+#include <gio/gio.h>
+
#include "vconf_key_changed_event.h"
struct vkc_value;
int result;
char *unit;
char *path;
+ guint subscription_id;
int (*step)(struct test_data *test);
};
struct test_data {
- sd_bus *bus;
- sd_event *loop;
- sd_event_source *step_timer;
+ GDBusConnection *bus;
+ GMainLoop *loop;
+ guint event_sources[4];
+ guint step_timer;
struct test_sequence *tests;
int tests_count;
int current_test;
};
int start_test(struct test_data *data);
-int on_properties_changed(sd_bus_message *m, void *userdata, sd_bus_error *ret_error);
+
+void on_properties_changed(GDBusConnection *connection,
+ const gchar *sender_name,
+ const gchar *object_path,
+ const gchar *interface_name,
+ const gchar *signal_name,
+ GVariant *parameters,
+ gpointer user_data);
#endif /* ACTIVATIOND_ACCEPTANCE_TESTS_H */
#define DBUS_TEST_INTERFACE "org.freedesktop.ActivationdTestInterface"
#define DBUS_TEST_PATH "/org/freedesktop/activationd/test/object"
-static int send_dbus_signal(sd_bus *bus, const char *method, int param_cnt, const struct vkc_value *params)
+static int send_dbus_signal(GDBusConnection *bus, const char *method, int param_cnt, const struct vkc_value *params)
{
- _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
- int ret;
+ GVariant *p;
+ GError *err = NULL;
+ GVariantBuilder builder;
- ret = sd_bus_message_new_signal(bus, &m, DBUS_TEST_PATH, DBUS_TEST_INTERFACE, method);
- if (ret < 0)
- goto fail;
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
for (int i = 0; i < param_cnt; i++) {
switch(params[i].type) {
case VKC_STRING:
- ret = sd_bus_message_append(m, "s", params[i].value.s);
- if (ret < 0)
- goto fail;
+ g_variant_builder_add(&builder, "s", params[i].value.s);
break;
case VKC_DOUBLE:
- ret = sd_bus_message_append(m, "d", params[i].value.d);
- if (ret < 0)
- goto fail;
+ g_variant_builder_add(&builder, "d", params[i].value.d);
break;
case VKC_INT:
- ret = sd_bus_message_append(m, "i", params[i].value.i);
- if (ret < 0)
- goto fail;
+ g_variant_builder_add(&builder, "i", params[i].value.i);
break;
case VKC_BOOL:
- ret = sd_bus_message_append(m, "b", params[i].value.b);
- if (ret < 0)
- goto fail;
+ g_variant_builder_add(&builder, "b", params[i].value.b);
break;
}
}
- sd_bus_send(bus, m, NULL);
- /* return value of sd_bus_send is useless because it will always fail on negative tests,
- * always return 0 instead */
+ p = g_variant_builder_end(&builder);
+
+ g_dbus_connection_emit_signal(bus,
+ NULL,
+ DBUS_TEST_PATH,
+ DBUS_TEST_INTERFACE,
+ method,
+ p,
+ &err);
+
+ if (err) {
+ fprintf(stderr, "Could not emit signal %s: %s\n", method, err->message);
+ g_error_free(err);
+ return -EINVAL;
+ }
return 0;
-fail:
- return ret;
}
int dbus_signal_step(struct test_data *data)
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+#include <glib.h>
#include "activationd_acceptance_tests.h"
#include "activationd_acceptance_tests_unit_control.h"
#define ACTD_DBUS_API_SERVICE_NAME "org.tizen.activationd"
#define ACTD_DBUS_API_OBJECT_PATH "/org/tizen/activationd"
-static int unit_control_call(sd_bus *bus, const char *unit, int param_cnt, const struct vkc_value *params)
+static int unit_control_call(GDBusConnection *bus, const char *unit, int param_cnt, const struct vkc_value *params)
{
assert(bus);
assert(unit);
assert(params);
- _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
int ret;
- char err[512];
+ GVariant *msg = NULL;
+ GError *error = NULL;
if (param_cnt != 1) {
fprintf(stderr, "invalid param count (%d)\n", param_cnt);
goto fail;
}
- ret = sd_bus_message_new_method_call(
- bus,
- &m,
+ msg = g_dbus_connection_call_sync(bus,
ACTD_DBUS_API_SERVICE_NAME,
ACTD_DBUS_API_OBJECT_PATH,
ACTD_DBUS_API_INTERFACE_NAME,
- params[0].value.s);
-
- if (ret < 0) {
- if (strerror_r(-ret, err, sizeof err))
- fprintf(stderr, "failed to issue dbus api method call: %s", err);
- goto fail;
+ params[0].value.s,
+ g_variant_new("(s)", unit),
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ 10000,
+ NULL,
+ &error);
+ if (error) {
+ fprintf(stderr, "Subscribe method call error: %s\n", error->message);
+ g_error_free(error);
+ return -EINVAL;
}
-
- ret = sd_bus_message_append(m, "s", unit);
- if (ret < 0) {
- fprintf(stderr, "failed to create dbus api call\n");
- goto fail;
- }
-
-
- sd_bus_call(bus, m, 0, NULL, NULL);
- /* return value of sd_bus_call is useless because it will always fail on negative tests,
- * always return 0 instead */
+ g_variant_unref(msg);
return 0;
fail:
return ret;
projects / platform / core / system / activationd.git / commitdiff