X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fafm-user-daemon.c;h=40b5971de07e63e1c86c9bb7c0053c9377a67a09;hb=36fad0e97eb67febcf91b55d0cc432897d477965;hp=4990ff7740e0ebafd49fab12ac88dfad4ccb3a4c;hpb=658c4a1fe18f6dee5063f899a449ea7020c99828;p=src%2Fapp-framework-main.git

diff --git a/src/afm-user-daemon.c b/src/afm-user-daemon.c
index 4990ff7..40b5971 100644
--- a/src/afm-user-daemon.c
+++ b/src/afm-user-daemon.c
@@ -19,21 +19,54 @@
 #include <unistd.h>
 #include <stdio.h>
 #include <time.h>
+#include <getopt.h>
+#include <string.h>
 
 #include <json.h>
 
 #include "verbose.h"
 #include "utils-jbus.h"
-#include "af-db.h"
-#include "af-run.h"
+#include "utils-json.h"
+#include "afm.h"
+#include "afm-db.h"
+#include "afm-launch-mode.h"
+#include "afm-run.h"
 
-static struct jbus *jbus;
-static struct af_db *afdb;
+static const char appname[] = "afm-user-daemon";
+
+static void usage()
+{
+	printf(
+		"usage: %s [-q] [-v] [-r rootdir]... [-a appdir]...\n"
+		"\n"
+		"   -a appdir    adds an application directory\n"
+		"   -r rootdir   adds a root directory of applications\n"
+		"   -d           run as a daemon\n"
+		"   -q           quiet\n"
+		"   -v           verbose\n"
+		"\n",
+		appname
+	);
+}
+
+static struct option options[] = {
+	{ "root",        required_argument, NULL, 'r' },
+	{ "application", required_argument, NULL, 'a' },
+	{ "daemon",      no_argument,       NULL, 'd' },
+	{ "quiet",       no_argument,       NULL, 'q' },
+	{ "verbose",     no_argument,       NULL, 'v' },
+	{ "help",        no_argument,       NULL, 'h' },
+	{ NULL, 0, NULL, 0 }
+};
+
+static struct jbus *jbuses[2];
+static struct afm_db *afdb;
 
 const char error_nothing[] = "[]";
 const char error_bad_request[] = "\"bad request\"";
 const char error_not_found[] = "\"not found\"";
 const char error_cant_start[] = "\"can't start\"";
+const char error_system[] = "\"system error\"";
 
 static const char *getappid(struct json_object *obj)
 {
@@ -63,86 +96,162 @@ static void reply_status(struct jreq *jreq, int status)
 
 static void on_runnables(struct jreq *jreq, struct json_object *obj)
 {
-	struct json_object *resp = af_db_application_list(afdb);
+	struct json_object *resp;
+	INFO("method runnables called");
+	resp = afm_db_application_list(afdb);
 	jbus_reply_j(jreq, resp);
-	json_object_put(obj);
+	json_object_put(resp);
 }
 
 static void on_detail(struct jreq *jreq, struct json_object *obj)
 {
-	const char *appid = getappid(obj);
-	struct json_object *resp = af_db_get_application_public(afdb, appid);
+	const char *appid;
+	struct json_object *resp;
+	appid = getappid(obj);
+	INFO("method detail called for %s", appid);
+	resp = afm_db_get_application_public(afdb, appid);
 	reply(jreq, resp, error_not_found);
-	json_object_put(obj);
+	json_object_put(resp);
 }
 
 static void on_start(struct jreq *jreq, struct json_object *obj)
 {
-	const char *appid;
-	struct json_object *appli;
+	const char *appid, *modestr;
+	char *uri;
+	struct json_object *appli, *resp;
 	int runid;
 	char runidstr[20];
-
-	appid = getappid(obj);
-	if (appid == NULL)
+	enum afm_launch_mode mode;
+
+	/* get the parameters */
+	mode = invalid_launch_mode;
+	if (j_read_string(obj, &appid)) {
+		mode = default_launch_mode;
+	} else if (j_read_string_at(obj, "id", &appid)) {
+		if (j_read_string_at(obj, "mode", &modestr)) {
+			mode = launch_mode_of_string(modestr);
+		} else {
+			mode = default_launch_mode;
+		}
+	}
+	if (!launch_mode_is_valid(mode)) {
 		jbus_reply_error_s(jreq, error_bad_request);
+		return;
+	}
+
+	/* get the application */
+	INFO("method start called for %s mode=%s", appid, name_of_launch_mode(mode));
+	appli = afm_db_get_application(afdb, appid);
+	if (appli == NULL) {
+		jbus_reply_error_s(jreq, error_not_found);
+		return;
+	}
+
+	/* launch the application */
+	uri = NULL;
+	runid = afm_run_start(appli, mode, &uri);
+	if (runid <= 0) {
+		jbus_reply_error_s(jreq, error_cant_start);
+		free(uri);
+		return;
+	}
+
+	if (uri == NULL) {
+		/* returns only the runid */
+		snprintf(runidstr, sizeof runidstr, "%d", runid);
+		runidstr[sizeof runidstr - 1] = 0;
+		jbus_reply_s(jreq, runidstr);
+		return;
+	}
+
+	/* returns the runid and its uri */
+	resp = json_object_new_object();
+	if (resp != NULL && j_add_integer(resp, "runid", runid) && j_add_string(resp, "uri", uri))
+		jbus_reply_j(jreq, resp);
 	else {
-		appli = af_db_get_application(afdb, appid);
-		if (appli == NULL)
-			jbus_reply_error_s(jreq, error_not_found);
-		else {
-			runid = af_run_start(appli);
-			if (runid <= 0)
-				jbus_reply_error_s(jreq, error_cant_start);
-			else {
-				snprintf(runidstr, sizeof runidstr, "%d", runid);
-				runidstr[sizeof runidstr - 1] = 0;
-				jbus_reply_s(jreq, runidstr);
-			}
-		}
+		afm_run_stop(runid);
+		jbus_reply_error_s(jreq, error_cant_start);
 	}
-	json_object_put(obj);
+	json_object_put(resp);
+	free(uri);
 }
 
 static void on_stop(struct jreq *jreq, struct json_object *obj)
 {
-	int runid = getrunid(obj);
-	int status = af_run_stop(runid);
+	int runid, status;
+	runid = getrunid(obj);
+	INFO("method stop called for %d", runid);
+	status = afm_run_stop(runid);
 	reply_status(jreq, status);
-	json_object_put(obj);
 }
 
 static void on_continue(struct jreq *jreq, struct json_object *obj)
 {
-	int runid = getrunid(obj);
-	int status = af_run_continue(runid);
+	int runid, status;
+	runid = getrunid(obj);
+	INFO("method continue called for %d", runid);
+	status = afm_run_continue(runid);
 	reply_status(jreq, status);
-	json_object_put(obj);
 }
 
 static void on_terminate(struct jreq *jreq, struct json_object *obj)
 {
-	int runid = getrunid(obj);
-	int status = af_run_terminate(runid);
+	int runid, status;
+	runid = getrunid(obj);
+	INFO("method terminate called for %d", runid);
+	status = afm_run_terminate(runid);
 	reply_status(jreq, status);
-	json_object_put(obj);
 }
 
 static void on_runners(struct jreq *jreq, struct json_object *obj)
 {
-	struct json_object *resp = af_run_list();
+	struct json_object *resp;
+	INFO("method runners called");
+	resp = afm_run_list();
 	jbus_reply_j(jreq, resp);
 	json_object_put(resp);
-	json_object_put(obj);
 }
 
 static void on_state(struct jreq *jreq, struct json_object *obj)
 {
-	int runid = getrunid(obj);
-	struct json_object *resp = af_run_state(runid);
+	int runid;
+	struct json_object *resp;
+	runid = getrunid(obj);
+	INFO("method state called for %d", runid);
+	resp = afm_run_state(runid);
 	reply(jreq, resp, error_not_found);
 	json_object_put(resp);
-	json_object_put(obj);
+}
+
+static void propagate(struct jreq *jreq, const char *msg, const char *method)
+{
+	char *reply;
+	INFO("method %s propagated with %s", method, msg);
+	reply = jbus_call_ss_sync(jbuses[0], method, msg);
+	if (reply) {
+		jbus_reply_s(jreq, reply);
+		free(reply);
+	}
+	else
+		jbus_reply_error_s(jreq, error_system);
+}
+
+static void on_install(struct jreq *jreq, const char *msg)
+{
+	return propagate(jreq, msg, "install");
+}
+
+static void on_uninstall(struct jreq *jreq, const char *msg)
+{
+	return propagate(jreq, msg, "uninstall");
+}
+
+static void on_signal_changed(struct json_object *obj)
+{
+	/* update the database */
+	afm_db_update_applications(afdb);
+	/* re-propagate now */
+	jbus_send_signal_j(jbuses[1], "changed", obj);
 }
 
 static int daemonize()
@@ -157,58 +266,126 @@ static int daemonize()
 
 int main(int ac, char **av)
 {
-	LOGAUTH("afm-main-daemon");
+	int i, daemon = 0;
+
+	LOGAUTH(appname);
+
+	/* first interpretation of arguments */
+	while ((i = getopt_long(ac, av, "hdqvr:a:", options, NULL)) >= 0) {
+		switch (i) {
+		case 'h':
+			usage();
+			return 0;
+		case 'q':
+			if (verbosity)
+				verbosity--;
+			break;
+		case 'v':
+			verbosity++;
+			break;
+		case 'd':
+			daemon = 1;
+			break;
+		case 'r':
+			break;
+		case 'a':
+			break;
+		case ':':
+			ERROR("missing argument value");
+			return 1;
+		default:
+			ERROR("unrecognized option");
+			return 1;
+		}
+	}
 
 	/* init random generator */
 	srandom((unsigned int)time(NULL));
 
 	/* init runners */
-	if (af_run_init()) {
-		ERROR("af_run_init failed");
+	if (afm_run_init()) {
+		ERROR("afm_run_init failed");
 		return 1;
 	}
 
 	/* init framework */
-	afdb = af_db_create();
+	afdb = afm_db_create();
 	if (!afdb) {
-		ERROR("af_create failed");
+		ERROR("afm_create failed");
 		return 1;
 	}
-	if (af_db_add_root(afdb, FWK_APP_DIR)) {
+	if (afm_db_add_root(afdb, FWK_APP_DIR)) {
 		ERROR("can't add root %s", FWK_APP_DIR);
 		return 1;
 	}
-	if (af_db_update_applications(afdb)) {
-		ERROR("af_update_applications failed");
+
+	/* second interpretation of arguments */
+	optind = 1;
+	while ((i = getopt_long(ac, av, "hdqvr:a:", options, NULL)) >= 0) {
+		switch (i) {
+		case 'r':
+			if (afm_db_add_root(afdb, optarg)) {
+				ERROR("can't add root %s", optarg);
+				return 1;
+			}
+			break;
+		case 'a':
+			if (afm_db_add_application(afdb, optarg)) {
+                                ERROR("can't add application %s", optarg);
+                                return 1;
+                        }
+			break;
+		}
+	}
+
+	/* update the database */
+	if (afm_db_update_applications(afdb)) {
+		ERROR("afm_update_applications failed");
+		return 1;
+	}
+
+	if (daemon && daemonize()) {
+		ERROR("daemonization failed");
+		return 1;
+	}
+
+	/* init observers */
+	jbuses[0] = create_jbus_system(AFM_SYSTEM_DBUS_PATH);
+	if (!jbuses[0]) {
+		ERROR("create_jbus failed for system");
+		return 1;
+	}
+	if(jbus_on_signal_j(jbuses[0], "changed", on_signal_changed)) {
+		ERROR("adding signal observer failed");
 		return 1;
 	}
 
 	/* init service	*/
-	jbus = create_jbus(1, "/org/AGL/afmMain");
-	if (!jbus) {
+	jbuses[1] = create_jbus_session(AFM_USER_DBUS_PATH);
+	if (!jbuses[1]) {
 		ERROR("create_jbus failed");
 		return 1;
 	}
-	if(jbus_add_service_j(jbus, "runnables", on_runnables)
-	|| jbus_add_service_j(jbus, "detail", on_detail)
-	|| jbus_add_service_j(jbus, "start", on_start)
-	|| jbus_add_service_j(jbus, "terminate", on_terminate)
-	|| jbus_add_service_j(jbus, "stop", on_stop)
-	|| jbus_add_service_j(jbus, "continue", on_continue)
-	|| jbus_add_service_j(jbus, "runners", on_runners)
-	|| jbus_add_service_j(jbus, "state", on_state)) {
+	if(jbus_add_service_j(jbuses[1], "runnables", on_runnables)
+	|| jbus_add_service_j(jbuses[1], "detail", on_detail)
+	|| jbus_add_service_j(jbuses[1], "start", on_start)
+	|| jbus_add_service_j(jbuses[1], "terminate", on_terminate)
+	|| jbus_add_service_j(jbuses[1], "stop", on_stop)
+	|| jbus_add_service_j(jbuses[1], "continue", on_continue)
+	|| jbus_add_service_j(jbuses[1], "runners", on_runners)
+	|| jbus_add_service_j(jbuses[1], "state", on_state)
+	|| jbus_add_service_s(jbuses[1], "install", on_install)
+	|| jbus_add_service_s(jbuses[1], "uninstall", on_uninstall)) {
 		ERROR("adding services failed");
 		return 1;
 	}
 
 	/* start and run */
-	if (jbus_start_serving(jbus)) {
-		ERROR("cant start server");
+	if (jbus_start_serving(jbuses[1])) {
+		ERROR("can't start server");
 		return 1;
 	}
-	while (!jbus_read_write_dispatch(jbus, -1));
+	while (jbus_read_write_dispatch_multiple(jbuses, 2, -1, 20) >= 0);
 	return 0;
 }
 
-
-