nm_madico_launcher.h

Go to the documentation of this file.

/*
 * NewMadeleine
 * Copyright (C) 2006-2026 (see AUTHORS file)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */
 
#ifndef NM_MADICO_LAUNCHER_H
#define NM_MADICO_LAUNCHER_H
 
#include <Padico/Topology.h>
#include <Padico/NetSelector.h>
 
static nm_drv_vect_t nm_madico_launcher_default_selector(const char*url, void*_arg)
{
  struct nm_launcher_gates_s*p_gates = _arg;
  const int size = p_gates->size;
  int i = 0;
  while(i < size)
    {
      if((p_gates->p_gates[i].p_url != NULL) && (strcmp(p_gates->p_gates[i].p_url, url) == 0))
        {
          nm_drv_vect_t p_drvs = nm_drv_vect_copy(&p_gates->p_gates[i].drvs);
          return p_drvs;
        }
      i++;
    }
  return NULL;
}
 
 
static inline void nm_launcher_gates_populate_ns(struct nm_launcher_gates_s*p_gates, padico_topo_node_t*p_peers)
{
  int use_ns = 0;
  const char*nmad_driver = padico_getenv("NMAD_DRIVER");
  if( (nmad_driver == NULL) ||
      (strcmp(nmad_driver, "defaults") == 0) ||
      (strcmp(nmad_driver, "auto") == 0) )
    {
      /* no NMAD_DRIVER or explicit auto: use NetSelector */
      use_ns = 1;
    }
  else if(strncmp(nmad_driver, "file:", 5) == 0)
    {
      /* NetSelector does not support the file: syntax */
      use_ns = 0;
    }
  else if(strchr(nmad_driver, ',') != NULL)
    {
      /* NMAD_DRIVER using NetSelector syntax -> inherit */
      puk_opt_setvalue("NetSelector_madico", "netselector_list", nmad_driver);
      padico_out(puk_verbose_info, "use NetSelector with value = %s\n", nmad_driver);
      use_ns = 1;
    }
  if(use_ns)
    {
      struct nm_component_hashtable_s loaded_components;
      nm_component_hashtable_init(&loaded_components);
      int i;
      for(i = 0; i < p_gates->size; i++)
        {
          if(!nm_drv_vect_empty(&p_gates->p_gates[i].drvs))
            {
              /* register already initialized drivers _before_ trying to load
               * anything else to avoid duplicates */
              nm_drv_vect_itor_t d;
              puk_vect_foreach(d, nm_drv, &p_gates->p_gates[i].drvs)
                {
                  nm_drv_t p_drv = *d;
                  nm_drv_t p_drv0 = nm_component_hashtable_lookup(&loaded_components, p_drv->assembly);
                  if(p_drv0 == NULL)
                    {
                      nm_component_hashtable_insert(&loaded_components, p_drv->assembly, p_drv);
                    }
                }
            }
        }
      for(i = 0; i < p_gates->size; i++)
        {
          if(p_peers[i] == NULL)
            {
              /* no topology info for this node yet; skip */
              continue;
            }
          if(!nm_drv_vect_empty(&p_gates->p_gates[i].drvs))
            {
              /* drivers already initialized for this gate; skip */
              continue;
            }
          const puk_component_t component_1 =
            padico_ns_serial_selector(p_peers[i], "trk_small", puk_iface_NewMad_minidriver());
          const puk_component_t component_2 =
            padico_ns_serial_selector(p_peers[i], "trk_large", puk_iface_NewMad_minidriver());
          if(component_1 == NULL)
            NM_FATAL("no suitable component to connect small trk to node %s\n",
                     padico_topo_node_getname(p_peers[i]));
          if(component_2 == NULL)
            NM_FATAL("no suitable component to connect large trk to node %s\n",
                     padico_topo_node_getname(p_peers[i]));
 
          nm_drv_t p_drv1 = nm_component_hashtable_lookup(&loaded_components, component_1);
          if(p_drv1 == NULL)
            {
              p_drv1 = nm_launcher_add_driver(component_1, nm_trk_kind_small);
              nm_component_hashtable_insert(&loaded_components, component_1, p_drv1);
            }
          nm_drv_vect_push_back(&p_gates->p_gates[i].drvs, p_drv1);
          nm_drv_t p_drv2 = nm_component_hashtable_lookup(&loaded_components, component_2);
          if(p_drv2 == NULL)
            {
              p_drv2 = nm_launcher_add_driver(component_2, nm_trk_kind_large);
              nm_component_hashtable_insert(&loaded_components, component_2, p_drv2);
            }
          nm_drv_vect_push_back(&p_gates->p_gates[i].drvs, p_drv2);
        }
      nm_launcher_set_selector(&nm_madico_launcher_default_selector, p_gates);
      nm_component_hashtable_destroy(&loaded_components);
    }
  int i;
  for(i = 0; i < p_gates->size; i++)
    {
      if(p_peers[i] != NULL)
        {
          assert(PADICO_TOPO_UUID_SIZE == NM_UUID_SIZE);
          padico_topo_uuid_t uuid = padico_topo_node_getuuid(p_peers[i]);
          memcpy(p_gates->p_gates[i].uuid.bytes, uuid, NM_UUID_SIZE);
        }
    }
 
}
 
 
#endif /* NM_MADICO_LAUNCHER_H */