libbeagle/beagle/beagle-daemon-information-response.c

   1 /*
   2  * beagle-daemon-information-response.c
   3  *
   4  * Copyright (C) 2005 Novell, Inc.
   5  *
   6  */
   7
   8 /*
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  24  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  25  * DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #include <stdlib.h>
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 #include <sys/un.h>
  32
  33 #include "beagle-scheduler-information.h"
  34 #include "beagle-queryable-status.h"
  35 #include "beagle-daemon-information-response.h"
  36 #include "beagle-private.h"
  37
  38 typedef struct {
  39         char *version;                                  /* Version. */
  40         gboolean is_indexing;                           /* Currently indexing ? */
  41         BeagleSchedulerInformation *scheduler_information;      /* Current task information. */
  42         GSList *index_status;                           /* List of BeagleQueryableStatus. */
  43 } BeagleDaemonInformationResponsePrivate;
  44
  45 #define BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), BEAGLE_TYPE_DAEMON_INFORMATION_RESPONSE, BeagleDaemonInformationResponsePrivate))
  46
  47 static GObjectClass *parent_class = NULL;
  48
  49 G_DEFINE_TYPE (BeagleDaemonInformationResponse, beagle_daemon_information_response, BEAGLE_TYPE_RESPONSE)
  50
  51 static void
  52 beagle_daemon_information_response_finalize (GObject *obj)
  53 {
  54         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (obj);
  55
  56         g_free (priv->version);
  57
  58         if (priv->scheduler_information)
  59                 beagle_scheduler_information_unref (priv->scheduler_information);
  60
  61         if (priv->index_status) {
  62                 g_slist_foreach (priv->index_status, (GFunc) beagle_queryable_status_unref, NULL);
  63                 g_slist_free (priv->index_status);
  64         }
  65
  66         if (G_OBJECT_CLASS (parent_class)->finalize)
  67                 G_OBJECT_CLASS (parent_class)->finalize (obj);
  68 }
  69
  70 static void
  71 end_version (BeagleParserContext *ctx)
  72 {
  73         BeagleDaemonInformationResponse *response = BEAGLE_DAEMON_INFORMATION_RESPONSE (_beagle_parser_context_get_response (ctx));
  74         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
  75
  76         priv->version = _beagle_parser_context_get_text_buffer (ctx);
  77 }
  78
  79 static void
  80 end_is_indexing (BeagleParserContext *ctx)
  81 {
  82         BeagleDaemonInformationResponse *response = BEAGLE_DAEMON_INFORMATION_RESPONSE (_beagle_parser_context_get_response (ctx));
  83         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
  84         char *buf;
  85
  86         buf = _beagle_parser_context_get_text_buffer (ctx);
  87
  88         priv->is_indexing = (strcmp (buf, "true") == 0);
  89
  90         g_free (buf);
  91 }
  92
  93 static void
  94 start_scheduler_information (BeagleParserContext *ctx, const char **attrs)
  95 {
  96         BeagleDaemonInformationResponse *response = BEAGLE_DAEMON_INFORMATION_RESPONSE (_beagle_parser_context_get_response (ctx));
  97         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
  98         int i;
  99         BeagleSchedulerInformation *scheduler_information;
 100
 101         scheduler_information = _beagle_scheduler_information_new ();
 102
 103         for (i = 0; attrs[i] != NULL; i += 2) {
 104                 if (strcmp (attrs[i], "TotalTaskCount") == 0)
 105                         scheduler_information->total_task_count = (int) g_ascii_strtod (attrs[i + 1], NULL);
 106                 else if (strcmp (attrs[i], "StatusString") == 0)
 107                         scheduler_information->status_string = g_strdup (attrs[i + 1]);
 108                 else
 109                         g_warning ("unknown attribute \"%s\" with value \"%s\"", attrs[i], attrs[i + 1]);
 110         }
 111
 112         priv->scheduler_information = scheduler_information;
 113 }
 114
 115 static void
 116 end_scheduler_information (BeagleParserContext *ctx)
 117 {
 118         BeagleDaemonInformationResponse *response = BEAGLE_DAEMON_INFORMATION_RESPONSE (_beagle_parser_context_get_response (ctx));
 119         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 120 }
 121
 122 static void
 123 end_pending_task (BeagleParserContext *ctx)
 124 {
 125         BeagleDaemonInformationResponse *response = BEAGLE_DAEMON_INFORMATION_RESPONSE (_beagle_parser_context_get_response (ctx));
 126         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 127         char *buf;
 128
 129         buf = _beagle_parser_context_get_text_buffer (ctx);
 130
 131         priv->scheduler_information->pending_task = g_slist_prepend (priv->scheduler_information->pending_task, buf);
 132 }
 133
 134 static void
 135 end_pending_tasks (BeagleParserContext *ctx)
 136 {
 137         BeagleDaemonInformationResponse *response = BEAGLE_DAEMON_INFORMATION_RESPONSE (_beagle_parser_context_get_response (ctx));
 138         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 139
 140         // Fix the order of tasks
 141         priv->scheduler_information->pending_task = g_slist_reverse (priv->scheduler_information->pending_task);
 142 }
 143
 144 static void
 145 end_future_task (BeagleParserContext *ctx)
 146 {
 147         BeagleDaemonInformationResponse *response = BEAGLE_DAEMON_INFORMATION_RESPONSE (_beagle_parser_context_get_response (ctx));
 148         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 149         char *buf;
 150
 151         buf = _beagle_parser_context_get_text_buffer (ctx);
 152
 153         priv->scheduler_information->future_task = g_slist_prepend (priv->scheduler_information->future_task, buf);
 154 }
 155
 156 static void
 157 end_future_tasks (BeagleParserContext *ctx)
 158 {
 159         BeagleDaemonInformationResponse *response = BEAGLE_DAEMON_INFORMATION_RESPONSE (_beagle_parser_context_get_response (ctx));
 160         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 161
 162         // Fix the order of tasks
 163         priv->scheduler_information->future_task = g_slist_reverse (priv->scheduler_information->future_task);
 164 }
 165
 166 static void
 167 end_blocked_task (BeagleParserContext *ctx)
 168 {
 169         BeagleDaemonInformationResponse *response = BEAGLE_DAEMON_INFORMATION_RESPONSE (_beagle_parser_context_get_response (ctx));
 170         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 171         char *buf;
 172
 173         buf = _beagle_parser_context_get_text_buffer (ctx);
 174
 175         priv->scheduler_information->blocked_task = g_slist_prepend (priv->scheduler_information->blocked_task, buf);
 176 }
 177
 178 static void
 179 end_blocked_tasks (BeagleParserContext *ctx)
 180 {
 181         BeagleDaemonInformationResponse *response = BEAGLE_DAEMON_INFORMATION_RESPONSE (_beagle_parser_context_get_response (ctx));
 182         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 183
 184         // Fix the order of tasks
 185         priv->scheduler_information->blocked_task = g_slist_reverse (priv->scheduler_information->blocked_task);
 186 }
 187
 188 static void
 189 end_index_status (BeagleParserContext *ctx)
 190 {
 191         BeagleDaemonInformationResponse *response = BEAGLE_DAEMON_INFORMATION_RESPONSE (_beagle_parser_context_get_response (ctx));
 192         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 193
 194         // Reverse the list to maintain the same order as returned by the daemon
 195         priv->index_status = g_slist_reverse (priv->index_status);
 196 }
 197
 198 static void
 199 start_queryable_status (BeagleParserContext *ctx, const char **attrs)
 200 {
 201         BeagleDaemonInformationResponse *response = BEAGLE_DAEMON_INFORMATION_RESPONSE (_beagle_parser_context_get_response (ctx));
 202         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 203
 204         int i;
 205         BeagleQueryableStatus *queryable_status = _beagle_queryable_status_new ();
 206
 207         for (i = 0; attrs[i] != NULL; i += 2) {
 208                 if (strcmp (attrs[i], "Name") == 0)
 209                         queryable_status->name = g_strdup (attrs[i + 1]);
 210                 else if (strcmp (attrs[i], "ItemCount") == 0)
 211                         queryable_status->item_count = (int) g_ascii_strtod (attrs[i + 1], NULL);
 212                 else if (strcmp (attrs[i], "ProgressPercent") == 0)
 213                         queryable_status->progress_percent = (int) g_ascii_strtod (attrs[i + 1], NULL);
 214                 else if (strcmp (attrs[i], "IsIndexing") == 0)
 215                         queryable_status->is_indexing = strcmp (attrs[i + 1], "true") == 0;
 216                 else if (strcmp (attrs[i], "State") == 0) {
 217                         if (strcmp (attrs [i + 1], "NotApplicable") == 0)
 218                                 queryable_status->state = BEAGLE_QUERYABLE_STATE_NA;
 219                         else if (strcmp (attrs [i + 1], "Idle") == 0)
 220                                 queryable_status->state = BEAGLE_QUERYABLE_STATE_IDLE;
 221                         else if (strcmp (attrs [i + 1], "Crawling") == 0)
 222                                 queryable_status->state = BEAGLE_QUERYABLE_STATE_CRAWLING;
 223                         else if (strcmp (attrs [i + 1], "Indexing") == 0)
 224                                 queryable_status->state = BEAGLE_QUERYABLE_STATE_INDEXING;
 225                         else if (strcmp (attrs [i + 1], "Flushing") == 0)
 226                                 queryable_status->state = BEAGLE_QUERYABLE_STATE_FLUSHING;
 227                 } else
 228                         g_warning ("could not handle %s", attrs[i]);
 229         }
 230
 231         priv->index_status = g_slist_prepend (priv->index_status, queryable_status);
 232 }
 233
 234 enum {
 235         PARSER_STATE_DAEMON_INFORMATION_VERSION,
 236         PARSER_STATE_DAEMON_INFORMATION_IS_INDEXING,
 237         PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION,
 238         PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_PENDING_TASKS,
 239         PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_FUTURE_TASKS,
 240         PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_BLOCKED_TASKS,
 241         PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_TASK,
 242         PARSER_STATE_DAEMON_INFORMATION_INDEX_STATUS,
 243         PARSER_STATE_DAEMON_INFORMATION_QUERYABLE_STATUS,
 244 };
 245
 246 static BeagleParserHandler parser_handlers[] = {
 247         { "Version",
 248           -1,
 249           PARSER_STATE_DAEMON_INFORMATION_VERSION,
 250           NULL,
 251           end_version },
 252
 253         { "IsIndexing",
 254           -1,
 255           PARSER_STATE_DAEMON_INFORMATION_IS_INDEXING,
 256           NULL,
 257           end_is_indexing },
 258
 259         { "SchedulerInformation",
 260           -1,
 261           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION,
 262           start_scheduler_information,
 263           NULL},
 264
 265         { "PendingTasks",
 266           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION,
 267           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_PENDING_TASKS,
 268           NULL,
 269           end_pending_tasks },
 270
 271         { "PendingTask",
 272           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_PENDING_TASKS,
 273           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_TASK,
 274           NULL,
 275           end_pending_task },
 276
 277         { "FutureTasks",
 278           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION,
 279           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_FUTURE_TASKS,
 280           NULL,
 281           end_future_tasks },
 282
 283         { "FutureTask",
 284           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_FUTURE_TASKS,
 285           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_TASK,
 286           NULL,
 287           end_future_task },
 288
 289         { "BlockedTasks",
 290           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION,
 291           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_BLOCKED_TASKS,
 292           NULL,
 293           end_blocked_tasks },
 294
 295         { "BlockedTask",
 296           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_BLOCKED_TASKS,
 297           PARSER_STATE_DAEMON_INFORMATION_SCHEDULER_INFORMATION_TASK,
 298           NULL,
 299           end_blocked_task },
 300
 301         { "IndexStatus",
 302           -1,
 303           PARSER_STATE_DAEMON_INFORMATION_INDEX_STATUS,
 304           NULL,
 305           end_index_status },
 306
 307         { "QueryableStatus",
 308           PARSER_STATE_DAEMON_INFORMATION_INDEX_STATUS,
 309           PARSER_STATE_DAEMON_INFORMATION_QUERYABLE_STATUS,
 310           start_queryable_status,
 311           NULL },
 312         { 0 }
 313 };
 314
 315 static void
 316 beagle_daemon_information_response_class_init (BeagleDaemonInformationResponseClass *klass)
 317 {
 318         GObjectClass        *obj_class = G_OBJECT_CLASS (klass);
 319         BeagleResponseClass *response_class = BEAGLE_RESPONSE_CLASS (klass);
 320
 321         parent_class = g_type_class_peek_parent (klass);
 322
 323         obj_class->finalize = beagle_daemon_information_response_finalize;
 324
 325         _beagle_response_class_set_parser_handlers (response_class,
 326                                                     parser_handlers);
 327
 328         g_type_class_add_private (klass, sizeof (BeagleDaemonInformationResponsePrivate));
 329 }
 330
 331 static void
 332 beagle_daemon_information_response_init (BeagleDaemonInformationResponse *response)
 333 {
 334         BeagleDaemonInformationResponsePrivate *priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 335
 336         priv->version = NULL;
 337         priv->scheduler_information = NULL;
 338         priv->index_status = NULL;
 339         priv->is_indexing = FALSE;
 340 }
 341
 342 /**
 343  * beagle_daemon_information_response_get_version:
 344  * @response: a #BeagleDaemonInformationResponse
 345  *
 346  * Fetches the version string of the given #BeagleDaemonInformationResponse.
 347  *
 348  * Return value: the version string of the #BeagleDaemonInformationResponse.
 349  **/
 350 G_CONST_RETURN char *
 351 beagle_daemon_information_response_get_version (BeagleDaemonInformationResponse *response)
 352 {
 353         BeagleDaemonInformationResponsePrivate *priv;
 354
 355         g_return_val_if_fail (BEAGLE_IS_DAEMON_INFORMATION_RESPONSE (response), NULL);
 356
 357         priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 358         g_return_val_if_fail (priv->version, NULL);
 359
 360         return priv->version;
 361 }
 362
 363 /**
 364  * beagle_daemon_information_response_get_scheduler_information:
 365  * @response: a #BeagleDaemonInformationResponse
 366  *
 367  * Fetches the current scheduler information from the given #BeagleDaemonInformationResponse.
 368  *
 369  * Return value: the current scheduler information from the #BeagleDaemonInformationResponse.
 370  **/
 371 BeagleSchedulerInformation *
 372 beagle_daemon_information_response_get_scheduler_information (BeagleDaemonInformationResponse *response)
 373 {
 374         BeagleDaemonInformationResponsePrivate *priv;
 375
 376         g_return_val_if_fail (BEAGLE_IS_DAEMON_INFORMATION_RESPONSE (response), NULL);
 377
 378         priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 379         g_return_val_if_fail (priv->scheduler_information, NULL);
 380
 381         return priv->scheduler_information;
 382 }
 383
 384 /**
 385  * beagle_daemon_information_response_get_human_readable_status:
 386  * @response: a #BeagleDaemonInformationResponse
 387  *
 388  * Fetches the status string of the given #BeagleDaemonInformationResponse.
 389  *
 390  * Return value: the status of the #BeagleDaemonInformationResponse.
 391  **/
 392 G_CONST_RETURN char *
 393 beagle_daemon_information_response_get_human_readable_status (BeagleDaemonInformationResponse *response)
 394 {
 395         BeagleDaemonInformationResponsePrivate *priv;
 396         BeagleSchedulerInformation *process_info;
 397
 398         g_return_val_if_fail (BEAGLE_IS_DAEMON_INFORMATION_RESPONSE (response), NULL);
 399
 400         priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 401         g_return_val_if_fail (priv->scheduler_information != NULL, NULL);
 402
 403         process_info = priv->scheduler_information;
 404
 405         return beagle_scheduler_information_to_human_readable_string (process_info);
 406 }
 407
 408 /**
 409  * beagle_daemon_information_response_get_index_status:
 410  * @response: a #BeagleDaemonInformationResponse
 411  *
 412  * Fetches the list of #QueryableStatus from each of the currently running backends.
 413  *
 414  * Return value: the index information of the #BeagleDaemonInformationResponse.
 415  **/
 416 GSList *
 417 beagle_daemon_information_response_get_index_status (BeagleDaemonInformationResponse *response)
 418 {
 419         BeagleDaemonInformationResponsePrivate *priv;
 420
 421         g_return_val_if_fail (BEAGLE_IS_DAEMON_INFORMATION_RESPONSE (response), NULL);
 422
 423         priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 424         g_return_val_if_fail (priv->index_status, NULL);
 425
 426         return priv->index_status;
 427 }
 428
 429 /**
 430  * beagle_daemon_information_response_get_index_information:
 431  * @response: a #BeagleDaemonInformationResponse
 432  *
 433  * Fetches a human-readable string describing the index information
 434  * of the given #BeagleDaemonInformationResponse.
 435  *
 436  * Return value: string describing the index information of the #BeagleDaemonInformationResponse.
 437  **/
 438 G_CONST_RETURN char *
 439 beagle_daemon_information_response_get_index_information (BeagleDaemonInformationResponse *response)
 440 {
 441         BeagleDaemonInformationResponsePrivate *priv;
 442         BeagleQueryableStatus *status;
 443         GString *tmp;
 444         GSList *iter;
 445
 446         g_return_val_if_fail (BEAGLE_IS_DAEMON_INFORMATION_RESPONSE (response), NULL);
 447
 448         priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 449         g_return_val_if_fail (priv->index_status != NULL, NULL);
 450
 451         tmp = g_string_new ("\n");
 452
 453         for (iter = priv->index_status; iter != NULL; iter = iter->next) {
 454                 status = iter->data;
 455                 g_string_append_printf (tmp, "Name: %s\nCount: %d\nIndexing: %s\n\n",
 456                                                 status->name,
 457                                                 status->item_count,
 458                                                 (status->is_indexing ? "Yes" : "No"));
 459         }
 460
 461         return g_string_free (tmp, FALSE);
 462 }
 463
 464 /**
 465  * beagle_daemon_information_response_is_indexing:
 466  * @response: a #BeagleDaemonInformationResponse
 467  *
 468  * Returns whether the daemon is in the process of indexing data.
 469  *
 470  * Return value: a boolean indicating whether the daemon is indexing.
 471  **/
 472 gboolean
 473 beagle_daemon_information_response_is_indexing (BeagleDaemonInformationResponse *response)
 474 {
 475         BeagleDaemonInformationResponsePrivate *priv;
 476
 477         g_return_val_if_fail (BEAGLE_IS_DAEMON_INFORMATION_RESPONSE (response), FALSE);
 478
 479         priv = BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_PRIVATE (response);
 480
 481         return priv->is_indexing;
 482 }