irreco/src/core/irreco_backend_manager.c

   1 /*
   2  * irreco - Ir Remote Control
   3  * Copyright (C) 2007  Arto Karppinen (arto.karppinen@iki.fi)
   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
   7  * as published by the Free Software Foundation; either version 2
   8  * of the 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
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #include "irreco_backend_manager.h"
  21 #include "irreco_config.h"
  22
  23 /**
  24  * @addtogroup IrrecoBackendManager
  25  * @ingroup Irreco
  26  *
  27  * Maintains tables of backend libraries and backend instances.
  28  *
  29  * @{
  30  */
  31
  32 /**
  33  * @file
  34  * Source file of @ref IrrecoBackendManager.
  35  */
  36
  37
  38 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  39 /* Prototypes                                                                 */
  40 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  41
  42 void
  43 irreco_backend_manager_open_lib_dir_foreach(IrrecoDirForeachData * dir_data);
  44
  45
  46
  47 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  48 /* Construction & Destruction.                                                */
  49 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  50
  51 /**
  52  * @name Construction & Destruction
  53  * @{
  54  */
  55
  56
  57 IrrecoBackendManager* irreco_backend_manager_create(IrrecoData *irreco_data)
  58 {
  59         IrrecoBackendManager* manager;
  60         IRRECO_ENTER
  61
  62         manager = g_slice_new0(IrrecoBackendManager);
  63         manager->irreco_data = irreco_data;
  64         manager->lib_table = irreco_string_table_new(
  65                 G_DESTROYNOTIFY(irreco_backend_lib_close), NULL);
  66         manager->instance_table = irreco_string_table_new(
  67                 G_DESTROYNOTIFY(irreco_backend_instance_destroy),
  68                 IRRECO_KEY_SET_NOTIFY(irreco_backend_instance_set_name));
  69         manager->config_map = irreco_string_table_new(NULL,
  70                 IRRECO_KEY_SET_NOTIFY(irreco_backend_instance_set_config));
  71         IRRECO_RETURN_PTR(manager);
  72 }
  73
  74 void irreco_backend_manager_destroy(IrrecoBackendManager * manager)
  75 {
  76         IRRECO_ENTER
  77         if (manager == NULL) IRRECO_RETURN
  78         irreco_string_table_free(manager->config_map);
  79         irreco_string_table_free(manager->instance_table);
  80         irreco_string_table_free(manager->lib_table);
  81         g_slice_free(IrrecoBackendManager, manager);
  82
  83         IRRECO_RETURN
  84 }
  85
  86 /** @} */
  87
  88
  89
  90 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  91 /* Utility.                                                                   */
  92 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  93
  94 /**
  95  * @name Utility
  96  * @{
  97  */
  98
  99 void irreco_backend_manager_get_devcmd_lists(IrrecoBackendManager * manager)
 100 {
 101         IRRECO_ENTER
 102         g_assert(manager != NULL);
 103
 104         IRRECO_PRINTF("Getting device / command lists.\n");
 105         IRRECO_BACKEND_MANAGER_FOREACH_INSTANCE(manager, instance)
 106                 irreco_backend_instance_get_devcmd_list(instance);
 107         IRRECO_BACKEND_MANAGER_FOREACH_END
 108
 109         IRRECO_RETURN
 110 }
 111
 112 void irreco_backend_manager_read_from_confs(IrrecoBackendManager * manager)
 113 {
 114         IRRECO_ENTER
 115         g_assert(manager != NULL);
 116
 117         IRRECO_PRINTF("Reading instace configurations.\n");
 118         IRRECO_BACKEND_MANAGER_FOREACH_INSTANCE(manager, instance)
 119                 irreco_backend_instance_read_from_conf(instance);
 120         IRRECO_BACKEND_MANAGER_FOREACH_END
 121
 122         IRRECO_RETURN
 123 }
 124
 125 void irreco_backend_manager_print(IrrecoBackendManager * manager)
 126 {
 127         gint i;
 128         IRRECO_ENTER
 129         g_assert(manager != NULL);
 130
 131         i = 0;
 132         IRRECO_PRINTF("Backend libraries:\n");
 133         IRRECO_BACKEND_MANAGER_FOREACH_LIB(manager, lib)
 134                 IRRECO_PRINTF(" %i. \"%s\" \"%s\"\n", i++,
 135                               lib->filename, lib->name);
 136         IRRECO_BACKEND_MANAGER_FOREACH_END
 137
 138         i = 0;
 139         IRRECO_PRINTF("Backend instances:\n");
 140         IRRECO_BACKEND_MANAGER_FOREACH_INSTANCE(manager, instance)
 141                 IRRECO_PRINTF(" %i. \"%s\" \"%s\" \"%s\"\n", i++,
 142                               instance->lib->name, instance->name,
 143                               instance->config);
 144         IRRECO_BACKEND_MANAGER_FOREACH_END
 145
 146         IRRECO_RETURN
 147 }
 148
 149 /** @} */
 150
 151
 152
 153 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 154 /* Library management.                                                        */
 155 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 156
 157 /**
 158  * @name Library management
 159  * @{
 160  */
 161
 162 /**
 163  * Load backend from file.
 164  *
 165  * @param filepath      Complete path to library.
 166  * @return              Pointer to new IrrecoBackendLib, or NULL on failure.
 167  */
 168 IrrecoBackendLib *
 169 irreco_backend_manager_load_lib(IrrecoBackendManager * manager,
 170                                 const gchar * filepath)
 171 {
 172         gchar *filename;
 173         IrrecoBackendLib *backend_lib;
 174         IRRECO_ENTER
 175         g_assert(manager != NULL);
 176         g_assert(filepath != NULL);
 177
 178         filename = g_path_get_basename(filepath);
 179         backend_lib = irreco_backend_manager_load_with_name(
 180                 manager, filepath, filename);
 181         g_free(filename);
 182         IRRECO_RETURN_PTR(backend_lib);
 183 }
 184
 185 /**
 186  * Load backend from file.
 187  *
 188  * @param filepath      Complete path to library.
 189  * @param filename      Basename of the library.
 190  * @return              Pointer to new IrrecoBackendLib, or NULL on failure.
 191  */
 192 IrrecoBackendLib *
 193 irreco_backend_manager_load_with_name(IrrecoBackendManager * manager,
 194                                       const gchar * filepath,
 195                                       const gchar * filename)
 196 {
 197         IrrecoBackendLib *backend_lib;
 198         IRRECO_ENTER
 199         g_assert(manager != NULL);
 200         g_assert(filepath != NULL);
 201         g_assert(filename != NULL);
 202
 203         if (irreco_string_table_exists(manager->lib_table, filename)) {
 204                 IRRECO_ERROR("Backend \"%s\" has already been loaded.",
 205                              filename);
 206                 IRRECO_RETURN_PTR(NULL);
 207         }
 208
 209         backend_lib = irreco_backend_lib_load_with_name(filepath, filename);
 210         if (backend_lib != NULL) {
 211                 irreco_string_table_add(manager->lib_table,
 212                                         backend_lib->filename,
 213                                         backend_lib);
 214                 irreco_string_table_sort_abc(manager->lib_table);
 215         }
 216         IRRECO_RETURN_PTR(backend_lib);
 217 }
 218
 219 /**
 220  * Load all backends from directory.
 221  */
 222 gboolean
 223 irreco_backend_manager_load_lib_dir(IrrecoBackendManager * manager,
 224                                     gchar * directory)
 225 {
 226         IrrecoDirForeachData dir_data;
 227         IRRECO_ENTER
 228         g_assert(manager != NULL);
 229         g_assert(directory != NULL);
 230
 231         dir_data.directory = directory;
 232         dir_data.filesuffix = ".la";
 233         dir_data.user_data_1 = manager;
 234
 235         IRRECO_RETURN_BOOL(irreco_dir_foreach(
 236                 &dir_data, irreco_backend_manager_open_lib_dir_foreach));
 237 }
 238 void
 239 irreco_backend_manager_open_lib_dir_foreach(IrrecoDirForeachData * dir_data)
 240 {
 241         IrrecoBackendManager *manager;
 242         IRRECO_ENTER
 243
 244         manager = (IrrecoBackendManager *) dir_data->user_data_1;
 245         irreco_backend_manager_load_with_name(manager,
 246                                               dir_data->filepath,
 247                                               dir_data->filename);
 248
 249         IRRECO_RETURN
 250 }
 251
 252 /**
 253  * Find library by filename.
 254  *
 255  * Returns: TRUE on success, FALSE otherwise.
 256  */
 257 gboolean irreco_backend_manager_find_lib(IrrecoBackendManager * manager,
 258                                          const gchar * filename,
 259                                          IrrecoBackendLib ** lib)
 260 {
 261         IRRECO_ENTER
 262         g_assert(manager != NULL);
 263         g_assert(filename != NULL);
 264         g_assert(lib != NULL);
 265
 266         if (irreco_string_table_get(manager->lib_table, filename,
 267                                     (gpointer *) lib)) {
 268                 IRRECO_RETURN_BOOL(TRUE);
 269         }
 270         IRRECO_RETURN_BOOL(FALSE);
 271 }
 272
 273 /** @} */
 274
 275
 276
 277 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 278 /* Instance management.                                                       */
 279 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 280
 281 /**
 282  * @name Instance management
 283  * @{
 284  */
 285
 286
 287 /**
 288  * Create new IrrecoBackendInstance and add it to the instance_table.
 289  *
 290  * @param name          Name of instace. Or NULL for autogeneration.
 291  * @param config        Config file of instace. Or NULL for autogeneration.
 292  * @return              New IrrecoBackendInstance, or NULL on failure.
 293  */
 294 IrrecoBackendInstance *
 295 irreco_backend_manager_create_instance(IrrecoBackendManager * manager,
 296                                        IrrecoBackendLib * lib,
 297                                        const gchar * name,
 298                                        const gchar * config)
 299 {
 300         IrrecoBackendInstance *instance;
 301         IRRECO_ENTER
 302         g_assert(manager != NULL);
 303         g_assert(lib != NULL);
 304
 305         /* Create instance. */
 306         instance = irreco_backend_instance_create(lib, manager->irreco_data);
 307         if (instance == NULL) IRRECO_RETURN_PTR(NULL);
 308
 309         /* Set instance name. */
 310         if (name != NULL) {
 311                 if (irreco_backend_manager_set_instance_name(
 312                         manager, instance, name) == FALSE) {
 313                         IRRECO_ERROR("Could not set instace name to \"%s\"",
 314                                      name);
 315                         irreco_backend_instance_destroy(instance);
 316                         IRRECO_RETURN_PTR(NULL);
 317                 }
 318         } else {
 319                 irreco_backend_manager_assign_instance_name(manager, instance);
 320         }
 321
 322         /* Set instance config. */
 323         if (config != NULL) {
 324                 if (irreco_backend_manager_set_instance_config(
 325                         manager, instance, config) == FALSE) {
 326                         IRRECO_ERROR("Could not set instace config to \"%s\"",
 327                                      config);
 328                         irreco_backend_instance_destroy(instance);
 329                         IRRECO_RETURN_PTR(NULL);
 330                 }
 331         } else {
 332                 irreco_backend_manager_assign_instance_config(manager, instance);
 333         }
 334
 335         IRRECO_RETURN_PTR(instance);
 336 }
 337
 338 /**
 339  * Destroy IrrecoBackendInstance and remove it from the instance_table.
 340  *
 341  * @return TRUE on success, FALSE otherwise.
 342  */
 343 gboolean
 344 irreco_backend_manager_destroy_instance(IrrecoBackendManager * manager,
 345                                        IrrecoBackendInstance * instance)
 346 {
 347         gchar *config_path;
 348         IRRECO_ENTER
 349
 350         g_assert(manager != NULL);
 351         g_assert(instance != NULL);
 352
 353         if (irreco_string_table_steal_by_data(
 354                 manager->instance_table, instance) == FALSE) {
 355                 IRRECO_RETURN_BOOL(FALSE);
 356         }
 357
 358         config_path = irreco_get_config_file("irreco", instance->config);
 359         irreco_string_table_remove(manager->config_map, instance->config);
 360         irreco_backend_instance_destroy_full(instance, TRUE);
 361
 362         IRRECO_PRINTF("Deleting \"%s\".\n", config_path);
 363         g_unlink(config_path);
 364         g_free(config_path);
 365
 366         IRRECO_RETURN_BOOL(TRUE);
 367 }
 368
 369 /**
 370  * Find instance by name.
 371  *
 372  * @return TRUE on success, FALSE otherwise.
 373  */
 374 gboolean irreco_backend_manager_find_instance(
 375                                       IrrecoBackendManager * manager,
 376                                       const gchar * name,
 377                                       IrrecoBackendInstance ** instance)
 378 {
 379         IRRECO_ENTER
 380         g_assert(manager != NULL);
 381         g_assert(name != NULL);
 382         g_assert(instance != NULL);
 383
 384         if (irreco_string_table_get(manager->instance_table, name,
 385                                     (gpointer *) instance)) {
 386                 IRRECO_RETURN_BOOL(TRUE);
 387         }
 388         IRRECO_RETURN_BOOL(FALSE);
 389 }
 390
 391 /**
 392  * Set name of the instance.
 393  *
 394  * @return TRUE on success, FALSE otherwise.
 395  */
 396 gboolean
 397 irreco_backend_manager_set_instance_name(IrrecoBackendManager * manager,
 398                                          IrrecoBackendInstance * instance,
 399                                          const gchar * name)
 400 {
 401         IRRECO_ENTER
 402         g_assert(manager != NULL);
 403         g_assert(instance != NULL);
 404         g_assert(name != NULL);
 405
 406         if (irreco_string_table_exists(manager->instance_table, name)) {
 407                 IRRECO_RETURN_BOOL(FALSE);
 408         }
 409
 410         /* Add instace to the table if it has not been added. */
 411         if (instance->name == NULL || irreco_string_table_exists(
 412             manager->instance_table, instance->name) == FALSE) {
 413                 irreco_string_table_add(manager->instance_table,
 414                                         name,
 415                                         instance);
 416
 417         /* Else we can just change the key. */
 418         } else {
 419                 irreco_string_table_change_key(manager->instance_table,
 420                                                instance->name,
 421                                                name);
 422         }
 423         irreco_string_table_sort_abc(manager->instance_table);
 424         IRRECO_RETURN_BOOL(TRUE);
 425 }
 426
 427 /**
 428  * Assingn a unique name to the instance.
 429  */
 430 void
 431 irreco_backend_manager_assign_instance_name(IrrecoBackendManager * manager,
 432                                             IrrecoBackendInstance * instance)
 433 {
 434         gint i = 0;
 435         GString *string;
 436         IRRECO_ENTER
 437
 438         g_assert(manager != NULL);
 439         g_assert(instance != NULL);
 440
 441         /* Generate a unique name for the instance. */
 442         string = g_string_new(NULL);
 443         do {
 444                 g_string_set_size(string, 0);
 445                 g_string_append_printf(string, "%s %i",
 446                                        instance->lib->name, ++i);
 447         } while (irreco_string_table_exists(manager->instance_table,
 448                                             string->str));
 449         irreco_backend_manager_set_instance_name(manager,
 450                                                  instance,
 451                                                  string->str);
 452         g_string_free(string, TRUE);
 453
 454         IRRECO_RETURN
 455 }
 456
 457 /**
 458  * Set configuration filename to the instance, if it is not used by another
 459  * instance.
 460  */
 461 gboolean
 462 irreco_backend_manager_set_instance_config(IrrecoBackendManager * manager,
 463                                            IrrecoBackendInstance * instance,
 464                                            const gchar * filename)
 465 {
 466         IRRECO_ENTER
 467         g_assert(manager != NULL);
 468         g_assert(instance != NULL);
 469         g_assert(filename != NULL);
 470
 471         if (irreco_string_table_exists(manager->config_map, filename)) {
 472                 IRRECO_RETURN_BOOL(FALSE);
 473         }
 474
 475         if (instance->config == NULL || irreco_string_table_exists(
 476             manager->config_map, instance->config) == FALSE) {
 477                 irreco_string_table_add(manager->config_map,
 478                                         filename,
 479                                         instance);
 480         } else {
 481                 irreco_string_table_change_key(manager->config_map,
 482                                                instance->config,
 483                                                filename);
 484         }
 485         IRRECO_RETURN_BOOL(TRUE);
 486 }
 487
 488 /**
 489  * Assingn a unique configuration filename to the instance.
 490  */
 491 void
 492 irreco_backend_manager_assign_instance_config(IrrecoBackendManager * manager,
 493                                               IrrecoBackendInstance * instance)
 494 {
 495         gint i = 0;
 496         GString *string;
 497         IRRECO_ENTER
 498
 499         g_assert(manager != NULL);
 500         g_assert(instance != NULL);
 501
 502         string = g_string_new(NULL);
 503         do {
 504                 g_string_set_size(string, 0);
 505                 g_string_append(string, "backend_");
 506                 g_string_append(string, instance->lib->filename);
 507                 irreco_char_replace(string->str, '.', '_');
 508                 g_string_append_printf(string, "_%i.config", ++i);
 509         } while (irreco_string_table_exists(manager->config_map,
 510                                             string->str));
 511         irreco_backend_manager_set_instance_config(manager,
 512                                                    instance,
 513                                                    string->str);
 514         g_string_free(string, TRUE);
 515
 516         IRRECO_RETURN
 517 }
 518
 519 /** @} */
 520 /** @} */
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536
 537
 538
 539
 540