NetKit network generator

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
##############################################################################
#  Copyright (C) 2010 Kenkeiras <[email protected]>
#
#  This program is free software. It comes without any warranty, to
#  the extent permitted by applicable law. You can redistribute it
#  and/or modify it under the terms of the Do What The Fuck You Want
#  To Public License, Version 2, as published by Sam Hocevar.
#
#  See http://sam.zoy.org/wtfpl/COPYING for more details.
##############################################################################

import sys, string, os
from random import *
seed()

# Valores por defecto
machines = 10 # Número de máquinas
mem = 20      # Memoria por máquina
switches = 2  # Número de switches
mem_prop = 12 # Cantidad mínima de memoria por máquina
tap = ( int(os.getuid()) == 0 ) # Si es root (y tiene permisos para crear nuevas interfaces)

# Clase de interfaz
class interface:
    def __init__(self, name, ip, colName, default = False):
        self.name = name
        self.ip = ip
        self.default = default
        self.col = colName

# Clase de host
class host:
    def __init__(self, name):
        self.ifc = []
        self.name = name

    # Se conecta con una IP a un dominio de colisión
    def connect(self, ip, col, default = False):
        iface = interface("eth"+str(len(self.ifc)), ip, col, default)
        self.ifc.append(iface)


# Dominio de colision
class colDom:
    def __init__(self, name, ipNum):
        self.host = host("SW" + name) # Se añade el prefijo para distinguir
        self.name = name              # Switches
        self.list = []
        self.cip = 1
        self.ipRange = "10.0." + str(ipNum)

    # Se obtiene una IP no usada (y se considera usada)
    def getIdle(self):
        if (self.cip < 255):
            self.cip += 1
            return self.ipRange + "." + str(self.cip)

        else:
            return None

def buildFileTree(rootFolder):
    os.mkdir(str(rootFolder))

def genLab(net, col, mem, tap = False):

    # Se genera el archivo lab.conf
    f = open("lab.conf", "w")
    f.write("""LAB_DESCRIPTION=""
LAB_VERSION=""
LAB_AUTHOR=""
LAB_EMAIL=""
LAB_WEB=""
""")

    # Crea el núcleo de la red
    buildFileTree("BBOSS")
    bf = open("BBOSS.startup", "w")
    f.write("BBOSS[mem]=" + str(mem) + "\n")
    f.write("BBOSS[eth0]=" + "BigBoss" + "\n")               # Conexión al núcleo de la red
    if (tap):
        f.write("BBOSS[eth1]=tap,192.168.254.1,192.168.254.2\n") # Conexión a la red exterior

    bf.write("ifconfig eth0 10.0.0.1 netmask 255.255.255.0\n")
    # Se incluyen las máquinas y el gasto en memoria
    for i in net:
        f.write(str(i.name) + "[mem]=" + str(mem) + "\n")

    # Y los switches
    for i in col:
        f.write(str(i.host.name) + "[mem]=" + str(mem) + "\n")

    # Se incluyen las interfaces y dominios de colision
    for i in net:
        for iface in i.ifc:
            f.write(str(i.name) + "[" + str(iface.name) + "]=" +\
                     str(iface.col) + "\n")

    for i in col:
        for iface in i.host.ifc:
            f.write(str(i.host.name) + "[" + str(iface.name) + "]=" +\
                     str(iface.col) + "\n")


    f.close()

    for i in net:
        # Se crean los archivos .startup
        f = open(str(i.name) + ".startup", "w")
        #f.write("sh /etc/rc.d/rc.stup\n")
        f.close()

        # Y el árbol de archivos
        buildFileTree(str(i.name))

        f = open(str(i.name) + ".startup", "a")
        for iface in i.ifc: # Se configuran las interfaces
            f.write("ifconfig " + iface.name + " " + iface.ip + " netmask 255.255.255.0\n")
            f.write("ifconfig " + iface.name + " up\n")
            tgt = iface.ip.split(".")
            if (iface.default): # Y el enrutado
                f.write("route add default gw " + string.join(tgt[ : 3 ], \
                        ".") + ".1\n")

        f.close()


    for c in col:
        i = c.host
        # Se crean los archivos .startup
        f = open(str(i.name) + ".startup", "w")
        #f.write("/etc/rc.d/rc.stup start\n")
        f.close()

        # Y el árbol de archivos
        buildFileTree(str(i.name))

        f = open(str(i.name) + ".startup", "a")
        tgt = ""
        src = ""
        def_if = ""
        for iface in i.ifc: # Se configuran las interfaces
            if not("10.0.0." in iface.ip):
                src = iface.ip.split(".")
            else:
                def_if = iface.name
                tgt = iface.ip

            f.write("ifconfig " + iface.name + " " + iface.ip + " netmask 255.255.255.0\n")

        if (tgt != "") and (src != ""):
            bf.write("route add -net " + string.join(src[ : 3 ], ".") + ".0 gw " + tgt + " netmask 255.255.255.0 \n")
        else:
            print >>sys.stderr, "Switch", i.name, "sin conexion a BBOSS (¿?)"

        f.write("route add default gw 10.0.0.1 dev " + def_if + "\n") # Y el enrutado
        f.write("echo 1 >> /proc/sys/net/ipv4/ip_forward\n") # Se permite forwardear paquetes

        f.close()

    bf.write("echo 1 >> /proc/sys/net/ipv4/ip_forward\n")
    bf.close()

# Se genera la red a partir de el número de máquinas
# su gasto en memoria y el numero de dominios de colision
def Netbuild(nmachine, mem, sn, tap = False):

    colName = "CD"       # Prefijo de los dominios de colision
    machName = "MACH"    # Prefijo de las máquinas
    prop = (nmachine/sn) # Proporción máquinas/switches

    print 'Memoria por máquina:',mem,'MB'
    print prop,'máquinas por switch'
    print 'Generando (',nmachine + 1,') máquinas...'

    net = []
    col = []
    ipNet = []
    for i in range(0, nmachine): # Se generan las máquinas
        h = host(machName + str(i))
        net.append(h)

    j = 0
    print 'Generando (',sn,') switches...'
    for i in range(1, sn + 1):
        col.append(colDom(colName + str(i), i)) # Se genera el dominio de colision

        col[-1].host.connect( col[-1].ipRange + ".1", col[-1].name, True) # Se conecta el switch al dominio de colision
        col[-1].host.connect( "10.0.0." + str(i + 1), "BigBoss", True)    # Y al núcleo de la red
        while (j < prop * (i)): # Se le asignan las máquinas correspondientes

            ip = col[-1].getIdle() # Se obtiene una IP válida
            if (ip == None):
                print >>sys.stderr, "Exceso de máquinas por dominio de colision"
                exit(1)

            net[j].connect(ip, col[-1].name, True) # Se le asigna a la máquina como salida por defecto

            j += 1

    # Se asignan las máquinas que sobran
    while (j < len(net)):
        n = randint(0, len(col) - 1)
        ip = col[-1].getIdle() # Se obtiene una IP válida
        if (ip == None):
            print >>sys.stderr, "Exceso de máquinas por dominio de colision"
            exit(1)

        net[j].connect(ip, col[-1].name, True) # Se le asigna a la máquina como salida por defecto
        j += 1


    genLab(net, col, mem, tap) # Se generan los archivos de laboratorio


if __name__=="__main__":

    if (len(sys.argv) > 1):
        if (sys.argv[1] in "clean") and ("clean".index(sys.argv[1]) == 0):
            os.system("rm -Rf MACH* SWCD* BBOSS* lab.conf")
            sys.exit(0)

        else:
            max_mem = int(raw_input('Máximo de memoria que utilizara(MB): '))
            switches = int(raw_input('Número de switches que se utilizarán: '))
            machines = int(raw_input('Número total de máquinas que se utilizarán: '))
            mem = int(max_mem / (switches + machines) )

    if (machines < 1):
        print 'Datos invalidos'
        sys.exit(1)

    elif ( mem < mem_prop):
        print 'No hay suficiente memoria para cada máquina'
        sys.exit(1)

    Netbuild(machines - 1, mem, switches, tap)