daemon/app_supervisor.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009, 2010 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains implementation of app supervisor object
   9  **************************************************************************
  10  *
  11  * LADI Session Handler is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * LADI Session Handler is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  23  * or write to the Free Software Foundation, Inc.,
  24  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include "config.h"  /* Get _GNU_SOURCE defenition first to have some GNU extension available */
  28
  29 #include <sys/types.h>
  30 #include <signal.h>
  31 #include <unistd.h>
  32
  33 #include "app_supervisor.h"
  34 #include "../dbus/error.h"
  35 #include "../dbus_constants.h"
  36 #include "loader.h"
  37 #include "studio_internal.h"
  38 #include "../proxies/notify_proxy.h"
  39
  40 struct ladish_app
  41 {
  42   struct list_head siblings;
  43   uint64_t id;
  44   uuid_t uuid;
  45   char * name;
  46   char * commandline;
  47   bool terminal;
  48   uint8_t level;
  49   pid_t pid;
  50   pid_t pgrp;
  51   pid_t firstborn_pid;
  52   pid_t firstborn_pgrp;
  53   bool zombie;                  /* if true, remove when stopped */
  54   bool autorun;
  55   unsigned int state;
  56 };
  57
  58 struct ladish_app_supervisor
  59 {
  60   char * name;
  61   char * opath;
  62   char * dir;
  63   char * project_name;
  64   uint64_t version;
  65   uint64_t next_id;
  66   struct list_head applist;
  67   void * on_app_renamed_context;
  68   ladish_app_supervisor_on_app_renamed_callback on_app_renamed;
  69 };
  70
  71 bool
  72 ladish_app_supervisor_create(
  73   ladish_app_supervisor_handle * supervisor_handle_ptr,
  74   const char * opath,
  75   const char * name,
  76   void * context,
  77   ladish_app_supervisor_on_app_renamed_callback on_app_renamed)
  78 {
  79   struct ladish_app_supervisor * supervisor_ptr;
  80
  81   supervisor_ptr = malloc(sizeof(struct ladish_app_supervisor));
  82   if (supervisor_ptr == NULL)
  83   {
  84     log_error("malloc() failed to allocate struct ladish_app_supervisor");
  85     return false;
  86   }
  87
  88   supervisor_ptr->opath = strdup(opath);
  89   if (supervisor_ptr->opath == NULL)
  90   {
  91     log_error("strdup() failed for app supervisor opath");
  92     free(supervisor_ptr);
  93     return false;
  94   }
  95
  96   supervisor_ptr->name = strdup(name);
  97   if (supervisor_ptr->name == NULL)
  98   {
  99     log_error("strdup() failed for app supervisor name");
 100     free(supervisor_ptr->opath);
 101     free(supervisor_ptr);
 102     return false;
 103   }
 104
 105   supervisor_ptr->dir = NULL;
 106   supervisor_ptr->project_name = NULL;
 107
 108   supervisor_ptr->version = 0;
 109   supervisor_ptr->next_id = 1;
 110
 111   INIT_LIST_HEAD(&supervisor_ptr->applist);
 112
 113   supervisor_ptr->on_app_renamed_context = context;
 114   supervisor_ptr->on_app_renamed = on_app_renamed;
 115
 116   *supervisor_handle_ptr = (ladish_app_supervisor_handle)supervisor_ptr;
 117
 118   return true;
 119 }
 120
 121 struct ladish_app * ladish_app_supervisor_find_app_by_id_internal(struct ladish_app_supervisor * supervisor_ptr, uint64_t id)
 122 {
 123   struct list_head * node_ptr;
 124   struct ladish_app * app_ptr;
 125
 126   list_for_each(node_ptr, &supervisor_ptr->applist)
 127   {
 128     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 129     if (app_ptr->id == id)
 130     {
 131       return app_ptr;
 132     }
 133   }
 134
 135   return NULL;
 136 }
 137
 138 void remove_app_internal(struct ladish_app_supervisor * supervisor_ptr, struct ladish_app * app_ptr)
 139 {
 140   ASSERT(app_ptr->pid == 0);    /* Removing not-stoped app? Zombies will make a rebellion! */
 141
 142   list_del(&app_ptr->siblings);
 143
 144   supervisor_ptr->version++;
 145
 146   dbus_signal_emit(
 147     g_dbus_connection,
 148     supervisor_ptr->opath,
 149     IFACE_APP_SUPERVISOR,
 150     "AppRemoved",
 151     "tt",
 152     &supervisor_ptr->version,
 153     &app_ptr->id);
 154
 155   free(app_ptr->name);
 156   free(app_ptr->commandline);
 157   free(app_ptr);
 158 }
 159
 160 void emit_app_state_changed(struct ladish_app_supervisor * supervisor_ptr, struct ladish_app * app_ptr)
 161 {
 162   dbus_bool_t running;
 163   dbus_bool_t terminal;
 164
 165   running = app_ptr->pid != 0;
 166   terminal = app_ptr->terminal;
 167
 168   supervisor_ptr->version++;
 169
 170   dbus_signal_emit(
 171     g_dbus_connection,
 172     supervisor_ptr->opath,
 173     IFACE_APP_SUPERVISOR,
 174     "AppStateChanged",
 175     "ttsbby",
 176     &supervisor_ptr->version,
 177     &app_ptr->id,
 178     &app_ptr->name,
 179     &running,
 180     &terminal,
 181     &app_ptr->level);
 182 }
 183
 184 #define supervisor_ptr ((struct ladish_app_supervisor *)supervisor_handle)
 185
 186 const char * ladish_app_supervisor_get_opath(ladish_app_supervisor_handle supervisor_handle)
 187 {
 188   return supervisor_ptr->opath;
 189 }
 190
 191 ladish_app_handle ladish_app_supervisor_find_app_by_name(ladish_app_supervisor_handle supervisor_handle, const char * name)
 192 {
 193   struct list_head * node_ptr;
 194   struct ladish_app * app_ptr;
 195
 196   list_for_each(node_ptr, &supervisor_ptr->applist)
 197   {
 198     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 199     if (strcmp(app_ptr->name, name) == 0)
 200     {
 201       return (ladish_app_handle)app_ptr;
 202     }
 203   }
 204
 205   return NULL;
 206 }
 207
 208 ladish_app_handle ladish_app_supervisor_find_app_by_id(ladish_app_supervisor_handle supervisor_handle, uint64_t id)
 209 {
 210   return (ladish_app_handle)ladish_app_supervisor_find_app_by_id_internal(supervisor_ptr, id);
 211 }
 212
 213 ladish_app_handle ladish_app_supervisor_find_app_by_pid(ladish_app_supervisor_handle supervisor_handle, pid_t pid)
 214 {
 215   struct list_head * node_ptr;
 216   struct ladish_app * app_ptr;
 217
 218   list_for_each(node_ptr, &supervisor_ptr->applist)
 219   {
 220     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 221     if (app_ptr->pid == pid)
 222     {
 223       //log_info("app \"%s\" found by pid %llu", app_ptr->name, (unsigned long long)pid);
 224       return (ladish_app_handle)app_ptr;
 225     }
 226   }
 227
 228   return NULL;
 229 }
 230
 231 ladish_app_handle ladish_app_supervisor_find_app_by_uuid(ladish_app_supervisor_handle supervisor_handle, const uuid_t uuid)
 232 {
 233   struct list_head * node_ptr;
 234   struct ladish_app * app_ptr;
 235
 236   list_for_each(node_ptr, &supervisor_ptr->applist)
 237   {
 238     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 239     if (uuid_compare(app_ptr->uuid, uuid) == 0)
 240     {
 241       return (ladish_app_handle)app_ptr;
 242     }
 243   }
 244
 245   return NULL;
 246 }
 247
 248 ladish_app_handle
 249 ladish_app_supervisor_add(
 250   ladish_app_supervisor_handle supervisor_handle,
 251   const char * name,
 252   uuid_t uuid,
 253   bool autorun,
 254   const char * command,
 255   bool terminal,
 256   uint8_t level)
 257 {
 258   struct ladish_app * app_ptr;
 259   dbus_bool_t running;
 260
 261   app_ptr = malloc(sizeof(struct ladish_app));
 262   if (app_ptr == NULL)
 263   {
 264     log_error("malloc of struct ladish_app failed");
 265     return NULL;
 266   }
 267
 268   app_ptr->name = strdup(name);
 269   if (app_ptr->name == NULL)
 270   {
 271     log_error("strdup() failed for app name");
 272     free(app_ptr);
 273     return NULL;
 274   }
 275
 276   app_ptr->commandline = strdup(command);
 277   if (app_ptr->commandline == NULL)
 278   {
 279     log_error("strdup() failed for app commandline");
 280     free(app_ptr->name);
 281     free(app_ptr);
 282     return NULL;
 283   }
 284
 285   app_ptr->terminal = terminal;
 286   app_ptr->level = level;
 287   app_ptr->pid = 0;
 288   app_ptr->pgrp = 0;
 289   app_ptr->firstborn_pid = 0;
 290   app_ptr->firstborn_pgrp = 0;
 291
 292   app_ptr->id = supervisor_ptr->next_id++;
 293   if (uuid == NULL || uuid_is_null(uuid))
 294   {
 295     uuid_generate(app_ptr->uuid);
 296   }
 297   else
 298   {
 299     uuid_copy(app_ptr->uuid, uuid);
 300   }
 301
 302   app_ptr->zombie = false;
 303   app_ptr->state = LADISH_APP_STATE_STOPPED;
 304   app_ptr->autorun = autorun;
 305   list_add_tail(&app_ptr->siblings, &supervisor_ptr->applist);
 306
 307   supervisor_ptr->version++;
 308
 309   running = false;
 310   dbus_signal_emit(
 311     g_dbus_connection,
 312     supervisor_ptr->opath,
 313     IFACE_APP_SUPERVISOR,
 314     "AppAdded",
 315     "ttsbby",
 316     &supervisor_ptr->version,
 317     &app_ptr->id,
 318     &app_ptr->name,
 319     &running,
 320     &terminal,
 321     &app_ptr->level);
 322
 323   return (ladish_app_handle)app_ptr;
 324 }
 325
 326 static void ladish_app_send_signal(struct ladish_app * app_ptr, int sig, bool prefer_firstborn)
 327 {
 328   pid_t pid;
 329   const char * signal_name;
 330
 331   ASSERT(app_ptr->state = LADISH_APP_STATE_STARTED);
 332
 333   switch (sig)
 334   {
 335   case SIGTERM:
 336     signal_name = "SIGTERM";
 337     break;
 338   case SIGKILL:
 339     signal_name = "SIGKILL";
 340     break;
 341   case SIGUSR1:
 342     signal_name = "SIGUSR1";
 343     break;
 344   default:
 345     signal_name = strsignal(sig);
 346     if (signal_name == NULL)
 347     {
 348       signal_name = "unknown";
 349     }
 350   }
 351
 352   switch (sig)
 353   {
 354   case SIGKILL:
 355   case SIGTERM:
 356     if (app_ptr->pgrp == 0)
 357     {
 358       app_ptr->pgrp = getpgid(app_ptr->pid);
 359       if (app_ptr->pgrp == -1)
 360       {
 361         app_ptr->pgrp = 0;
 362         if (errno != ESRCH)
 363         {
 364           log_error("getpgid(%u) failed. %s (%d)", (unsigned int)app_ptr->pid, strerror(errno), errno);
 365         }
 366       }
 367     }
 368
 369     if (app_ptr->firstborn_pid != 0)
 370     {
 371       app_ptr->firstborn_pgrp = getpgid(app_ptr->firstborn_pid);
 372       if (app_ptr->firstborn_pgrp == -1)
 373       {
 374         app_ptr->firstborn_pgrp = 0;
 375         if (errno != ESRCH)
 376         {
 377           log_error("getpgid(%u) failed (firstborn). %s (%d)", (unsigned int)app_ptr->firstborn_pid, strerror(errno), errno);
 378         }
 379       }
 380     }
 381
 382     if (app_ptr->pgrp != 0)
 383     {
 384       log_info("sending signal %d (%s) to pgrp %u ('%s')", sig, signal_name, (unsigned int)app_ptr->pgrp, app_ptr->name);
 385
 386       if (app_ptr->pgrp <= 1)
 387       {
 388         ASSERT_NO_PASS;
 389         return;
 390       }
 391
 392       killpg(app_ptr->pgrp, sig);
 393
 394       if (app_ptr->firstborn_pid != 0)
 395       {
 396         if (app_ptr->firstborn_pgrp != 0)
 397         {
 398           if (app_ptr->firstborn_pgrp <= 1)
 399           {
 400             ASSERT_NO_PASS;
 401             return;
 402           }
 403
 404           if (app_ptr->firstborn_pgrp != app_ptr->pgrp)
 405           {
 406             log_info("sending signal %d (%s) to firstborn pgrp %u ('%s')", sig, signal_name, (unsigned int)app_ptr->firstborn_pgrp, app_ptr->name);
 407
 408             killpg(app_ptr->firstborn_pgrp, sig);
 409           }
 410           return;
 411         }
 412         /* fall through to sending signal to pid */
 413       }
 414       else
 415       {
 416         return;
 417       }
 418     }
 419     /* fall through to sending signal to pid */
 420   default:
 421     if (app_ptr->pid <= 1)
 422     {
 423       ASSERT_NO_PASS;
 424       return;
 425     }
 426
 427     if (prefer_firstborn && app_ptr->firstborn_pid != 0)
 428     {
 429       pid = app_ptr->firstborn_pid;
 430     }
 431     else
 432     {
 433       pid = app_ptr->pid;
 434     }
 435
 436     if (pid <= 1)
 437     {
 438       ASSERT_NO_PASS;
 439       return;
 440     }
 441
 442     log_info("sending signal %d (%s) to '%s' with pid %u", sig, signal_name, app_ptr->name, (unsigned int)pid);
 443     kill(pid, sig);
 444   }
 445 }
 446
 447 bool ladish_app_supervisor_clear(ladish_app_supervisor_handle supervisor_handle)
 448 {
 449   struct list_head * node_ptr;
 450   struct list_head * safe_node_ptr;
 451   struct ladish_app * app_ptr;
 452   bool lifeless;
 453
 454   free(supervisor_ptr->dir);
 455   supervisor_ptr->dir = NULL;
 456
 457   free(supervisor_ptr->project_name);
 458   supervisor_ptr->project_name = NULL;
 459
 460   lifeless = true;
 461
 462   list_for_each_safe(node_ptr, safe_node_ptr, &supervisor_ptr->applist)
 463   {
 464     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 465     if (app_ptr->pid != 0)
 466     {
 467       log_info("terminating '%s'...", app_ptr->name);
 468       ladish_app_send_signal(app_ptr, SIGTERM, false);
 469       app_ptr->zombie = true;
 470       app_ptr->state = LADISH_APP_STATE_STOPPING;
 471       lifeless = false;
 472     }
 473     else
 474     {
 475       log_info("removing '%s'", app_ptr->name);
 476       remove_app_internal(supervisor_ptr, app_ptr);
 477     }
 478   }
 479
 480   return lifeless;
 481 }
 482
 483 void ladish_app_supervisor_destroy(ladish_app_supervisor_handle supervisor_handle)
 484 {
 485   ladish_app_supervisor_clear(supervisor_handle);
 486   free(supervisor_ptr->name);
 487   free(supervisor_ptr->opath);
 488   free(supervisor_ptr);
 489 }
 490
 491 bool
 492 ladish_app_supervisor_set_directory(
 493   ladish_app_supervisor_handle supervisor_handle,
 494   const char * dir)
 495 {
 496   char * dup;
 497
 498   dup = strdup(dir);
 499   if (dup == NULL)
 500   {
 501     log_error("strdup(\"%s\") failed", dir);
 502     return false;
 503   }
 504
 505   if (supervisor_ptr->dir != NULL)
 506   {
 507     free(supervisor_ptr->dir);
 508   }
 509
 510   supervisor_ptr->dir = dup;
 511
 512   return true;
 513 }
 514
 515 bool
 516 ladish_app_supervisor_set_project_name(
 517   ladish_app_supervisor_handle supervisor_handle,
 518   const char * project_name)
 519 {
 520   char * dup;
 521
 522   if (project_name != NULL)
 523   {
 524     dup = strdup(project_name);
 525     if (dup == NULL)
 526     {
 527       log_error("strdup(\"%s\") failed", project_name);
 528       return false;
 529     }
 530   }
 531   else
 532   {
 533     dup = NULL;
 534   }
 535
 536   free(supervisor_ptr->project_name);
 537   supervisor_ptr->project_name = dup;
 538
 539   return true;
 540 }
 541
 542 bool ladish_app_supervisor_child_exit(ladish_app_supervisor_handle supervisor_handle, pid_t pid)
 543 {
 544   struct list_head * node_ptr;
 545   struct ladish_app * app_ptr;
 546
 547   list_for_each(node_ptr, &supervisor_ptr->applist)
 548   {
 549     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 550     if (app_ptr->pid == pid)
 551     {
 552       log_info("exit of child '%s' detected.", app_ptr->name);
 553
 554       app_ptr->pid = 0;
 555       app_ptr->pgrp = 0;
 556       app_ptr->firstborn_pid = 0;
 557       app_ptr->firstborn_pgrp = 0;
 558       if (app_ptr->zombie)
 559       {
 560         remove_app_internal(supervisor_ptr, app_ptr);
 561       }
 562       else
 563       {
 564         if (app_ptr->state == LADISH_APP_STATE_STARTED)
 565         {
 566           ladish_notify_simple(LADISH_NOTIFY_URGENCY_HIGH, "App terminated unexpectedly", app_ptr->name);
 567         }
 568
 569         app_ptr->state = LADISH_APP_STATE_STOPPED;
 570
 571         emit_app_state_changed(supervisor_ptr, app_ptr);
 572       }
 573
 574       return true;
 575     }
 576   }
 577
 578   return false;
 579 }
 580
 581 bool
 582 ladish_app_supervisor_enum(
 583   ladish_app_supervisor_handle supervisor_handle,
 584   void * context,
 585   ladish_app_supervisor_enum_callback callback)
 586 {
 587   struct list_head * node_ptr;
 588   struct ladish_app * app_ptr;
 589
 590   list_for_each(node_ptr, &supervisor_ptr->applist)
 591   {
 592     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 593
 594     if (!callback(context, app_ptr->name, app_ptr->pid != 0, app_ptr->commandline, app_ptr->terminal, app_ptr->level, app_ptr->pid, app_ptr->uuid))
 595     {
 596       return false;
 597     }
 598   }
 599
 600   return true;
 601 }
 602
 603 static inline void ladish_app_save_L1_internal(struct ladish_app * app_ptr)
 604 {
 605   if (app_ptr->level == 1)
 606   {
 607     ladish_app_send_signal(app_ptr, SIGUSR1, true);
 608   }
 609 }
 610
 611 #define app_ptr ((struct ladish_app *)app_handle)
 612
 613 bool ladish_app_supervisor_start_app(ladish_app_supervisor_handle supervisor_handle, ladish_app_handle app_handle)
 614 {
 615   app_ptr->zombie = false;
 616
 617   ASSERT(app_ptr->pid == 0);
 618
 619   if (!loader_execute(
 620         supervisor_ptr->name,
 621         supervisor_ptr->project_name,
 622         app_ptr->name,
 623         supervisor_ptr->dir != NULL ? supervisor_ptr->dir : "/",
 624         app_ptr->terminal,
 625         app_ptr->commandline,
 626         &app_ptr->pid))
 627   {
 628     return false;
 629   }
 630
 631   ASSERT(app_ptr->pid != 0);
 632   app_ptr->state = LADISH_APP_STATE_STARTED;
 633
 634   emit_app_state_changed(supervisor_ptr, app_ptr);
 635   return true;
 636 }
 637
 638 void ladish_app_supervisor_remove_app(ladish_app_supervisor_handle supervisor_handle, ladish_app_handle app_handle)
 639 {
 640   remove_app_internal(supervisor_ptr, app_ptr);
 641 }
 642
 643 unsigned int ladish_app_get_state(ladish_app_handle app_handle)
 644 {
 645   return app_ptr->state;
 646 }
 647
 648 bool ladish_app_is_running(ladish_app_handle app_handle)
 649 {
 650   return app_ptr->pid != 0;
 651 }
 652
 653 const char * ladish_app_get_name(ladish_app_handle app_handle)
 654 {
 655   return app_ptr->name;
 656 }
 657
 658 void ladish_app_get_uuid(ladish_app_handle app_handle, uuid_t uuid)
 659 {
 660   uuid_copy(uuid, app_ptr->uuid);
 661 }
 662
 663 void ladish_app_stop(ladish_app_handle app_handle)
 664 {
 665   ladish_app_send_signal(app_ptr, SIGTERM, false);
 666   app_ptr->state = LADISH_APP_STATE_STOPPING;
 667 }
 668
 669 void ladish_app_kill(ladish_app_handle app_handle)
 670 {
 671   ladish_app_send_signal(app_ptr, SIGKILL, false);
 672   app_ptr->state = LADISH_APP_STATE_KILL;
 673 }
 674
 675 void ladish_app_save_L1(ladish_app_handle app_handle)
 676 {
 677   ladish_app_save_L1_internal(app_ptr);
 678 }
 679
 680 void ladish_app_add_pid(ladish_app_handle app_handle, pid_t pid)
 681 {
 682   if (app_ptr->pid == 0)
 683   {
 684     log_error("Associating pid with stopped app does not make sense");
 685     ASSERT_NO_PASS;
 686     return;
 687   }
 688
 689   if (pid <= 1)                 /* catch -1, 0 and 1 */
 690   {
 691     log_error("Refusing domination by ignoring pid %d", (int)pid);
 692     ASSERT_NO_PASS;
 693     return;
 694   }
 695
 696   if (app_ptr->pid == pid)
 697   { /* The top level process that is already known */
 698     return;
 699   }
 700
 701   if (app_ptr->firstborn_pid != 0)
 702   { /* Ignore non-first children */
 703     return;
 704   }
 705
 706   log_info("First grandchild with pid %u", (unsigned int)pid);
 707   app_ptr->firstborn_pid = pid;
 708 }
 709
 710 void ladish_app_del_pid(ladish_app_handle app_handle, pid_t pid)
 711 {
 712   if (app_ptr->firstborn_pid != 0 && app_ptr->firstborn_pid == pid)
 713   {
 714     log_info("First grandchild with pid %u has gone", (unsigned int)pid);
 715     app_ptr->firstborn_pid = 0;
 716     app_ptr->firstborn_pgrp = 0;
 717   }
 718 }
 719
 720 #undef app_ptr
 721
 722 void ladish_app_supervisor_autorun(ladish_app_supervisor_handle supervisor_handle)
 723 {
 724   struct list_head * node_ptr;
 725   struct ladish_app * app_ptr;
 726
 727   list_for_each(node_ptr, &supervisor_ptr->applist)
 728   {
 729     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 730
 731     if (!app_ptr->autorun)
 732     {
 733       continue;
 734     }
 735
 736     app_ptr->autorun = false;
 737
 738     log_info("autorun('%s', %s, '%s') called", app_ptr->name, app_ptr->terminal ? "terminal" : "shell", app_ptr->commandline);
 739
 740     if (!ladish_app_supervisor_start_app((ladish_app_supervisor_handle)supervisor_ptr, (ladish_app_handle)app_ptr))
 741     {
 742       log_error("Execution of '%s' failed",  app_ptr->commandline);
 743       return;
 744     }
 745   }
 746 }
 747
 748 void ladish_app_supervisor_stop(ladish_app_supervisor_handle supervisor_handle)
 749 {
 750   struct list_head * node_ptr;
 751   struct ladish_app * app_ptr;
 752
 753   list_for_each(node_ptr, &supervisor_ptr->applist)
 754   {
 755     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 756     if (app_ptr->pid != 0)
 757     {
 758       log_info("terminating '%s'...", app_ptr->name);
 759       ladish_app_send_signal(app_ptr, SIGTERM, false);
 760       app_ptr->autorun = true;
 761       app_ptr->state = LADISH_APP_STATE_STOPPING;
 762     }
 763   }
 764 }
 765
 766 void ladish_app_supervisor_save_L1(ladish_app_supervisor_handle supervisor_handle)
 767 {
 768   struct list_head * node_ptr;
 769   struct ladish_app * app_ptr;
 770
 771   list_for_each(node_ptr, &supervisor_ptr->applist)
 772   {
 773     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 774     if (app_ptr->state != LADISH_APP_STATE_STARTED)
 775     {
 776       continue;
 777     }
 778
 779     if (app_ptr->pid == 0)
 780     {
 781       ASSERT_NO_PASS;
 782       continue;
 783     }
 784
 785     ladish_app_save_L1_internal(app_ptr);
 786   }
 787 }
 788
 789 const char * ladish_app_supervisor_get_name(ladish_app_supervisor_handle supervisor_handle)
 790 {
 791   return supervisor_ptr->name;
 792 }
 793
 794 unsigned int ladish_app_supervisor_get_running_app_count(ladish_app_supervisor_handle supervisor_handle)
 795 {
 796   struct list_head * node_ptr;
 797   struct ladish_app * app_ptr;
 798   unsigned int counter;
 799
 800   counter = 0;
 801   list_for_each(node_ptr, &supervisor_ptr->applist)
 802   {
 803     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 804     if (app_ptr->pid != 0)
 805     {
 806       counter++;
 807     }
 808   }
 809
 810   return counter;
 811 }
 812
 813 bool ladish_app_supervisor_has_apps(ladish_app_supervisor_handle supervisor_handle)
 814 {
 815   return !list_empty(&supervisor_ptr->applist);
 816 }
 817
 818 #undef supervisor_ptr
 819
 820 /**********************************************************************************/
 821 /*                                D-Bus methods                                   */
 822 /**********************************************************************************/
 823
 824 #define supervisor_ptr ((struct ladish_app_supervisor *)call_ptr->iface_context)
 825
 826 static void get_all(struct dbus_method_call * call_ptr)
 827 {
 828   DBusMessageIter iter, array_iter, struct_iter;
 829   struct list_head * node_ptr;
 830   struct ladish_app * app_ptr;
 831   dbus_bool_t running;
 832   dbus_bool_t terminal;
 833
 834   //log_info("get_all called");
 835
 836   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 837   if (call_ptr->reply == NULL)
 838   {
 839     goto fail;
 840   }
 841
 842   dbus_message_iter_init_append(call_ptr->reply, &iter);
 843
 844   if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT64, &supervisor_ptr->version))
 845   {
 846     goto fail_unref;
 847   }
 848
 849   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(tsbby)", &array_iter))
 850   {
 851     goto fail_unref;
 852   }
 853
 854   list_for_each(node_ptr, &supervisor_ptr->applist)
 855   {
 856     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 857
 858     log_info("app '%s' (%llu)", app_ptr->name, (unsigned long long)app_ptr->id);
 859
 860     if (!dbus_message_iter_open_container (&array_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter))
 861     {
 862       goto fail_unref;
 863     }
 864
 865     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_UINT64, &app_ptr->id))
 866     {
 867       goto fail_unref;
 868     }
 869
 870     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &app_ptr->name))
 871     {
 872       goto fail_unref;
 873     }
 874
 875     running = app_ptr->pid != 0;
 876     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_BOOLEAN, &running))
 877     {
 878       goto fail_unref;
 879     }
 880
 881     terminal = app_ptr->terminal;
 882     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_BOOLEAN, &terminal))
 883     {
 884       goto fail_unref;
 885     }
 886
 887     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_BYTE, &app_ptr->level))
 888     {
 889       goto fail_unref;
 890     }
 891
 892     if (!dbus_message_iter_close_container(&array_iter, &struct_iter))
 893     {
 894       goto fail_unref;
 895     }
 896   }
 897
 898   if (!dbus_message_iter_close_container(&iter, &array_iter))
 899   {
 900     goto fail_unref;
 901   }
 902
 903   return;
 904
 905 fail_unref:
 906   dbus_message_unref(call_ptr->reply);
 907   call_ptr->reply = NULL;
 908
 909 fail:
 910   log_error("Ran out of memory trying to construct method return");
 911 }
 912
 913 static void run_custom(struct dbus_method_call * call_ptr)
 914 {
 915   dbus_bool_t terminal;
 916   const char * commandline;
 917   const char * name;
 918   uint8_t level;
 919
 920   if (!dbus_message_get_args(
 921         call_ptr->message,
 922         &g_dbus_error,
 923         DBUS_TYPE_BOOLEAN, &terminal,
 924         DBUS_TYPE_STRING, &commandline,
 925         DBUS_TYPE_STRING, &name,
 926         DBUS_TYPE_BYTE, &level,
 927         DBUS_TYPE_INVALID))
 928   {
 929     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 930     dbus_error_free(&g_dbus_error);
 931     return;
 932   }
 933
 934   log_info("run_custom('%s', %s, '%s', %"PRIu8") called", name, terminal ? "terminal" : "shell", commandline, level);
 935
 936   if (level != 0 && level != 1)
 937   {
 938     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "invalid level %"PRIu8, level);
 939     return;
 940   }
 941
 942   if (ladish_command_new_app(
 943         call_ptr,
 944         ladish_studio_get_cmd_queue(),
 945         supervisor_ptr->opath,
 946         terminal,
 947         commandline,
 948         name,
 949         level))
 950   {
 951     method_return_new_void(call_ptr);
 952   }
 953 }
 954
 955 static void start_app(struct dbus_method_call * call_ptr)
 956 {
 957   uint64_t id;
 958
 959   if (!dbus_message_get_args(
 960         call_ptr->message,
 961         &g_dbus_error,
 962         DBUS_TYPE_UINT64, &id,
 963         DBUS_TYPE_INVALID))
 964   {
 965     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 966     dbus_error_free(&g_dbus_error);
 967     return;
 968   }
 969
 970   if (ladish_command_change_app_state(call_ptr, ladish_studio_get_cmd_queue(), supervisor_ptr->opath, id, LADISH_APP_STATE_STARTED))
 971   {
 972     method_return_new_void(call_ptr);
 973   }
 974 }
 975
 976 static void stop_app(struct dbus_method_call * call_ptr)
 977 {
 978   uint64_t id;
 979
 980   if (!dbus_message_get_args(
 981         call_ptr->message,
 982         &g_dbus_error,
 983         DBUS_TYPE_UINT64, &id,
 984         DBUS_TYPE_INVALID))
 985   {
 986     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 987     dbus_error_free(&g_dbus_error);
 988     return;
 989   }
 990
 991   if (ladish_command_change_app_state(call_ptr, ladish_studio_get_cmd_queue(), supervisor_ptr->opath, id, LADISH_APP_STATE_STOPPED))
 992   {
 993     method_return_new_void(call_ptr);
 994   }
 995 }
 996
 997 static void kill_app(struct dbus_method_call * call_ptr)
 998 {
 999   uint64_t id;
1000
1001   if (!dbus_message_get_args(
1002         call_ptr->message,
1003         &g_dbus_error,
1004         DBUS_TYPE_UINT64, &id,
1005         DBUS_TYPE_INVALID))
1006   {
1007     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
1008     dbus_error_free(&g_dbus_error);
1009     return;
1010   }
1011
1012   if (ladish_command_change_app_state(call_ptr, ladish_studio_get_cmd_queue(), supervisor_ptr->opath, id, LADISH_APP_STATE_KILL))
1013   {
1014     method_return_new_void(call_ptr);
1015   }
1016 }
1017
1018 static void get_app_properties(struct dbus_method_call * call_ptr)
1019 {
1020   uint64_t id;
1021   struct ladish_app * app_ptr;
1022   dbus_bool_t running;
1023   dbus_bool_t terminal;
1024
1025   if (!dbus_message_get_args(
1026         call_ptr->message,
1027         &g_dbus_error,
1028         DBUS_TYPE_UINT64, &id,
1029         DBUS_TYPE_INVALID))
1030   {
1031     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
1032     dbus_error_free(&g_dbus_error);
1033     return;
1034   }
1035
1036   app_ptr = ladish_app_supervisor_find_app_by_id_internal(supervisor_ptr, id);
1037   if (app_ptr == NULL)
1038   {
1039     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "App with ID %"PRIu64" not found", id);
1040     return;
1041   }
1042
1043   running = app_ptr->pid != 0;
1044   terminal = app_ptr->terminal;
1045
1046   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
1047   if (call_ptr->reply == NULL)
1048   {
1049     goto fail;
1050   }
1051
1052   if (!dbus_message_append_args(
1053         call_ptr->reply,
1054         DBUS_TYPE_STRING, &app_ptr->name,
1055         DBUS_TYPE_STRING, &app_ptr->commandline,
1056         DBUS_TYPE_BOOLEAN, &running,
1057         DBUS_TYPE_BOOLEAN, &terminal,
1058         DBUS_TYPE_BYTE, &app_ptr->level,
1059         DBUS_TYPE_INVALID))
1060   {
1061     goto fail_unref;
1062   }
1063
1064   return;
1065
1066 fail_unref:
1067   dbus_message_unref(call_ptr->reply);
1068   call_ptr->reply = NULL;
1069
1070 fail:
1071   log_error("Ran out of memory trying to construct method return");
1072 }
1073
1074 static void set_app_properties(struct dbus_method_call * call_ptr)
1075 {
1076   uint64_t id;
1077   dbus_bool_t terminal;
1078   const char * name;
1079   const char * commandline;
1080   uint8_t level;
1081   struct ladish_app * app_ptr;
1082   char * name_buffer;
1083   char * commandline_buffer;
1084
1085   if (!dbus_message_get_args(
1086         call_ptr->message,
1087         &g_dbus_error,
1088         DBUS_TYPE_UINT64, &id,
1089         DBUS_TYPE_STRING, &name,
1090         DBUS_TYPE_STRING, &commandline,
1091         DBUS_TYPE_BOOLEAN, &terminal,
1092         DBUS_TYPE_BYTE, &level,
1093         DBUS_TYPE_INVALID))
1094   {
1095     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
1096     dbus_error_free(&g_dbus_error);
1097     return;
1098   }
1099
1100   app_ptr = ladish_app_supervisor_find_app_by_id_internal(supervisor_ptr, id);
1101   if (app_ptr == NULL)
1102   {
1103     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "App with ID %"PRIu64" not found", id);
1104     return;
1105   }
1106
1107   if (app_ptr->pid != 0 && strcmp(commandline, app_ptr->commandline) != 0)
1108   {
1109     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "Cannot change commandline when app is running. '%s' -> '%s'", app_ptr->commandline, commandline);
1110     return;
1111   }
1112
1113   if (app_ptr->pid != 0 && ((app_ptr->terminal && !terminal) || (!app_ptr->terminal && terminal)))
1114   {
1115     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "Cannot change whether to run in terminal when app is running");
1116     return;
1117   }
1118
1119   if (app_ptr->pid != 0 && app_ptr->level != level)
1120   {
1121     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "Cannot change app level when app is running");
1122     return;
1123   }
1124
1125   if (strcmp(commandline, app_ptr->commandline) != 0)
1126   {
1127     commandline_buffer = strdup(commandline);
1128     if (commandline_buffer == NULL)
1129     {
1130       lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "strdup() failed for app commandline");
1131       return;
1132     }
1133   }
1134   else
1135   {
1136     commandline_buffer = NULL;
1137   }
1138
1139   if (strcmp(name, app_ptr->name) != 0)
1140   {
1141     name_buffer = strdup(name);
1142     if (name_buffer == NULL)
1143     {
1144       lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "strdup() failed for app nam");
1145       if (commandline_buffer != NULL)
1146       {
1147         free(commandline_buffer);
1148       }
1149       return;
1150     }
1151   }
1152   else
1153   {
1154     name_buffer = NULL;
1155   }
1156
1157   if (name_buffer != NULL)
1158   {
1159     supervisor_ptr->on_app_renamed(supervisor_ptr->on_app_renamed_context, app_ptr->uuid, app_ptr->name, name_buffer);
1160     free(app_ptr->name);
1161     app_ptr->name = name_buffer;
1162   }
1163
1164   if (commandline_buffer != NULL)
1165   {
1166     free(app_ptr->commandline);
1167     app_ptr->commandline = commandline_buffer;
1168   }
1169
1170   app_ptr->level = level;
1171   app_ptr->terminal = terminal;
1172
1173   emit_app_state_changed(supervisor_ptr, app_ptr);
1174
1175   method_return_new_void(call_ptr);
1176 }
1177
1178 static void remove_app(struct dbus_method_call * call_ptr)
1179 {
1180   uint64_t id;
1181
1182   if (!dbus_message_get_args(
1183         call_ptr->message,
1184         &g_dbus_error,
1185         DBUS_TYPE_UINT64, &id,
1186         DBUS_TYPE_INVALID))
1187   {
1188     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
1189     dbus_error_free(&g_dbus_error);
1190     return;
1191   }
1192
1193   if (ladish_command_remove_app(call_ptr, ladish_studio_get_cmd_queue(), supervisor_ptr->opath, id))
1194   {
1195     method_return_new_void(call_ptr);
1196   }
1197 }
1198
1199 static void is_app_running(struct dbus_method_call * call_ptr)
1200 {
1201   uint64_t id;
1202   struct ladish_app * app_ptr;
1203   dbus_bool_t running;
1204
1205   if (!dbus_message_get_args(
1206         call_ptr->message,
1207         &g_dbus_error,
1208         DBUS_TYPE_UINT64, &id,
1209         DBUS_TYPE_INVALID))
1210   {
1211     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
1212     dbus_error_free(&g_dbus_error);
1213     return;
1214   }
1215
1216   app_ptr = ladish_app_supervisor_find_app_by_id_internal(supervisor_ptr, id);
1217   if (app_ptr == NULL)
1218   {
1219     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "App with ID %"PRIu64" not found", id);
1220     return;
1221   }
1222
1223   running = app_ptr->pid != 0;
1224
1225   method_return_new_single(call_ptr, DBUS_TYPE_BOOLEAN, &running);
1226 }
1227
1228 #undef supervisor_ptr
1229
1230 METHOD_ARGS_BEGIN(GetAll, "Get list of apps")
1231   METHOD_ARG_DESCRIBE_OUT("list_version", DBUS_TYPE_UINT64_AS_STRING, "Version of the list")
1232   METHOD_ARG_DESCRIBE_OUT("apps_list", "a(tsbby)", "List of apps")
1233 METHOD_ARGS_END
1234
1235 METHOD_ARGS_BEGIN(RunCustom, "Start application by supplying commandline")
1236   METHOD_ARG_DESCRIBE_IN("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1237   METHOD_ARG_DESCRIBE_IN("commandline", DBUS_TYPE_STRING_AS_STRING, "Commandline")
1238   METHOD_ARG_DESCRIBE_IN("name", DBUS_TYPE_STRING_AS_STRING, "Name")
1239   METHOD_ARG_DESCRIBE_IN("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1240 METHOD_ARGS_END
1241
1242 METHOD_ARGS_BEGIN(StartApp, "Start application")
1243   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1244 METHOD_ARGS_END
1245
1246 METHOD_ARGS_BEGIN(StopApp, "Stop application")
1247   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1248 METHOD_ARGS_END
1249
1250 METHOD_ARGS_BEGIN(KillApp, "Kill application")
1251   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1252 METHOD_ARGS_END
1253
1254 METHOD_ARGS_BEGIN(RemoveApp, "Remove application")
1255   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1256 METHOD_ARGS_END
1257
1258 METHOD_ARGS_BEGIN(GetAppProperties, "Get properties of an application")
1259   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1260   METHOD_ARG_DESCRIBE_OUT("name", DBUS_TYPE_STRING_AS_STRING, "")
1261   METHOD_ARG_DESCRIBE_OUT("commandline", DBUS_TYPE_STRING_AS_STRING, "Commandline")
1262   METHOD_ARG_DESCRIBE_OUT("running", DBUS_TYPE_BOOLEAN_AS_STRING, "")
1263   METHOD_ARG_DESCRIBE_OUT("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1264   METHOD_ARG_DESCRIBE_OUT("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1265 METHOD_ARGS_END
1266
1267 METHOD_ARGS_BEGIN(SetAppProperties, "Set properties of an application")
1268   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1269   METHOD_ARG_DESCRIBE_IN("name", DBUS_TYPE_STRING_AS_STRING, "")
1270   METHOD_ARG_DESCRIBE_IN("commandline", DBUS_TYPE_STRING_AS_STRING, "Commandline")
1271   METHOD_ARG_DESCRIBE_IN("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1272   METHOD_ARG_DESCRIBE_IN("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1273 METHOD_ARGS_END
1274
1275 METHOD_ARGS_BEGIN(IsAppRunning, "Check whether application is running")
1276   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1277   METHOD_ARG_DESCRIBE_OUT("running", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether app is running")
1278 METHOD_ARGS_END
1279
1280
1281 METHODS_BEGIN
1282   METHOD_DESCRIBE(GetAll, get_all)                      /* sync */
1283   METHOD_DESCRIBE(RunCustom, run_custom)                /* async */
1284   METHOD_DESCRIBE(StartApp, start_app)                  /* async */
1285   METHOD_DESCRIBE(StopApp, stop_app)                    /* async */
1286   METHOD_DESCRIBE(KillApp, kill_app)                    /* async */
1287   METHOD_DESCRIBE(GetAppProperties, get_app_properties) /* sync */
1288   METHOD_DESCRIBE(SetAppProperties, set_app_properties) /* sync */
1289   METHOD_DESCRIBE(RemoveApp, remove_app)                /* sync */
1290   METHOD_DESCRIBE(IsAppRunning, is_app_running)         /* sync */
1291 METHODS_END
1292
1293 SIGNAL_ARGS_BEGIN(AppAdded, "")
1294   SIGNAL_ARG_DESCRIBE("new_list_version", DBUS_TYPE_UINT64_AS_STRING, "")
1295   SIGNAL_ARG_DESCRIBE("id", DBUS_TYPE_UINT64_AS_STRING, "")
1296   SIGNAL_ARG_DESCRIBE("name", DBUS_TYPE_STRING_AS_STRING, "")
1297   SIGNAL_ARG_DESCRIBE("running", DBUS_TYPE_BOOLEAN_AS_STRING, "")
1298   SIGNAL_ARG_DESCRIBE("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1299   SIGNAL_ARG_DESCRIBE("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1300 SIGNAL_ARGS_END
1301
1302 SIGNAL_ARGS_BEGIN(AppRemoved, "")
1303   SIGNAL_ARG_DESCRIBE("new_list_version", DBUS_TYPE_UINT64_AS_STRING, "")
1304   SIGNAL_ARG_DESCRIBE("id", DBUS_TYPE_UINT64_AS_STRING, "")
1305 SIGNAL_ARGS_END
1306
1307 SIGNAL_ARGS_BEGIN(AppStateChanged, "")
1308   SIGNAL_ARG_DESCRIBE("new_list_version", DBUS_TYPE_UINT64_AS_STRING, "")
1309   SIGNAL_ARG_DESCRIBE("id", DBUS_TYPE_UINT64_AS_STRING, "")
1310   SIGNAL_ARG_DESCRIBE("name", DBUS_TYPE_STRING_AS_STRING, "")
1311   SIGNAL_ARG_DESCRIBE("running", DBUS_TYPE_BOOLEAN_AS_STRING, "")
1312   SIGNAL_ARG_DESCRIBE("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1313   SIGNAL_ARG_DESCRIBE("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1314 SIGNAL_ARGS_END
1315
1316 SIGNALS_BEGIN
1317   SIGNAL_DESCRIBE(AppAdded)
1318   SIGNAL_DESCRIBE(AppRemoved)
1319   SIGNAL_DESCRIBE(AppStateChanged)
1320 SIGNALS_END
1321
1322 INTERFACE_BEGIN(g_iface_app_supervisor, IFACE_APP_SUPERVISOR)
1323   INTERFACE_DEFAULT_HANDLER
1324   INTERFACE_EXPOSE_METHODS
1325   INTERFACE_EXPOSE_SIGNALS
1326 INTERFACE_END