1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
2 *
3 * Copyright (C) 2007 Novell, Inc.
4 * Copyright (C) 2008 Red Hat, Inc.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation; either version 2 of the
9 * License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include <glib.h>
25 #include <string.h>
26
27 #include "gsm-app.h"
28 #include "org.gnome.SessionManager.App.h"
29
30 #define GSM_APP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GSM_TYPE_APP, GsmAppPrivate))
31
32 /* If a component crashes twice within a minute, we count that as a fatal error */
33 #define _GSM_APP_RESPAWN_RATELIMIT_SECONDS 3
34
35 struct _GsmAppPrivate
36 {
37 char *id;
38 char *app_id;
39 int phase;
40 char *startup_id;
41 gboolean registered;
42 GTimeVal last_restart_time;
43 GDBusConnection *connection;
44 GsmExportedApp *skeleton;
45 };
46
47
48 enum {
49 EXITED,
50 DIED,
51 LAST_SIGNAL
52 };
53
54 static guint32 app_serial = 1;
55
56 static guint signals[LAST_SIGNAL] = { 0 };
57
58 enum {
59 PROP_0,
60 PROP_ID,
61 PROP_STARTUP_ID,
62 PROP_PHASE,
63 PROP_REGISTERED,
64 LAST_PROP
65 };
66
G_DEFINE_TYPE(GsmApp,gsm_app,G_TYPE_OBJECT)67 G_DEFINE_TYPE (GsmApp, gsm_app, G_TYPE_OBJECT)
68
69 GQuark
70 gsm_app_error_quark (void)
71 {
72 static GQuark ret = 0;
73 if (ret == 0) {
74 ret = g_quark_from_static_string ("gsm_app_error");
75 }
76
77 return ret;
78
79 }
80
81 static gboolean
gsm_app_get_app_id(GsmExportedApp * skeleton,GDBusMethodInvocation * invocation,GsmApp * app)82 gsm_app_get_app_id (GsmExportedApp *skeleton,
83 GDBusMethodInvocation *invocation,
84 GsmApp *app)
85 {
86 const gchar *id;
87
88 id = GSM_APP_GET_CLASS (app)->impl_get_app_id (app);
89 gsm_exported_app_complete_get_app_id (skeleton, invocation, id);
90
91 return TRUE;
92 }
93
94 static gboolean
gsm_app_get_startup_id(GsmExportedApp * skeleton,GDBusMethodInvocation * invocation,GsmApp * app)95 gsm_app_get_startup_id (GsmExportedApp *skeleton,
96 GDBusMethodInvocation *invocation,
97 GsmApp *app)
98 {
99 const gchar *id;
100
101 id = g_strdup (app->priv->startup_id);
102 gsm_exported_app_complete_get_startup_id (skeleton, invocation, id);
103
104 return TRUE;
105 }
106
107 static gboolean
gsm_app_get_phase(GsmExportedApp * skeleton,GDBusMethodInvocation * invocation,GsmApp * app)108 gsm_app_get_phase (GsmExportedApp *skeleton,
109 GDBusMethodInvocation *invocation,
110 GsmApp *app)
111 {
112 gsm_exported_app_complete_get_phase (skeleton, invocation, app->priv->phase);
113 return TRUE;
114 }
115
116 static guint32
get_next_app_serial(void)117 get_next_app_serial (void)
118 {
119 guint32 serial;
120
121 serial = app_serial++;
122
123 if ((gint32)app_serial < 0) {
124 app_serial = 1;
125 }
126
127 return serial;
128 }
129
130 static gboolean
register_app(GsmApp * app)131 register_app (GsmApp *app)
132 {
133 GError *error;
134 GsmExportedApp *skeleton;
135
136 error = NULL;
137 app->priv->connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
138 if (error != NULL) {
139 g_critical ("error getting session bus: %s", error->message);
140 g_error_free (error);
141 return FALSE;
142 }
143
144 skeleton = gsm_exported_app_skeleton_new ();
145 app->priv->skeleton = skeleton;
146 g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (skeleton),
147 app->priv->connection, app->priv->id,
148 &error);
149
150 if (error != NULL) {
151 g_critical ("error registering app on session bus: %s", error->message);
152 g_error_free (error);
153 return FALSE;
154 }
155
156 g_signal_connect (skeleton, "handle-get-app-id",
157 G_CALLBACK (gsm_app_get_app_id), app);
158 g_signal_connect (skeleton, "handle-get-phase",
159 G_CALLBACK (gsm_app_get_phase), app);
160 g_signal_connect (skeleton, "handle-get-startup-id",
161 G_CALLBACK (gsm_app_get_startup_id), app);
162
163 return TRUE;
164 }
165
166 static GObject *
gsm_app_constructor(GType type,guint n_construct_properties,GObjectConstructParam * construct_properties)167 gsm_app_constructor (GType type,
168 guint n_construct_properties,
169 GObjectConstructParam *construct_properties)
170 {
171 GsmApp *app;
172 gboolean res;
173
174 app = GSM_APP (G_OBJECT_CLASS (gsm_app_parent_class)->constructor (type,
175 n_construct_properties,
176 construct_properties));
177
178 g_free (app->priv->id);
179 app->priv->id = g_strdup_printf ("/org/gnome/SessionManager/App%u", get_next_app_serial ());
180
181 res = register_app (app);
182 if (! res) {
183 g_warning ("Unable to register app with session bus");
184 }
185
186 return G_OBJECT (app);
187 }
188
189 static void
gsm_app_init(GsmApp * app)190 gsm_app_init (GsmApp *app)
191 {
192 app->priv = GSM_APP_GET_PRIVATE (app);
193 }
194
195 static void
gsm_app_set_phase(GsmApp * app,int phase)196 gsm_app_set_phase (GsmApp *app,
197 int phase)
198 {
199 g_return_if_fail (GSM_IS_APP (app));
200
201 app->priv->phase = phase;
202 }
203
204 static void
gsm_app_set_id(GsmApp * app,const char * id)205 gsm_app_set_id (GsmApp *app,
206 const char *id)
207 {
208 g_return_if_fail (GSM_IS_APP (app));
209
210 g_free (app->priv->id);
211
212 app->priv->id = g_strdup (id);
213 g_object_notify (G_OBJECT (app), "id");
214
215 }
216 static void
gsm_app_set_startup_id(GsmApp * app,const char * startup_id)217 gsm_app_set_startup_id (GsmApp *app,
218 const char *startup_id)
219 {
220 g_return_if_fail (GSM_IS_APP (app));
221
222 g_free (app->priv->startup_id);
223
224 app->priv->startup_id = g_strdup (startup_id);
225 g_object_notify (G_OBJECT (app), "startup-id");
226
227 }
228
229 static void
gsm_app_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)230 gsm_app_set_property (GObject *object,
231 guint prop_id,
232 const GValue *value,
233 GParamSpec *pspec)
234 {
235 GsmApp *app = GSM_APP (object);
236
237 switch (prop_id) {
238 case PROP_STARTUP_ID:
239 gsm_app_set_startup_id (app, g_value_get_string (value));
240 break;
241 case PROP_ID:
242 gsm_app_set_id (app, g_value_get_string (value));
243 break;
244 case PROP_PHASE:
245 gsm_app_set_phase (app, g_value_get_int (value));
246 break;
247 case PROP_REGISTERED:
248 gsm_app_set_registered (app, g_value_get_boolean (value));
249 break;
250 default:
251 break;
252 }
253 }
254
255 static void
gsm_app_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)256 gsm_app_get_property (GObject *object,
257 guint prop_id,
258 GValue *value,
259 GParamSpec *pspec)
260 {
261 GsmApp *app = GSM_APP (object);
262
263 switch (prop_id) {
264 case PROP_STARTUP_ID:
265 g_value_set_string (value, app->priv->startup_id);
266 break;
267 case PROP_ID:
268 g_value_set_string (value, app->priv->id);
269 break;
270 case PROP_PHASE:
271 g_value_set_int (value, app->priv->phase);
272 break;
273 case PROP_REGISTERED:
274 g_value_set_boolean (value, app->priv->registered);
275 break;
276 default:
277 break;
278 }
279 }
280
281 static void
gsm_app_dispose(GObject * object)282 gsm_app_dispose (GObject *object)
283 {
284 GsmApp *app = GSM_APP (object);
285
286 g_free (app->priv->startup_id);
287 app->priv->startup_id = NULL;
288
289 g_free (app->priv->id);
290 app->priv->id = NULL;
291
292 if (app->priv->skeleton != NULL) {
293 g_dbus_interface_skeleton_unexport_from_connection (G_DBUS_INTERFACE_SKELETON (app->priv->skeleton),
294 app->priv->connection);
295 g_clear_object (&app->priv->skeleton);
296 }
297
298 g_clear_object (&app->priv->connection);
299
300 G_OBJECT_CLASS (gsm_app_parent_class)->dispose (object);
301 }
302
303 static void
gsm_app_class_init(GsmAppClass * klass)304 gsm_app_class_init (GsmAppClass *klass)
305 {
306 GObjectClass *object_class = G_OBJECT_CLASS (klass);
307
308 object_class->set_property = gsm_app_set_property;
309 object_class->get_property = gsm_app_get_property;
310 object_class->dispose = gsm_app_dispose;
311 object_class->constructor = gsm_app_constructor;
312
313 klass->impl_start = NULL;
314 klass->impl_get_app_id = NULL;
315 klass->impl_get_autorestart = NULL;
316 klass->impl_provides = NULL;
317 klass->impl_get_provides = NULL;
318 klass->impl_is_running = NULL;
319
320 g_object_class_install_property (object_class,
321 PROP_PHASE,
322 g_param_spec_int ("phase",
323 "Phase",
324 "Phase",
325 -1,
326 G_MAXINT,
327 -1,
328 G_PARAM_READWRITE));
329 g_object_class_install_property (object_class,
330 PROP_ID,
331 g_param_spec_string ("id",
332 "ID",
333 "ID",
334 NULL,
335 G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
336 g_object_class_install_property (object_class,
337 PROP_STARTUP_ID,
338 g_param_spec_string ("startup-id",
339 "startup ID",
340 "Session management startup ID",
341 NULL,
342 G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
343
344 g_object_class_install_property (object_class,
345 PROP_REGISTERED,
346 g_param_spec_boolean ("registered",
347 "Registered",
348 "Registered",
349 FALSE,
350 G_PARAM_READWRITE));
351
352 signals[EXITED] =
353 g_signal_new ("exited",
354 G_OBJECT_CLASS_TYPE (object_class),
355 G_SIGNAL_RUN_LAST,
356 G_STRUCT_OFFSET (GsmAppClass, exited),
357 NULL, NULL, NULL,
358 G_TYPE_NONE,
359 1, G_TYPE_UCHAR);
360 signals[DIED] =
361 g_signal_new ("died",
362 G_OBJECT_CLASS_TYPE (object_class),
363 G_SIGNAL_RUN_LAST,
364 G_STRUCT_OFFSET (GsmAppClass, died),
365 NULL, NULL, NULL,
366 G_TYPE_NONE,
367 1, G_TYPE_INT);
368
369 g_type_class_add_private (klass, sizeof (GsmAppPrivate));
370 }
371
372 const char *
gsm_app_peek_id(GsmApp * app)373 gsm_app_peek_id (GsmApp *app)
374 {
375 return app->priv->id;
376 }
377
378 const char *
gsm_app_peek_app_id(GsmApp * app)379 gsm_app_peek_app_id (GsmApp *app)
380 {
381 return GSM_APP_GET_CLASS (app)->impl_get_app_id (app);
382 }
383
384 const char *
gsm_app_peek_startup_id(GsmApp * app)385 gsm_app_peek_startup_id (GsmApp *app)
386 {
387 return app->priv->startup_id;
388 }
389
390 /**
391 * gsm_app_peek_phase:
392 * @app: a %GsmApp
393 *
394 * Returns @app's startup phase.
395 *
396 * Return value: @app's startup phase
397 **/
398 GsmManagerPhase
gsm_app_peek_phase(GsmApp * app)399 gsm_app_peek_phase (GsmApp *app)
400 {
401 g_return_val_if_fail (GSM_IS_APP (app), GSM_MANAGER_PHASE_APPLICATION);
402
403 return app->priv->phase;
404 }
405
406 gboolean
gsm_app_peek_is_disabled(GsmApp * app)407 gsm_app_peek_is_disabled (GsmApp *app)
408 {
409 g_return_val_if_fail (GSM_IS_APP (app), FALSE);
410
411 if (GSM_APP_GET_CLASS (app)->impl_is_disabled) {
412 return GSM_APP_GET_CLASS (app)->impl_is_disabled (app);
413 } else {
414 return FALSE;
415 }
416 }
417
418 gboolean
gsm_app_peek_is_conditionally_disabled(GsmApp * app)419 gsm_app_peek_is_conditionally_disabled (GsmApp *app)
420 {
421 g_return_val_if_fail (GSM_IS_APP (app), FALSE);
422
423 if (GSM_APP_GET_CLASS (app)->impl_is_conditionally_disabled) {
424 return GSM_APP_GET_CLASS (app)->impl_is_conditionally_disabled (app);
425 } else {
426 return FALSE;
427 }
428 }
429
430 gboolean
gsm_app_is_running(GsmApp * app)431 gsm_app_is_running (GsmApp *app)
432 {
433 g_return_val_if_fail (GSM_IS_APP (app), FALSE);
434
435 if (GSM_APP_GET_CLASS (app)->impl_is_running) {
436 return GSM_APP_GET_CLASS (app)->impl_is_running (app);
437 } else {
438 return FALSE;
439 }
440 }
441
442 gboolean
gsm_app_peek_autorestart(GsmApp * app)443 gsm_app_peek_autorestart (GsmApp *app)
444 {
445 g_return_val_if_fail (GSM_IS_APP (app), FALSE);
446
447 if (GSM_APP_GET_CLASS (app)->impl_get_autorestart) {
448 return GSM_APP_GET_CLASS (app)->impl_get_autorestart (app);
449 } else {
450 return FALSE;
451 }
452 }
453
454 gboolean
gsm_app_provides(GsmApp * app,const char * service)455 gsm_app_provides (GsmApp *app, const char *service)
456 {
457 if (GSM_APP_GET_CLASS (app)->impl_provides) {
458 return GSM_APP_GET_CLASS (app)->impl_provides (app, service);
459 } else {
460 return FALSE;
461 }
462 }
463
464 char **
gsm_app_get_provides(GsmApp * app)465 gsm_app_get_provides (GsmApp *app)
466 {
467 if (GSM_APP_GET_CLASS (app)->impl_get_provides) {
468 return GSM_APP_GET_CLASS (app)->impl_get_provides (app);
469 } else {
470 return NULL;
471 }
472 }
473
474 gboolean
gsm_app_has_autostart_condition(GsmApp * app,const char * condition)475 gsm_app_has_autostart_condition (GsmApp *app,
476 const char *condition)
477 {
478
479 if (GSM_APP_GET_CLASS (app)->impl_has_autostart_condition) {
480 return GSM_APP_GET_CLASS (app)->impl_has_autostart_condition (app, condition);
481 } else {
482 return FALSE;
483 }
484 }
485
486 gboolean
gsm_app_start(GsmApp * app,GError ** error)487 gsm_app_start (GsmApp *app,
488 GError **error)
489 {
490 g_debug ("Starting app: %s", app->priv->id);
491 return GSM_APP_GET_CLASS (app)->impl_start (app, error);
492 }
493
494 gboolean
gsm_app_restart(GsmApp * app,GError ** error)495 gsm_app_restart (GsmApp *app,
496 GError **error)
497 {
498 GTimeVal current_time;
499 g_debug ("Re-starting app: %s", app->priv->id);
500
501 g_get_current_time (¤t_time);
502 if (app->priv->last_restart_time.tv_sec > 0
503 && (current_time.tv_sec - app->priv->last_restart_time.tv_sec) < _GSM_APP_RESPAWN_RATELIMIT_SECONDS) {
504 g_warning ("App '%s' respawning too quickly", gsm_app_peek_app_id (app));
505 g_set_error (error,
506 GSM_APP_ERROR,
507 GSM_APP_ERROR_RESTART_LIMIT,
508 "Component '%s' crashing too quickly",
509 gsm_app_peek_app_id (app));
510 return FALSE;
511 }
512 app->priv->last_restart_time = current_time;
513
514 return GSM_APP_GET_CLASS (app)->impl_restart (app, error);
515 }
516
517 gboolean
gsm_app_stop(GsmApp * app,GError ** error)518 gsm_app_stop (GsmApp *app,
519 GError **error)
520 {
521 return GSM_APP_GET_CLASS (app)->impl_stop (app, error);
522 }
523
524 void
gsm_app_exited(GsmApp * app,guchar exit_code)525 gsm_app_exited (GsmApp *app,
526 guchar exit_code)
527 {
528 g_return_if_fail (GSM_IS_APP (app));
529
530 g_signal_emit (app, signals[EXITED], 0, exit_code);
531 }
532
533 void
gsm_app_died(GsmApp * app,int signal)534 gsm_app_died (GsmApp *app,
535 int signal)
536 {
537 g_return_if_fail (GSM_IS_APP (app));
538
539 g_signal_emit (app, signals[DIED], 0, signal);
540 }
541
542 gboolean
gsm_app_get_registered(GsmApp * app)543 gsm_app_get_registered (GsmApp *app)
544 {
545 g_return_val_if_fail (GSM_IS_APP (app), FALSE);
546
547 return app->priv->registered;
548 }
549
550 void
gsm_app_set_registered(GsmApp * app,gboolean registered)551 gsm_app_set_registered (GsmApp *app,
552 gboolean registered)
553 {
554 g_return_if_fail (GSM_IS_APP (app));
555
556 if (app->priv->registered != registered) {
557 app->priv->registered = registered;
558 g_object_notify (G_OBJECT (app), "registered");
559 }
560 }
561
562 gboolean
gsm_app_save_to_keyfile(GsmApp * app,GKeyFile * keyfile,GError ** error)563 gsm_app_save_to_keyfile (GsmApp *app,
564 GKeyFile *keyfile,
565 GError **error)
566 {
567 g_debug ("Saving app: %s", app->priv->id);
568 return GSM_APP_GET_CLASS (app)->impl_save_to_keyfile (app, keyfile, error);
569 }
570