misc/kickstart_create_network_line.py

#!/usr/bin/python
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#


'''
    This reads a configuration file and checks for functioning
    network links in /sys/class/net/*, then emits a ks.cfg network line.
    '''

from __future__ import print_function
import os
import re


global TO_LOG
# This "logs" to stdout which is captured during kickstart
TO_LOG = True

# This is the standard interface we install to. It is set to a speed value of
# 5 (vice 100,1000 or 10000) later on and any other interface will override it
# if you've got something faster installed.
standard_interface=['p4p1']

## These are configuration settings:
# Name of Configuration file:
cfg_file = "network.cfg"

# Where linux is putting the interface stuff:
iface_dir = '/sys/class/net/'

ignore_interfaces = ['lo','bond']

# Where we kickstart mounts the ISO, and our config directory:
base_cfg_dir = '/mnt/stage2/ks_scripts/'

# Remember the ? makes the match non-greedy. This is important.
cfg_line = re.compile("\s*(?P<key>.*?)=(?P<value>.*)\s*$")

# Pick the interface speed for bonding, or "Auto".
# Auto assumes you want the fastest connections with more than 1 interface,
# Or if there's not 2 interfaces at the same speed you want the fastest.
# auto is expected to be a string, otherwise use integers:
# Speed is in megs. 1000 is 1 gig, 10000 is 10G.

iface_speed = 'auto'

restring = iface_dir + "(?P<iface>.*)/speed"
iface_search = re.compile(restring)


def read_config(config_file):
    ''' Reads our network config file and hands back a dict of key:value
    pairs '''

    net_cfg = {}
    with open(config_file,'r') as cfg:
        network_lines = cfg.readlines()
        for line in network_lines:
            if cfg_line.match(line):
                key = cfg_line.match(line).group('key')
                value = cfg_line.match(line).group('value')
                net_cfg[key] = value
    return net_cfg


def find_usable_net_devs(location):
    ''' Search through iface_dir looking for /speed files.
    Build a dict keyed on speed (in otherwords the speed is the key with a list of
    interfaces as teh value). '''
    # We "pre-seed" the dictionary with the standard interface names at a
    # speed of 5 so that if there's nothing else we set that up. This
    # makes it easier  to reconfigure later.
    ifaces = {5:standard_interface}
    bad_ifaces={}
    devs = os.listdir(location)
    for dev in devs:
        dev_path = os.path.join(location,dev,'speed')
        add=True
        if os.path.isfile(dev_path):
            with open(dev_path,'r') as iface:
                try:
                    speed = iface.readlines()
                    # speed should only have one line:
                    speed = int(speed[0])
                # if there is no link some drivers/cards/whatever will
                # throw an IOError when you try to read the speed file.
                except IOError:
                    speed = 0
        # Other cards will return a -1, which is fine, but *some* of them
        # return a 65535. Those we set to 0 as well.
        if speed == 65535:
            speed = 0
        for i_face in ignore_interfaces:
            if i_face in dev:
                add = False
        if speed  <= 0:
            add = False
        if TO_LOG:
            print(add, dev)
        if add:
            if speed in ifaces:
                this_speed = ifaces[speed]
                this_speed.append(dev)
                ifaces[speed]=this_speed
            else:
                ifaces[speed]=[dev]
        else:
            bad_ifaces[dev] = speed
    print("We find these interfaces have link and might be useful:", ifaces)
    if TO_LOG:
        print("And these aren't useful:", bad_ifaces)
    return ifaces


def useable_interfaces(net_devs, nc, iface_speed):
    ''' This takes a go at figuring out which interfaces to use.'''
    iface_list = False
    notes = False
    if TO_LOG:
        print("in usable interfaces")

    if "bond" not in nc['BOND_DEVICE'].lower():
        if TO_LOG:
            print("useable interfaces if not", nc['BOND_DEVICE'])
        #  Not doing a bond, so  we check to make sure the requested device,
        #  nc['BOND_DEVICE'], is in the list of devices with carrier:
        if nc['BOND_DEVICE'] == '""':
            # In this case we have no network interface in the configuration but we
            # network settings.
            # First we check how many net_devs we have:
            if TO_LOG:
                print("nc['BOND_DEVICE']=''", len(net_devs), net_devs)
            if len(net_devs) == 1: # This is a dict of speed: devices
                speeds = net_devs.keys()
                speeds.sort(reverse=True)
                speed = speeds[0]
                possibles = net_devs[speed]
                if TO_LOG:
                    print(possibles)
                # At this point we have options, but no information, so:
                notes = "No device in the configuration file and multiple devices found. Picking the first"
                iface_list = [possibles[0]]
        else:
            if TO_LOG:
                print("inner else")
            for speed in net_devs:
                if nc['BOND_DEVICE'] in net_devs[speed]:
                    iface_list = [nc['BOND_DEVICE']]
                else:
                    iface_list = [nc['BOND_DEVICE']]
                    notes = "{0} did not have carrier at install time, and may not work".format(nc['BOND_DEVICE'])
    elif iface_speed != 'auto':
        if len(net_devs[iface_speed]) > 0:
            iface_list = net_devs[iface_speed]
        else:
            notes = "no devices set to {0}".format(iface_speed)
    else: # This SHOULD be iface_speed == auto, and nc['BOND_DEVCE'] containing bond.
        #  if not it is anyway.
        # Thus we are doing a bond of some sort.
        # This gives us the fastest interfaces first:
        speeds = [k for k in sorted(net_devs.keys(), reverse=True)]
        fastest = speeds[0]
        # Walk through "speeds" and take the first one that has more than one
        # interface. This will only set iface_list if there are 2 or more interfaces:
        # previous_speed = 0
        for i in speeds:
            if len(net_devs[i]) > 1:
                iface_list = net_devs[i]
                break
        if TO_LOG:
            print("iface list:", iface_list)
        # if iface_list is still false, and we are requesting a bond, we will
        # want the fastest interface with link:
        if (iface_list == False) and ("bond" in nc['BOND_DEVICE'].lower()):
                if TO_LOG:
                    print(len(net_devs), net_devs, i)
                if len(net_devs) == 0:
                    iface_list = net_devs
                    notes = "no devices found for the bond. Will not have network after reboot"
                else:
                    iface_list = net_devs[fastest] # This is assuming that we'll want to bond the fastest interaface.
                    if TO_LOG:
                        print("dev:", net_devs[fastest])
    if TO_LOG:
        print(iface_list, notes)
    return iface_list, notes


# Find our network configuration file:
if os.path.isfile(os.path.join(base_cfg_dir,cfg_file)):
    cfg_path = os.path.join(base_cfg_dir,cfg_file)
elif os.path.isfile(cfg_file):
    cfg_path = cfg_file
else:
    cfg_path = ''

if cfg_path:
    nc = read_config(cfg_path)
else:
    # if we don't have a working config file we use this
    # The IPs and hostnames are bad.
    nc = { IPADDR:"10.0.0.2",
        NETMASK:"255.255.255.252",
        GATEWAY:"10.0.0.1",
        BOND_DEVICE:"bond0",
        MTU:"9000",
        NAMESERVER:"192.168.0.1",
        HOSTNAME:"bad.example.com",
        NETWORKING_IPV6:"yes",
        IPV6ADDR:" 2001:0db8:0a0b:12f0:0000:0000:0000:0002/64",
        IPV6_DEFAULTGW:" 2001:0db8:0a0b:12f0:0000:0000:0000:0001",
        BONDING_OPTS:"miimon=100 mode=4 lacp_rate=fast xmit_hash_policy=layer3+4",
        DHCP:"no" }
# This should be set to no in the config file, but that could change:
if "DHCP" not in nc:
    nc['DHCP']='no'

net_devs = find_usable_net_devs(iface_dir)
bondable_iface, iface_problems = useable_interfaces(net_devs, nc, iface_speed)

# turn bondable_iface into a string for the network line:
if bondable_iface and len(bondable_iface) > 1:
    dev_list = bondable_iface
    dev_str = dev_list.pop()
    for d in dev_list:
        dev_str = dev_str + "," + d
else:
    dev_str = bondable_iface[0]


if ('y' in nc['NETWORKING_IPV6'].lower()) and re.search(":",nc['IPV6ADDR']):
    IPV6 = "--ipv6=" + nc["IPV6ADDR"]
else:
    if 'y' in nc['NETWORKING_IPV6'].lower():
        if iface_problems is False:
            iface_problems = "IPv6 enabled but no address provided"
        else:
            iface_problems = "{0} and IPv6 enabled but no address provided".format(iface_problems)
    if re.search(":",nc['IPV6ADDR']):
        if iface_problems is False:
            iface_problems = "IPv6 is disabled, but IPV6ADDR was set to {0}".format(nc['IPV6ADDR'])
        else:
            iface_problems = "{0} and IPv6 is disabled, but IPV6ADDR was set to {1}".format(iface_problems, nc['IPV6ADDR'])
    IPV6 = "--noipv6"

if "bond" in nc['BOND_DEVICE'].lower():
    bond_stuff = "--device={BOND_DEVICE} --bondslaves={0} --bondopts={BONDING_OPTS}".format(dev_str, **nc)
elif nc['BOND_DEVICE'] in dev_str:
    bond_stuff = "--device={0}".format(nc["BOND_DEVICE"])
elif bondable_iface and nc['BOND_DEVICE'] == '""' :
    print("**")
    print("No device (BOND_DEVICE) specified it he config, found", bondable_iface, "with link, using it.")
    print("**")
    bond_stuff = "--device={0}".format(bondable_iface[0])
else:
    print("**")
    print(nc["BOND_DEVICE"], "not found within $usable_devices, setting anyway, this probably won't work")
    print("**")
    bond_stuff = "--device={0}".format(nc["BOND_DEVICE"])

if 'yes' in nc['DHCP'].lower() or not bondable_iface:
    network_line = "network --bootproto=dhcp --device={BOND_DEVICE} --hostname={HOSTNAME}".format(**nc)
else:
    network_line = "network --bootproto=static {0} --activate {1} --ip={IPADDR} --netmask={NETMASK} --gateway={GATEWAY} --nameserver={NAMESERVER} --mtu={MTU} --hostname={HOSTNAME} \n".format(
            bond_stuff, IPV6, **nc)

if iface_problems:
    network_line = "# Problems found: {0}\n{1}".format(iface_problems,network_line)

with open('/tmp/network_line','w') as OUT:
    OUT.write(network_line)