Hôtes avec un espace PID distinct pour les processus dans Mininet

Question

Je souhaite exécuter des instances de Quagga sur chacun de mes hôtes dans un paramètre Mininet. Comme implémenté dans le code ci-dessous, je peux monter /tmp/<host>/etc/quagga comme /etc/quagga pour chaque hôte, en isolant les fichiers de configuration dans le répertoire par hôte (répertoires privés). Mais quand je démarre le service Quagga dans chaque hôte (dernières lignes dans le fichier ipconf ci-dessous), ils partagent tous le même numéro PID, créant effectivement le même processus pour chacun d'eux, bien que chacun ait son propre fichier de configuration Quagga.

Je veux avoir des instances Quagga séparées, chacune avec son propre PID. Comment puis-je atteindre cet objectif?

fichier de topologie personnalisée my_topo.py:

from mininet.topo import Topo 

class my_topo(Topo): 
    "My custom topology settings" 

    def __init__(self, enable_all=True): 
     "Create custom topo." 

     Topo.__init__(self) 

     private_dirs = [("/etc/quagga", "/tmp/%(name)s/etc/quagga")] 

     h1 = self.addHost("h1", 
          ip="172.31.1.100/24", 
          privateDirs=private_dirs) 

     h2 = self.addHost("h2", 
          ip="172.31.2.100/24", 
          privateDirs=private_dirs) 

     h3 = self.addHost("h3", 
          ip="172.31.3.100/24", 
          privateDirs=private_dirs) 

     h4 = self.addHost("h4", 
          ip="172.31.4.100/24", 
          privateDirs=private_dirs) 

     h5 = self.addHost("h5", 
          ip="172.32.1.2/30", 
          privateDirs=private_dirs) 

     sA = self.addSwitch("s5") 
     sB = self.addSwitch("s6") 
     sC = self.addSwitch("s7") 
     sD = self.addSwitch("s8") 

     self.addLink(h1, sA) 
     self.addLink(h2, sB) 
     self.addLink(h3, sC) 
     self.addLink(h4, sD) 
     self.addLink(sA, sB) 
     self.addLink(sB, sD) 
     self.addLink(sD, sC) 
     self.addLink(sC, sA) 
     self.addLink(sA, sD) 

     self.addLink(h2, h5, 1, 0) 
     self.addLink(h4, h5, 1, 1) 


topos = { "my_topo": (lambda: my_topo()) } 

fichier de commandes de ipconf:

h1 /etc/init.d/quagga restart 
h2 /etc/init.d/quagga restart 
h3 /etc/init.d/quagga restart 
h4 /etc/init.d/quagga restart 
h5 /etc/init.d/quagga restart 

Commande à exécuter MININET:

sudo mn --custom mininet/custom/my_topo.py --topo=my_topo --controller=remote,ip=192.168.56.101,port=6633 --pre=ipconf 

Answer 1

J'ai découvert moi-même comment isoler les processus de chaque hôte en utilisant Mininext, une extension pour Mininet qui fournit une plus grande isolation entre les hôtes. Mininext n'étant pas compatible avec les versions récentes de Mininet, j'ai dû rétrograder ce dernier en version 2.1.0, comme indiqué dans le référentiel Mininext. Maintenant, je peux gérer des instances Quagga distinctes dans chaque hôte.

Voici le code de la topologie adaptée en utilisant la bibliothèque Mininext, au cas où quelqu'un fait face à la même situation:

import inspect 
import os 
from mininext.topo import Topo 
from mininext.services.quagga import QuaggaService 
from collections import namedtuple 

QuaggaHost = namedtuple('QuaggaHost', 'name ip lo gw') 


class my_topo(Topo): 
    'My custom topology settings' 

    def __init__(self): 
     Topo.__init__(self) 

     self_path = os.path.dirname(os.path.abspath(
      inspect.getfile(inspect.currentframe()) 
     )) 

     quagga_svc = QuaggaService(autoStop=False) 

     quagga_base_config_path = self_path + '/configs/' 

     quagga_hosts = [] 
     quagga_hosts.append(QuaggaHost(name='h1', 
             ip='172.31.1.100/24', 
             lo='10.0.1.1/24', 
             gw='gw 172.31.1.1')) 
     quagga_hosts.append(QuaggaHost(name='h2', 
             ip='172.31.2.100/24', 
             lo='10.0.2.1/24', 
             gw='gw 172.31.2.1')) 
     quagga_hosts.append(QuaggaHost(name='h3', 
             ip='172.31.3.100/24', 
             lo='10.0.3.1/24', 
             gw='gw 172.31.3.1')) 
     quagga_hosts.append(QuaggaHost(name='h4', 
             ip='172.31.4.100/24', 
             lo='10.0.4.1/24', 
             gw='gw 172.31.4.1')) 
     quagga_hosts.append(QuaggaHost(name='h5', 
             ip='172.32.1.2/30', 
             lo='10.0.5.1/24', 
             gw='gw 172.32.1.1')) 

     hosts = {} 

     for host in quagga_hosts: 
      quagga_container = self.addHost(name=host.name, 
              ip=host.ip, 
              defaultRoute=host.gw, 
              hostname=host.name, 
              privateLogDir=True, 
              privateRunDir=True, 
              inMountNamespace=True, 
              inPIDNamespace=True, 
              inUTSNamespace=True) 
      hosts[host.name] = quagga_container 

      self.addNodeLoopbackIntf(node=host.name, ip=host.lo) 

      quagga_svc_config = \ 
       {'quaggaConfigPath': quagga_base_config_path + host.name} 
      self.addNodeService(node=host.name, service=quagga_svc, 
           nodeConfig=quagga_svc_config) 

     sA = self.addSwitch('s5') 
     sB = self.addSwitch('s6') 
     sC = self.addSwitch('s7') 
     sD = self.addSwitch('s8') 

     self.addLink(hosts['h1'], sA) 
     self.addLink(hosts['h2'], sB) 
     self.addLink(hosts['h3'], sC) 
     self.addLink(hosts['h4'], sD) 
     self.addLink(sA, sB) 
     self.addLink(sB, sD) 
     self.addLink(sD, sC) 
     self.addLink(sC, sA) 
     self.addLink(sA, sD) 

     self.addLink(hosts['h2'], hosts['h5'], 1, 0) 
     self.addLink(hosts['h4'], hosts['h5'], 1, 1) 


topos = {'my_topo': (lambda: my_topo())} 

fichiers de configuration quagga doivent être placés dans le répertoire configs, qui se trouve dans le même répertoire que le fichier de topologie. configs a des répertoires pour chaque hôte, comme si chacun d'eux était un répertoire /etc/quagga.