libgiggle/giggle-dispatcher.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2007 Imendio AB
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <config.h>
  22 #include <unistd.h>
  23
  24 #include "giggle-error.h"
  25 #include "giggle-sysdeps.h"
  26 #include "giggle-dispatcher.h"
  27
  28 #define d(x)
  29
  30 #define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GIGGLE_TYPE_DISPATCHER, GiggleDispatcherPriv))
  31
  32 typedef struct GiggleDispatcherPriv GiggleDispatcherPriv;
  33
  34 typedef struct {
  35         gchar                 *command;
  36         gchar                 *wd;
  37         GiggleExecuteCallback  callback;
  38         guint                  id;
  39         GPid                   pid;
  40         gint                   std_out;
  41         gint                   std_err;
  42         gpointer               user_data;
  43 } DispatcherJob;
  44
  45 struct GiggleDispatcherPriv {
  46         GQueue        *queue;
  47
  48         DispatcherJob *current_job;
  49         guint          current_job_wait_id;
  50
  51         guint          current_job_read_id;
  52         GIOChannel    *channel;
  53         GString       *output;
  54         gsize          length;
  55 };
  56
  57 static void     giggle_dispatcher_finalize (GObject *object);
  58
  59
  60 static void      dispatcher_queue_job        (GiggleDispatcher  *dispatcher,
  61                                               DispatcherJob     *job);
  62 static void      dispatcher_unqueue_job      (GiggleDispatcher  *dispatcher,
  63                                               guint              id);
  64 static gboolean  dispatcher_start_job        (GiggleDispatcher  *dispatcher,
  65                                               DispatcherJob     *job);
  66 static void      dispatcher_stop_current_job (GiggleDispatcher *dispatcher);
  67 static void      dispatcher_start_next_job   (GiggleDispatcher *dispatcher);
  68 static void      dispatcher_signal_job_failed (GiggleDispatcher *dispatcher,
  69                                                DispatcherJob    *job,
  70                                                GError           *error);
  71 static void      dispatcher_job_free         (DispatcherJob    *job);
  72 static gboolean  dispatcher_is_free_to_start (GiggleDispatcher *dispatcher);
  73 static gboolean  dispatcher_is_current_job   (GiggleDispatcher *dispatcher,
  74                                               guint             id);
  75
  76 static void      dispatcher_job_finished_cb  (GPid              pid,
  77                                               gint              status,
  78                                               GiggleDispatcher *dispatcher);
  79 static gboolean  dispatcher_job_read_cb      (GIOChannel       *source,
  80                                               GIOCondition      condition,
  81                                               GiggleDispatcher *dispatcher);
  82
  83
  84 G_DEFINE_TYPE (GiggleDispatcher, giggle_dispatcher, G_TYPE_OBJECT)
  85
  86 static void
  87 giggle_dispatcher_class_init (GiggleDispatcherClass *class)
  88 {
  89         GObjectClass *object_class = G_OBJECT_CLASS (class);
  90
  91         object_class->finalize = giggle_dispatcher_finalize;
  92
  93         g_type_class_add_private (object_class, sizeof (GiggleDispatcherPriv));
  94 }
  95
  96 static void
  97 giggle_dispatcher_init (GiggleDispatcher *dispatcher)
  98 {
  99         GiggleDispatcherPriv *priv;
 100
 101         priv = GET_PRIV (dispatcher);
 102
 103         priv->queue = g_queue_new ();
 104         priv->current_job = NULL;
 105         priv->current_job_wait_id = 0;
 106 }
 107
 108 static void
 109 giggle_dispatcher_finalize (GObject *object)
 110 {
 111         GiggleDispatcher     *dispatcher = GIGGLE_DISPATCHER (object);
 112         GiggleDispatcherPriv *priv = GET_PRIV (object);
 113         DispatcherJob        *job;
 114
 115         if (priv->current_job_wait_id) {
 116                 dispatcher_stop_current_job (dispatcher);
 117         }
 118
 119         while ((job = g_queue_pop_head (priv->queue))) {
 120                 dispatcher_job_free (job);
 121         }
 122         g_queue_free (priv->queue);
 123
 124         G_OBJECT_CLASS (giggle_dispatcher_parent_class)->finalize (object);
 125 }
 126
 127 static void
 128 dispatcher_queue_job (GiggleDispatcher *dispatcher, DispatcherJob *job)
 129 {
 130         GiggleDispatcherPriv *priv;
 131
 132         priv = GET_PRIV (dispatcher);
 133
 134         d(g_print ("GiggleDispatcher::queue_job\n"));
 135
 136         g_queue_push_tail (priv->queue, job);
 137 }
 138
 139 static void
 140 dispatcher_unqueue_job (GiggleDispatcher *dispatcher, guint id)
 141 {
 142         GiggleDispatcherPriv *priv;
 143         GList                *l;
 144
 145         priv = GET_PRIV (dispatcher);
 146
 147         d(g_print ("GiggleDispatcher::unqueue_job\n"));
 148
 149         for (l = priv->queue->head; l; l = l->next) {
 150                 DispatcherJob *job = (DispatcherJob *) l->data;
 151
 152                 if (job->id == id) {
 153                         g_queue_delete_link (priv->queue, l);
 154                         dispatcher_job_free (job);
 155                         break;
 156                 }
 157         }
 158 }
 159
 160 static gboolean
 161 dispatcher_start_job (GiggleDispatcher *dispatcher, DispatcherJob *job)
 162 {
 163         GiggleDispatcherPriv  *priv;
 164         gint                   argc;
 165         gchar                **argv;
 166         GError                *error = NULL;
 167
 168         priv = GET_PRIV (dispatcher);
 169
 170         g_assert (priv->current_job == NULL);
 171
 172         if (!g_shell_parse_argv (job->command, &argc, &argv, &error)) {
 173                 goto failed;
 174         }
 175
 176         if (!g_spawn_async_with_pipes (job->wd, argv,
 177                                        NULL, /* envp */
 178                                        G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
 179                                        NULL, NULL,
 180                                        &job->pid,
 181                                        NULL, &job->std_out, &job->std_err,
 182                                        &error)) {
 183                 goto failed;
 184         }
 185
 186         d(g_print ("GiggleDispatcher::run_job(job-started)\n"));
 187
 188         priv->channel = g_io_channel_unix_new (job->std_out);
 189         g_io_channel_set_encoding (priv->channel, NULL, NULL);
 190         priv->output = g_string_new ("");
 191         priv->length = 0;
 192
 193         priv->current_job = job;
 194         priv->current_job_read_id = g_io_add_watch_full (priv->channel,
 195                                                          G_PRIORITY_HIGH_IDLE,
 196                                                          G_IO_IN,
 197                                                          (GIOFunc) dispatcher_job_read_cb,
 198                                                          dispatcher, NULL);
 199         priv->current_job_wait_id = g_child_watch_add (job->pid,
 200                                                        (GChildWatchFunc) dispatcher_job_finished_cb,
 201                                                        dispatcher);
 202         g_strfreev (argv);
 203
 204         return TRUE;
 205
 206 failed:
 207         dispatcher_signal_job_failed (dispatcher, job, error);
 208         dispatcher_job_free (job);
 209         g_strfreev (argv);
 210         g_error_free (error);
 211         priv->current_job = NULL;
 212         priv->current_job_wait_id = 0;
 213
 214         return FALSE;
 215 }
 216
 217 static void
 218 dispatcher_stop_current_job (GiggleDispatcher *dispatcher)
 219 {
 220         GiggleDispatcherPriv *priv;
 221
 222         priv = GET_PRIV (dispatcher);
 223
 224         g_assert (priv->current_job_wait_id != 0);
 225         g_source_remove (priv->current_job_wait_id);
 226         priv->current_job_wait_id = 0;
 227
 228         g_source_remove (priv->current_job_read_id);
 229         priv->current_job_read_id = 0;
 230
 231         g_io_channel_unref (priv->channel);
 232         priv->channel = NULL;
 233
 234         g_string_free (priv->output, TRUE);
 235         priv->output = NULL;
 236
 237         g_assert (priv->current_job != NULL);
 238         giggle_sysdeps_kill_pid (priv->current_job->pid);
 239
 240         dispatcher_job_free (priv->current_job);
 241         priv->current_job = NULL;
 242 }
 243
 244 static void
 245 dispatcher_start_next_job (GiggleDispatcher *dispatcher)
 246 {
 247         GiggleDispatcherPriv *priv;
 248         DispatcherJob        *job;
 249
 250         priv = GET_PRIV (dispatcher);
 251
 252         while ((job = (DispatcherJob *) g_queue_pop_head (priv->queue))) {
 253                 if (dispatcher_start_job (dispatcher, job)) {
 254                         break;
 255                 }
 256         }
 257 }
 258
 259 static void
 260 dispatcher_signal_job_failed (GiggleDispatcher *dispatcher,
 261                               DispatcherJob    *job,
 262                               GError           *error)
 263 {
 264         job->callback (dispatcher, job->id, error, NULL, 0, job->user_data);
 265 }
 266
 267 static void
 268 dispatcher_job_free (DispatcherJob *job)
 269 {
 270         g_free (job->command);
 271         g_free (job->wd);
 272
 273         if (job->pid) {
 274                 g_spawn_close_pid (job->pid);
 275         }
 276
 277         if (job->std_out) {
 278                 close (job->std_out);
 279         }
 280
 281         if (job->std_err) {
 282                 close (job->std_err);
 283         }
 284
 285         g_slice_free (DispatcherJob, job);
 286 }
 287
 288 static gboolean
 289 dispatcher_is_free_to_start (GiggleDispatcher *dispatcher)
 290 {
 291         GiggleDispatcherPriv *priv;
 292
 293         priv = GET_PRIV (dispatcher);
 294
 295         if (priv->current_job) {
 296                 return FALSE;
 297         }
 298
 299         return TRUE;
 300 }
 301
 302 static gboolean
 303 dispatcher_is_current_job (GiggleDispatcher *dispatcher, guint id)
 304 {
 305         GiggleDispatcherPriv *priv;
 306
 307         priv = GET_PRIV (dispatcher);
 308
 309         if (priv->current_job && priv->current_job->id == id) {
 310                 return TRUE;
 311         }
 312
 313         return FALSE;
 314 }
 315
 316 static void
 317 dispatcher_job_finished_cb (GPid              pid,
 318                             gint              status,
 319                             GiggleDispatcher *dispatcher)
 320 {
 321         GiggleDispatcherPriv *priv;
 322         DispatcherJob        *job;
 323         gchar                *str;
 324         gsize                 len;
 325
 326         priv = GET_PRIV (dispatcher);
 327         job = priv->current_job;
 328
 329         d(g_print ("GiggleDispatcher::job_finished_cb\n"));
 330
 331         g_source_remove (priv->current_job_read_id);
 332         priv->current_job_read_id = 0;
 333
 334         g_io_channel_read_to_end (priv->channel, &str, &len, NULL);
 335
 336         if (str) {
 337                 g_string_append_len (priv->output, str, len);
 338                 g_free (str);
 339         }
 340
 341         job->callback (dispatcher, job->id, NULL,
 342                        priv->output->str, priv->length,
 343                        job->user_data);
 344
 345         dispatcher_job_free (job);
 346         g_io_channel_unref (priv->channel);
 347         g_string_free (priv->output, TRUE);
 348         priv->current_job = NULL;
 349         priv->current_job_wait_id = 0;
 350         dispatcher_start_next_job (dispatcher);
 351 }
 352
 353 static gboolean
 354 dispatcher_job_read_cb (GIOChannel       *source,
 355                         GIOCondition      condition,
 356                         GiggleDispatcher *dispatcher)
 357 {
 358         GiggleDispatcherPriv *priv;
 359         gsize                 length;
 360         gchar                *str;
 361         gint                  count = 0;
 362         GIOStatus             status;
 363         GError               *error = NULL;
 364
 365         priv = GET_PRIV (dispatcher);
 366         status = G_IO_STATUS_NORMAL;
 367
 368         while (count < 10 && status == G_IO_STATUS_NORMAL) {
 369                 status = g_io_channel_read_line (source, &str, &length, NULL, &error);
 370                 count++;
 371
 372                 if (str) {
 373                         g_string_append_len (priv->output, str, length);
 374                         priv->length += length;
 375                         g_free (str);
 376                 }
 377         }
 378
 379         if (status == G_IO_STATUS_ERROR) {
 380                 dispatcher_signal_job_failed (dispatcher, priv->current_job, error);
 381                 dispatcher_stop_current_job (dispatcher);
 382                 dispatcher_start_next_job (dispatcher);
 383
 384                 return FALSE;
 385         }
 386
 387         return TRUE;
 388 }
 389
 390 GiggleDispatcher *
 391 giggle_dispatcher_new (void)
 392 {
 393         return g_object_new (GIGGLE_TYPE_DISPATCHER, NULL);
 394 }
 395
 396 guint
 397 giggle_dispatcher_execute (GiggleDispatcher      *dispatcher,
 398                            const gchar           *wd,
 399                            const gchar           *command,
 400                            GiggleExecuteCallback  callback,
 401                            gpointer               user_data)
 402 {
 403         DispatcherJob *job;
 404         static guint   id = 0;
 405
 406         g_return_val_if_fail (GIGGLE_IS_DISPATCHER (dispatcher), 0);
 407         g_return_val_if_fail (command != NULL, 0);
 408         g_return_val_if_fail (callback != NULL, 0);
 409
 410         job = g_slice_new0 (DispatcherJob);
 411
 412         job->command = g_strdup (command);
 413         job->callback = callback;
 414         job->user_data = user_data;
 415
 416         job->id = ++id;
 417         job->pid = 0;
 418         job->std_out = 0;
 419         job->std_err = 0;
 420
 421         if (wd) {
 422                 job->wd = g_strdup (wd);
 423         } else {
 424                 job->wd = NULL;
 425         }
 426
 427         if (dispatcher_is_free_to_start (dispatcher)) {
 428                 dispatcher_start_job (dispatcher, job);
 429         } else {
 430                 dispatcher_queue_job (dispatcher, job);
 431         }
 432
 433         return job->id;
 434 }
 435
 436 void
 437 giggle_dispatcher_cancel (GiggleDispatcher *dispatcher, guint id)
 438 {
 439         g_return_if_fail (GIGGLE_IS_DISPATCHER (dispatcher));
 440         g_return_if_fail (id > 0);
 441
 442         if (dispatcher_is_current_job (dispatcher, id)) {
 443                 dispatcher_stop_current_job (dispatcher);
 444                 dispatcher_start_next_job (dispatcher);
 445         } else {
 446                 dispatcher_unqueue_job (dispatcher, id);
 447         }
 448 }
 449