raise UserException('No PXE IP Address in Inventory for client '
'\'%s\'' % hostname)
if ip_list != '':
ip = ',' + ip
ip_list += ip
return ip_list
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--deployer', action='store_true')
args = parser.parse_args()
config_pointer_file = get_python_path() + '/config_pointer_file'
if os.path.isfile(config_pointer_file):
with open(config_pointer_file) as f:
config_path = f.read()
else:
config_path = None
inv = Inventory(config_path)
cfg = Config(config_path)
ip_list = _get_pxe_ips(inv)
if args.deployer:
ip_list += "," + cfg.get_depl_netw_cont_ip()
print(ip_list)
class GetSwitchInfoAssignClass(object):
"""Get switch model information and assign class.
This class is responsible for collection switch model information
and assign the corresponding switch class.
"""
supported_mgmt_switches = (('G8052', 'Lenovo'), )
supported_data_switches = (('MLNX-OS', 'Mellanox'), )
MGMT_SWITCH_TYPE = 'mgmt'
DATA_SWITCH_TYPE = 'data'
ENABLE_REMOTE_CONFIG_MGMT = 'enable;configure terminal; %s'
SHOW_VERSION_MTM = 'show version | include ^MTM'
MODEL = 'Model'
MTM_VALUE = 'MTM Value'
ENABLE_REMOTE_CONFIG_DATA = 'cli enable "configure terminal" "%s"'
SHOW_VERSION_PRODUCT = 'show version | include ^Product'
PRODUCT_NAME = 'Product name'
SHOW_INVENTORY_CHASSIS = 'show inventory | include ^CHASSIS'
CHASSIS = 'CHASSIS'
def __init__(self, log, inv_file):
self.info_list = []
self.class_list = []
self.info_dict = AttrDict()
self.class_dict = AttrDict()
self.ipv4 = None
self.userid = None
self.password = None
self.enable_remote = None
self.inv = Inventory(log, inv_file)
self.log = log
def update_mgmt_switch_info(self):
"""Update management switch model information and assign class."""
self.enable_remote = self.ENABLE_REMOTE_CONFIG_MGMT
self.info_list = []
self.class_list = []
for switch in self.inv.yield_switches(self.inv.SwitchType.MGMT):
self.info_dict = AttrDict()
self.class_dict = AttrDict()
self.ipv4 = switch.ip_addr
self.userid = switch.userid
self.password = switch.password
switch_valid = False
output = self._send_cmd(self.SHOW_VERSION_MTM, 'Query MTM', False)
switch_valid |= self._set_switch_info_class(
r'\s+(\S+)\(config\)#', self.MODEL, output,
self.supported_mgmt_switches)
switch_valid |= self._set_switch_info_class(
r'%s:\s+(\S+)\s+' % self.MTM_VALUE, self.MTM_VALUE, output,
self.supported_mgmt_switches)
if not switch_valid:
if self.info_list:
self.log.error('Unsupported management switch: %s' %
self.info_dict)
else:
self.log.error('Management switch could not be identified')
sys.exit(1)
if self.info_list:
self.inv.update_switch_model_info(self.inv.SwitchType.MGMT,
self.info_list)
self.inv.update_switch_class(self.inv.SwitchType.MGMT,
self.class_list)
def update_data_switch_info(self):
"""Update data switch model information and assign class."""
self.enable_remote = self.ENABLE_REMOTE_CONFIG_DATA
self.info_list = []
self.class_list = []
for switch in self.inv.yield_switches(self.inv.SwitchType.DATA):
self.info_dict = AttrDict()
self.class_dict = AttrDict()
self.ipv4 = switch.ip_addr
self.userid = switch.userid
self.password = switch.password
switch_valid = False
output = self._send_cmd(self.SHOW_VERSION_PRODUCT,
'Query Product Name', False)
switch_valid |= self._set_switch_info_class(
r'%s:\s+(\S+)\s+' % self.PRODUCT_NAME, self.PRODUCT_NAME,
output, self.supported_data_switches)
output = self._send_cmd(self.SHOW_INVENTORY_CHASSIS,
'Query CHASSIS', False)
switch_valid |= self._set_switch_info_class(
r'%s\s+(\S+)\s+' % self.CHASSIS, self.CHASSIS, output,
self.supported_data_switches)
if not switch_valid:
if self.info_list:
self.log.error('Unsupported data switch: %s' %
self.info_dict)
else:
self.log.error('Data switch could not be identified')
sys.exit(1)
if self.info_list:
self.inv.update_switch_model_info(self.inv.SwitchType.DATA,
self.info_list)
self.inv.update_switch_class(self.inv.SwitchType.DATA,
self.class_list)
def _set_switch_info_class(self, pattern, attr, output,
supported_switches):
"""Add model and class information to switch structure.
Check whether switch is supported.
Args:
pattern (string): Command response pattern.
attr (string): Attribute key.
output (string): Command output.
supported_switches (tuple of tuples): Supported switches.
Returns:
(boolean): Whether switch is supported based on given attribute.
"""
pat = re.compile(pattern, re.MULTILINE)
match = pat.search(output)
if match:
switch_attr = match.group(1)
self.info_dict[attr] = switch_attr
self.info_list.append(self.info_dict)
attr_list = [sublist[0] for sublist in supported_switches]
class_list = [sublist[1] for sublist in supported_switches]
self.log.info(attr + ': ' + switch_attr + ' on ' + self.ipv4)
if switch_attr in attr_list:
index = attr_list.index(switch_attr)
self.class_dict = class_list[index]
self.class_list.append(self.class_dict)
return True
return False
def _send_cmd(self, cmd, msg, status_check=True):
"""Send command to switch.
Args:
cmd (string): Switch command.
msg (string): Description for log file.
status_check (boolean): Whether to check for SSH error.
Returns:
(string): Command output from switch.
"""
ssh = SSH(self.log)
self.log.debug(cmd + ' on ' + self.ipv4)
status, stdout_, _ = ssh.exec_cmd(self.ipv4, self.userid,
self.password,
self.enable_remote % cmd)
if status:
if status_check:
self.log.error('Failed: ' + msg + ' on ' + self.ipv4 +
' - Error: ' +
stdout_.replace('\n', ' ').replace('\r', ''))
sys.exit(1)
else:
self.log.info(msg + ' on ' + self.ipv4 + ' - Error: ' +
stdout_.replace('\n', ' ').replace('\r', ''))
else:
self.log.info(msg + ' on ' + self.ipv4)
return stdout_
class ConfigureDataSwitch(object):
ENABLE_REMOTE_CONFIG = 'cli enable "configure terminal" "%s"'
FORCE = 'force'
SET_VLAN = 'vlan %d'
SET_MTU = 'mtu %d'
INTERFACE_ETHERNET = 'interface ethernet 1/%s'
SWITCHPORT_MODE_HYBRID = 'switchport mode hybrid'
SWITCHPORT_HYBRID_ALLOWED_VLAN = \
'switchport hybrid allowed-vlan add %d'
SHUTDOWN = 'shutdown'
NO_SHUTDOWN = 'no shutdown'
IP_ROUTING = 'ip routing'
ENABLE_LACP = 'lacp'
QOS_ENABLE = 'dcb priority-flow-control enable force'
MLAG = 'protocol mlag'
LAG_PORT_CHANNEL = 'interface port-channel %d'
LACP = 'channel-group %d mode active'
IPL = 'ipl 1'
QOS_ON = 'dcb priority-flow-control mode on force'
INTERFACE_VLAN = 'interface vlan %d'
IP_CIDR = 'ip address %s'
PEER_ADDR = 'peer-address %s'
MLAG_VIP = 'mlag-vip my-mlag-vip-domain ip %s force'
ENABLE_MLAG = 'no mlag shutdown'
MLAG_PORT_CHANNEL = 'interface mlag-port-channel %d'
STP_PORT_TYPE_EDGE = 'spanning-tree port type edge'
STP_BPDUFILTER_ENABLE = 'spanning-tree bpdufilter enable'
MLAG_ACTIVE = 'mlag-channel-group %d mode active'
NO_CHANNEL_GROUP = 'no channel-group'
def __init__(self, log, inv_file):
self.inv = Inventory(log, inv_file)
self.log = log
self.userid = self.inv.get_userid_data_switch()
self.password = self.inv.get_password_data_switch()
self.switch_dict = {}
self.switch_name = self.inv.get_data_switch_name()
for ipv4 in self.inv.yield_data_switch_ip():
self.switch_dict[ipv4] = self.switch = SwitchFactory.factory(
log,
self.switch_name,
ipv4,
self.userid,
self.password,
mode='active')
for self.ipv4, userid, password, vlans in self.inv.yield_data_vlans(self.userid, self.password):
for vlan in vlans:
self.switch_dict[self.ipv4].create_vlan(vlan)
switch_index = 0
for self.ipv4, port_vlans, port_mtu, port_bonds \
in self.inv.yield_data_switch_ports(self.userid, self.password):
if port_bonds:
for ports in port_bonds.values():
for port in ports:
# Set port mode and add VLANs
if port in port_vlans:
self.switch_dict[self.ipv4].add_vlans_to_port(port, port_vlans[port])
# Specify MTU
if port in port_mtu:
self.switch_dict[self.ipv4].set_mtu_for_port(port, port_mtu[port])
else:
for port, vlans in port_vlans.items():
# Set port mode and add VLANs
self.switch_dict[self.ipv4].set_switchport_mode('trunk', port)
self.switch_dict[self.ipv4].add_vlans_to_port(port, vlans)
for port, mtu in port_mtu.items():
# Specify MTU
self.switch_dict[self.ipv4].set_mtu_for_port(port, mtu)
if port_bonds:
# Enable LACP
self.switch_dict[self.ipv4].enable_lacp()
# Configure port for MLAG
if self.inv.is_mlag():
vlan = self.inv.get_mlag_vlan()
port_channel = self.inv.get_mlag_port_channel()
cidr_mlag_ipl = self.inv.get_cidr_mlag_ipl(switch_index)
ipaddr_mlag_ipl_peer = self.inv.get_ipaddr_mlag_ipl_peer(switch_index)
ipaddr_mlag_vip = self.inv.get_ipaddr_mlag_vip()
mlag_ports = self.inv.get_mlag_ports(switch_index)
self.switch_dict[self.ipv4].configure_mlag(
vlan,
port_channel,
cidr_mlag_ipl,
ipaddr_mlag_ipl_peer,
ipaddr_mlag_vip,
mlag_ports)
for port_channel, ports in port_bonds.items():
# Remove any channel-group from port
self.switch_dict[self.ipv4].remove_channel_group(ports[0])
self.switch_dict[self.ipv4].create_mlag_interface(port_channel)
if ports[0] in port_vlans:
self.switch_dict[self.ipv4].add_vlans_to_mlag_port_channel(
port_channel, port_vlans[ports[0]])
if ports[0] in port_mtu:
self.switch_dict[self.ipv4].set_mtu_for_mlag_port_channel(
port_channel, port_mtu[ports[0]])
self.switch_dict[self.ipv4].bind_port_to_mlag_interface(port_channel)
# Enable MLAG
self.switch_dict[self.ipv4].enable_mlag()
# Configure port for LAG
else:
for port_channel, ports in port_bonds.items():
for port in ports:
self.switch_dict[self.ipv4].remove_channel_group(port)
if ports[0] in port_vlans:
self.switch_dict[self.ipv4].add_vlans_to_lag_port_channel(
port_channel, port_vlans[ports[0]])
if ports[0] in port_mtu:
self.switch_dict[self.ipv4].set_mtu_for_lag_port_channel(
port_channel, port_mtu[ports[0]])
self.switch_dict[self.ipv4].create_lag(port_channel)
self.switch_dict[self.ipv4].activate_lag(port_channel, ports)
switch_index += 1
if self.inv.is_write_switch_memory():
switch = WriteSwitchMemory(LOG, INV_FILE)
switch.write_data_switch_memory()
def __init__(self, log, inv_file):
self.inv = Inventory(log, inv_file)
self.log = log
self.userid = self.inv.get_userid_data_switch()
self.password = self.inv.get_password_data_switch()
self.switch_dict = {}
self.switch_name = self.inv.get_data_switch_name()
for ipv4 in self.inv.yield_data_switch_ip():
self.switch_dict[ipv4] = self.switch = SwitchFactory.factory(
log,
self.switch_name,
ipv4,
self.userid,
self.password,
mode='active')
for self.ipv4, userid, password, vlans in self.inv.yield_data_vlans(self.userid, self.password):
for vlan in vlans:
self.switch_dict[self.ipv4].create_vlan(vlan)
switch_index = 0
for self.ipv4, port_vlans, port_mtu, port_bonds \
in self.inv.yield_data_switch_ports(self.userid, self.password):
if port_bonds:
for ports in port_bonds.values():
for port in ports:
# Set port mode and add VLANs
if port in port_vlans:
self.switch_dict[self.ipv4].add_vlans_to_port(port, port_vlans[port])
# Specify MTU
if port in port_mtu:
self.switch_dict[self.ipv4].set_mtu_for_port(port, port_mtu[port])
else:
for port, vlans in port_vlans.items():
# Set port mode and add VLANs
self.switch_dict[self.ipv4].set_switchport_mode('trunk', port)
self.switch_dict[self.ipv4].add_vlans_to_port(port, vlans)
for port, mtu in port_mtu.items():
# Specify MTU
self.switch_dict[self.ipv4].set_mtu_for_port(port, mtu)
if port_bonds:
# Enable LACP
self.switch_dict[self.ipv4].enable_lacp()
# Configure port for MLAG
if self.inv.is_mlag():
vlan = self.inv.get_mlag_vlan()
port_channel = self.inv.get_mlag_port_channel()
cidr_mlag_ipl = self.inv.get_cidr_mlag_ipl(switch_index)
ipaddr_mlag_ipl_peer = self.inv.get_ipaddr_mlag_ipl_peer(switch_index)
ipaddr_mlag_vip = self.inv.get_ipaddr_mlag_vip()
mlag_ports = self.inv.get_mlag_ports(switch_index)
self.switch_dict[self.ipv4].configure_mlag(
vlan,
port_channel,
cidr_mlag_ipl,
ipaddr_mlag_ipl_peer,
ipaddr_mlag_vip,
mlag_ports)
for port_channel, ports in port_bonds.items():
# Remove any channel-group from port
self.switch_dict[self.ipv4].remove_channel_group(ports[0])
self.switch_dict[self.ipv4].create_mlag_interface(port_channel)
if ports[0] in port_vlans:
self.switch_dict[self.ipv4].add_vlans_to_mlag_port_channel(
port_channel, port_vlans[ports[0]])
if ports[0] in port_mtu:
self.switch_dict[self.ipv4].set_mtu_for_mlag_port_channel(
port_channel, port_mtu[ports[0]])
self.switch_dict[self.ipv4].bind_port_to_mlag_interface(port_channel)
# Enable MLAG
self.switch_dict[self.ipv4].enable_mlag()
# Configure port for LAG
else:
for port_channel, ports in port_bonds.items():
for port in ports:
self.switch_dict[self.ipv4].remove_channel_group(port)
if ports[0] in port_vlans:
self.switch_dict[self.ipv4].add_vlans_to_lag_port_channel(
port_channel, port_vlans[ports[0]])
if ports[0] in port_mtu:
self.switch_dict[self.ipv4].set_mtu_for_lag_port_channel(
port_channel, port_mtu[ports[0]])
self.switch_dict[self.ipv4].create_lag(port_channel)
self.switch_dict[self.ipv4].activate_lag(port_channel, ports)
switch_index += 1
if self.inv.is_write_switch_memory():
switch = WriteSwitchMemory(LOG, INV_FILE)
switch.write_data_switch_memory()
def __init__(self, inv_path=None, cfg_path=None):
self.log = logger.getlogger()
self.cfg_path = cfg_path
self.inv = Inventory(cfg_path, inv_path)
def cobbler_add_systems(cfg_file=None):
LOG = logger.getlogger()
cobbler_user = gen.get_cobbler_user()
cobbler_pass = gen.get_cobbler_pass()
cobbler_server = xmlrpc.client.Server("http://127.0.0.1/cobbler_api")
token = cobbler_server.login(cobbler_user, cobbler_pass)
inv = Inventory(cfg_file=cfg_file)
for index, hostname in enumerate(inv.yield_nodes_hostname()):
ipv4_ipmi = inv.get_nodes_ipmi_ipaddr(0, index)
userid_ipmi = inv.get_nodes_ipmi_userid(index)
password_ipmi = inv.get_nodes_ipmi_password(index)
ipv4_pxe = inv.get_nodes_pxe_ipaddr(0, index)
mac_pxe = inv.get_nodes_pxe_mac(0, index)
cobbler_profile = gen.check_os_profile(
re.sub("[.]iso", "", inv.get_nodes_os_profile(index)))
raid1_enabled = False
new_system_create = cobbler_server.new_system(token)
cobbler_server.modify_system(new_system_create, "name", hostname,
token)
cobbler_server.modify_system(new_system_create, "hostname", hostname,
token)
cobbler_server.modify_system(new_system_create, "power_address",
ipv4_ipmi, token)
cobbler_server.modify_system(new_system_create, "power_user",
userid_ipmi, token)
cobbler_server.modify_system(new_system_create, "power_pass",
password_ipmi, token)
cobbler_server.modify_system(new_system_create, "power_type",
"ipmilan", token)
cobbler_server.modify_system(new_system_create, "profile",
cobbler_profile, token)
cobbler_server.modify_system(
new_system_create, 'modify_interface', {
"macaddress-eth0": mac_pxe,
"ipaddress-eth0": ipv4_pxe,
"dnsname-eth0": hostname
}, token)
ks_meta = ""
disks = inv.get_nodes_os_install_device(index)
if disks is not None:
if isinstance(disks, str):
ks_meta += 'install_disk=%s ' % disks
elif isinstance(disks, list) and len(disks) == 2:
ks_meta += ('install_disk=%s install_disk_2=%s ' %
(disks[0], disks[1]))
raid1_enabled = True
else:
LOG.error('%s: Invalid install_device value: %s '
'Must be string or two item list.' %
(hostname, disks))
if raid1_enabled:
ks_meta += 'raid1_enabled=true '
users = inv.get_nodes_os_users(index)
if users is not None:
for user in users:
if 'name' in user and user['name'] != 'root':
ks_meta += 'default_user=%s ' % user['name']
LOG.debug("%s: Using \'%s\' as default user" %
(hostname, user['name']))
if 'password' in user:
ks_meta += ('passwd=%s passwdcrypted=true ' %
user['password'])
break
else:
LOG.debug("%s: No default user found" % hostname)
else:
LOG.debug("%s: No users defined" % hostname)
if ks_meta != "":
cobbler_server.modify_system(new_system_create, "ks_meta", ks_meta,
token)
kernel_options = inv.get_nodes_os_kernel_options(index)
if 'ubuntu-18.04' in cobbler_profile.lower():
if kernel_options is None:
kernel_options = ''
if 'netcfg/do_not_use_netplan=true' not in kernel_options:
kernel_options += ' netcfg/do_not_use_netplan=true'
if kernel_options is not None:
cobbler_server.modify_system(new_system_create, "kernel_options",
kernel_options, token)
cobbler_server.modify_system(new_system_create,
"kernel_options_post", kernel_options,
token)
comment = ""
cobbler_server.modify_system(new_system_create, "comment", comment,
token)
cobbler_server.save_system(new_system_create, token)
LOG.info("Cobbler Add System: name=%s, profile=%s" %
(hostname, cobbler_profile))
cobbler_server.sync(token)
LOG.info("Running Cobbler sync")
class InventoryAddPorts(object):
"""Class instance for adding port information to the Cluster Genesis
inventory file.
Args:
dhcp_leases_file (str): file path for the dnsmasq.leases file.
port_type (str): 'ipmi' or 'pxe'
"""
def __init__(self, dhcp_leases_file, port_type, config_path=None):
self.log = logger.getlogger()
self.cfg = Config(config_path)
self.dhcp_leases_file = dhcp_leases_file
self.port_type = port_type
self.inv = Inventory(cfg_file=config_path)
self.log.debug('Add ports, port type: {}'.format(self.port_type))
def get_ports(self):
dhcp_leases = GetDhcpLeases(self.dhcp_leases_file)
dhcp_mac_ip = dhcp_leases.get_mac_ip()
self.log.debug('DHCP leases: {}'.format(dhcp_mac_ip))
mgmt_sw_cfg_mac_lists = AttrDict()
if self.cfg.is_passive_mgmt_switches():
self.log.debug('passive mode')
for switch_label in self.cfg.yield_sw_mgmt_label():
file_path = os.path.join(GEN_PASSIVE_PATH, switch_label)
mac_info = {}
try:
with open(file_path, 'r') as f:
mac_info = f.read()
except IOError as error:
self.log.error(
'Passive switch MAC address table file not found {}'
.format(error))
raise
mgmt_sw_cfg_mac_lists[switch_label] = \
SwitchCommon.get_port_to_mac(mac_info, self.log)
else:
for sw_ai in self.cfg.yield_sw_mgmt_access_info():
self.log.debug('switch ai: {}'.format(sw_ai))
sw = SwitchFactory.factory(*sw_ai[1:])
label = sw_ai[0]
mgmt_sw_cfg_mac_lists[label] = \
sw.show_mac_address_table(format='std')
self.log.debug('Management switches MAC address tables: {}'.format(
mgmt_sw_cfg_mac_lists))
# Remove all the mac address table entries which do not have a matching
# MAC address in the DHCP leases table, then remove any MAC addresses
# which do not have a DHCP table entry.
for switch in mgmt_sw_cfg_mac_lists.keys():
for port in mgmt_sw_cfg_mac_lists[switch]:
port_macs = mgmt_sw_cfg_mac_lists[switch][port]
found_mac = False
for mac in dhcp_mac_ip.keys():
if mac in port_macs:
found_mac = True
# keep only the mac which has a dhcp address
mgmt_sw_cfg_mac_lists[switch][port] = [mac]
if not found_mac:
del mgmt_sw_cfg_mac_lists[switch][port]
self.log.debug('Management switches MAC address table of ports with'
'dhcp leases: {}'.format(mgmt_sw_cfg_mac_lists))
if self.port_type == "ipmi":
self.inv.add_macs_ipmi(mgmt_sw_cfg_mac_lists)
self.inv.add_ipaddrs_ipmi(dhcp_mac_ip)
elif self.port_type == "pxe":
self.inv.add_macs_pxe(mgmt_sw_cfg_mac_lists)
self.inv.add_ipaddrs_pxe(dhcp_mac_ip)
if self.port_type == 'ipmi':
self.node_table, self.ports_found, self.ports_total = \
self._build_node_table_ipmi(self.cfg, dhcp_mac_ip, mgmt_sw_cfg_mac_lists)
if self.port_type == 'pxe':
self.node_table, self.ports_found, self.ports_total = \
self._build_node_table_pxe(self.cfg, dhcp_mac_ip, mgmt_sw_cfg_mac_lists)
def _build_node_table_ipmi(self, cfg, dhcp_list, mac_lists):
# Tabulate results by Node type (template)
node_table = {}
ports_total = 0
ports_found = 0
for idx_ntmplt in self.cfg.yield_ntmpl_ind():
node_label = self.cfg.get_ntmpl_label(idx_ntmplt)
self.log.debug('node label: {}'.format(node_label))
ports_list = []
for idx_ipmi in self.cfg.yield_ntmpl_phyintf_ipmi_ind(idx_ntmplt):
switch_label = self.cfg.get_ntmpl_phyintf_ipmi_switch(
idx_ntmplt, idx_ipmi)
ports_total += self.cfg.get_ntmpl_phyintf_ipmi_pt_cnt(
idx_ntmplt, idx_ipmi)
for idx_port in self.cfg.yield_ntmpl_phyintf_ipmi_pt_ind(
idx_ntmplt, idx_ipmi):
port = self.cfg.get_ntmpl_phyintf_ipmi_ports(
idx_ntmplt, idx_ipmi, idx_port)
result = self.inv.get_port_mac_ip(switch_label, port)
if None not in result:
ports_found += 1
ports_list.append(
[True, switch_label, port, result[0], result[1], 'ipmi'])
self.log.debug(
'Node Port Defined in Inventory - Template: {}'
'Switch: {} Port: {} MAC: {} IP: {}'.format(
node_label, switch_label, port, result[0],
result[1], 'ipmi'))
elif str(port) in mac_lists[switch_label]:
for mac in mac_lists[switch_label][str(port)]:
if mac in dhcp_list:
ipaddr = dhcp_list[mac]
ports_list.append(
[False, switch_label, port, mac,
ipaddr, 'ipmi'])
self.log.debug(
'Node Port MAC/IP NOT Defined in Inventory - '
'Template: {} Switch: {} Port: {} '
'MAC: {} IP: {}'.format(
node_label, switch_label, port, mac, ipaddr))
else:
ports_list.append(
[False, switch_label, port, mac, '-', 'ipmi'])
self.log.debug(
'No DHCP Lease Found for Port MAC Address - '
'Template: {} Switch: {} Port: {} '
'MAC: {}'.format(
node_label, switch_label, port, mac))
else:
ports_list.append(
[False, switch_label, port, '-', '-', 'ipmi'])
self.log.debug(
'No Entries Found in MGMT Switch MAC Address Table - '
'Template: {} Switch: {} Port: {}'.format(
node_label, switch_label, port))
node_table[node_label] = ports_list
self.log.debug('node table: {}'.format(node_table))
return node_table, ports_found, ports_total
def _build_node_table_pxe(self, cfg, dhcp_list, mac_lists):
# Tabulate results by Node type (template)
node_table = {}
ports_total = 0
ports_found = 0
for idx_ntmplt in cfg.yield_ntmpl_ind():
node_label = cfg.get_ntmpl_label(idx_ntmplt)
self.log.debug('node label: {}'.format(node_label))
ports_list = []
for idx_pxe in cfg.yield_ntmpl_phyintf_pxe_ind(idx_ntmplt):
switch_label = cfg.get_ntmpl_phyintf_pxe_switch(idx_ntmplt, idx_pxe)
ports_total += cfg.get_ntmpl_phyintf_pxe_pt_cnt(idx_ntmplt, idx_pxe)
for idx_port in cfg.yield_ntmpl_phyintf_pxe_pt_ind(
idx_ntmplt, idx_pxe):
port = cfg.get_ntmpl_phyintf_pxe_ports(
idx_ntmplt, idx_pxe, idx_port)
result = self.inv.get_port_mac_ip(switch_label, port)
if None not in result:
ports_found += 1
ports_list.append(
[True, switch_label, port, result[0], result[1], 'pxe'])
self.log.debug(
'Node Port Defined in Inventory - Template: {}'
'Switch: {} Port: {} MAC: {} IP: {}'.format(
node_label, switch_label, port, result[0],
result[1], 'pxe'))
elif str(port) in mac_lists[switch_label]:
for mac in mac_lists[switch_label][str(port)]:
if mac in dhcp_list:
ipaddr = dhcp_list[mac]
ports_list.append(
[False, switch_label, port, mac,
ipaddr, 'pxe'])
self.log.debug(
'Node Port MAC/IP NOT Defined in Inventory - '
'Template: {} Switch: {} Port: {} '
'MAC: {} IP: {}'.format(
node_label, switch_label, port, mac, ipaddr))
else:
ports_list.append(
[False, switch_label, port, mac, '-', 'pxe'])
self.log.debug(
'No DHCP Lease Found for Port MAC Address - '
'Template: {} Switch: {} Port: {} '
'MAC: {}'.format(
node_label, switch_label, port, mac))
else:
ports_list.append(
[False, switch_label, port, '-', '-', 'pxe'])
self.log.debug(
'No Entries Found in MGMT Switch MAC Address Table - '
'Template: {} Switch: {} Port: {}'.format(
node_label, switch_label, port))
node_table[node_label] = ports_list
self.log.debug('node table: {}'.format(node_table))
return node_table, ports_found, ports_total
def get_table(self):
return self.node_table
def get_table_pretty(self):
"""Generates a list of node template names and pretty tables. To
print, simply print the list items. ie;
for item in add_ports.get_table_pretty():
print item
"""
blue = '\033[94m'
endc = '\033[0m'
table_pretty = []
table_header = ['In-Inventory', 'Switch', 'Port',
'MAC', 'IP', 'Port type']
for template in self.node_table.keys():
table_pretty.append('\n{}Node Type: {}:{}'.format(blue, template, endc))
table_pretty.append(tabulate(self.node_table[template], table_header))
return table_pretty
def get_status(self):
return (self.ports_found, self.ports_total)
class Player(Character):
def __init__(self, x, y, map, screen, uname, type, *groups):
super().__init__(x, y, type, map, screen, *groups)
self.inv = Inventory()
self.uname = uname
def facingTile(self):
x = self.x
y = self.y
if self.dir == "up":
y -= 1
elif self.dir == "down":
y += 1
elif self.dir == "left":
x -= 1
elif self.dir == "right":
x += 1
if x > constants.MAPWIDTH - 1:
return False
if x < 0:
return False
if y > constants.MAPHEIGHT - 1:
return False
if y < 0:
return False
return (x, y)
def interact(self):
coords = self.facingTile()
if coords == False:
return
tile = self.map.tileAt(coords[0], coords[1])
name = tile.unlocalisedName
if name == "grass":
to_place = self.inv.selected
if to_place == "":
return
self.map.tiles[(coords[0], coords[1])] = None
self.map.addTile(to_place, coords[0], coords[1])
self.inv.remove(to_place)
else:
tile.interact(self.inv)
def attack(self):
coords = self.facingTile()
if coords == False:
return
tile = self.map.tileAt(coords[0], coords[1])
name = tile.unlocalisedName
if name == "grass":
return
self.map.tiles[(coords[0], coords[1])] = None
self.map.addTile("grass", coords[0], coords[1])
if tile.drops == False:
self.inv.addTile(name, 1)
else:
drop = tile.drops[0]
amount = tile.drops[1]
self.inv.addTile(drop, amount)
def draw(self):
oldx = self.x
oldy = self.y
self.x = constants.CENTERX
self.y = constants.CENTERY
super().draw()
self.x = oldx
self.y = oldy
def __init__(self, log, inv_file):
inv = Inventory(log, inv_file)
inv.add_switches()
def ipmi_set_power(state, config_path=None, client_list=None, max_attempts=5,
wait=6):
"""Set power on or off
Args:
state (str) : 'on' or 'off'
client_list (list of str): list of IP addresses
"""
log = logger.getlogger()
inv = Inventory(config_path)
wait = float(wait)
max_attempts = int(max_attempts)
if not client_list:
log.debug('Retrieving IPMI address list from inventory')
client_list = inv.get_nodes_ipmi_ipaddr(0)
clients_left = client_list[:]
attempt = 0
none_cnt = 0
for client in client_list:
if client is None:
none_cnt += 1
log.warning('client node ip address is "None"')
clients_left.remove(None)
clients_left.sort()
while clients_left and attempt < max_attempts:
nodes = {}
attempt += 1
if attempt > 1:
print('Retrying set power {}. Attempt {} of {}'
.format(state, attempt, max_attempts))
print('Clients remaining: {}'.format(clients_left))
clients_set = []
bmc_dict = {}
for index, hostname in enumerate(inv.yield_nodes_hostname()):
ipv4 = inv.get_nodes_ipmi_ipaddr(0, index)
if ipv4 is None or ipv4 not in clients_left:
continue
rack_id = inv.get_nodes_rack_id(index)
userid = inv.get_nodes_ipmi_userid(index)
password = inv.get_nodes_ipmi_password(index)
nodes[ipv4] = [rack_id, ipv4]
for i in range(2):
try:
bmc_dict[ipv4] = ipmi_command.Command(
bmc=ipv4,
userid=userid,
password=password)
except pyghmi_exception.IpmiException as error:
log.error('IPMI login attempt {}, address {}\nIPMI error'
'message: {}'.format(i, ipv4, error.message))
time.sleep(1)
else:
break
for client in clients_left:
if client in bmc_dict:
try:
log.debug('Setting power state to {}. Device: {}'
.format(state, client))
status = bmc_dict[client].set_power(state, wait)
if attempt in [2, 4, 8]:
print('{} - {}'.format(client, status))
except pyghmi_exception.IpmiException as error:
msg = ('set_power failed Rack: %s - IP: %s, \n%s' %
(nodes[client][0], nodes[client][1], str(error)))
log.error(msg)
else:
# Allow delay between turn on to limit power surge
if state == 'on':
time.sleep(0.5)
finally:
if 'error' in status:
log.error(status)
time.sleep(wait + attempt)
for client in clients_left:
if client in bmc_dict:
try:
status = bmc_dict[client].get_power()
if attempt in [2, 4, 8]:
print('{} - {}'.format(client, status))
except pyghmi_exception.IpmiException as error:
msg = ('get_power failed - Rack: %s - IP: %s, %s' %
(rack_id, ipv4, str(error)))
log.error(msg)
else:
if status['powerstate'] == state:
log.debug('set_power successful Rack: %s - IP: %s' %
(nodes[client][0], nodes[client][1]))
clients_set += [client]
finally:
if 'error' in status:
log.error(status)
bmc_dict[client].ipmi_session.logout()
for client in clients_set:
clients_left.remove(client)
if attempt == max_attempts and clients_left:
log.error('Failed to power {} some clients'.format(state))
log.error(clients_left)
del bmc_dict
log.info('Powered {} {} of {} client devices.'
.format(state, len(client_list) - (len(clients_left) + none_cnt),
len(client_list)))
if state == 'off':
print('Pausing 60 sec for client power off')
time.sleep(60)
if clients_left:
return False
return True
def generate_dynamic_inventory():
config_pointer_file = gen.get_python_path() + '/config_pointer_file'
if os.path.isfile(config_pointer_file):
with open(config_pointer_file) as f:
config_path = f.read()
else:
config_path = None
inv = Inventory(config_path)
cfg = Config(config_path)
# Initialize the empty inventory
dynamic_inventory = INVENTORY_INIT
meta_hostvars = dynamic_inventory['_meta']['hostvars']
# Add 'env_variables' to 'all' 'vars'
dynamic_inventory['all']['vars']['env_variables'] = (
cfg.get_globals_env_variables())
# Add 'localhost' to inventory
meta_hostvars['localhost'] = {}
meta_hostvars['localhost']['ansible_connection'] = 'local'
# Add 'deployer' (container) to inventory
meta_hostvars['deployer'] = {}
meta_hostvars['deployer']['ansible_host'] = cfg.get_depl_netw_cont_ip()
meta_hostvars['deployer']['ansible_user'] = SSH_USER
meta_hostvars['deployer']['ansible_ssh_private_key_file'] = SSH_PRIVATE_KEY
# Add 'software_bootstrap' list to 'client_nodes' 'vars' if not empty
software_bootstrap = cfg.get_software_bootstrap()
if len(software_bootstrap) > 0:
dynamic_inventory['client_nodes']['vars']['software_bootstrap'] = (
software_bootstrap)
# Add client nodes to inventory
for index, hostname in enumerate(inv.yield_nodes_hostname()):
# Add node to top-level group (node-template label & 'client-nodes')
label = _sanitize(inv.get_nodes_label(index))
if label not in dynamic_inventory:
dynamic_inventory[label] = {'hosts': []}
dynamic_inventory['client_nodes']['children'].append(label)
dynamic_inventory[label]['hosts'].append(hostname)
# Add node hostvars in '_meta' dictionary
meta_hostvars[hostname] = inv.get_node_dict(index)
meta_hostvars[hostname]['ansible_host'] = (inv.get_nodes_pxe_ipaddr(
0, index))
meta_hostvars[hostname]['ansible_user'] = SSH_USER
meta_hostvars[hostname]['ansible_ssh_private_key_file'] = (
SSH_PRIVATE_KEY)
# Add node to any additional groups ('roles')
roles = inv.get_nodes_roles(index)
if roles is not None:
for role in roles:
_role = _sanitize(role)
if _role not in dynamic_inventory:
dynamic_inventory[_role] = {'hosts': []}
dynamic_inventory[_role]['hosts'].append(hostname)
return dynamic_inventory
def ipmi_set_bootdev(bootdev,
persist=False,
config_path=None,
client_list=None,
max_attempts=5):
log = logger.getlogger()
inv = Inventory(cfg_file=config_path)
if type(persist) is not bool:
persist = (persist == 'True')
# if client list passed, it is assumed to be pxe addresses.
# otherwise use the entire ipmi inventory list. This allows a
# subset of nodes to have their bootdev updated during install
if not client_list:
client_list = inv.get_nodes_ipmi_ipaddr(0)
clients_left = client_list[:]
else:
# Get corresponing ipmi addresses
clients_left = []
for index, hostname in enumerate(inv.yield_nodes_hostname()):
ipv4_ipmi = inv.get_nodes_ipmi_ipaddr(0, index)
ipv4_pxe = inv.get_nodes_pxe_ipaddr(0, index)
if ipv4_pxe is not None and ipv4_pxe in client_list:
clients_left.append(ipv4_ipmi)
attempt = 0
clients_left.sort()
while clients_left and attempt < max_attempts:
nodes = {}
attempt += 1
if attempt > 1:
print('Retrying set bootdev. Attempt {} of {}'.format(
attempt, max_attempts))
print('Clients remaining: {}'.format(clients_left))
clients_set = []
bmc_dict = {}
for index, hostname in enumerate(inv.yield_nodes_hostname()):
ipv4 = inv.get_nodes_ipmi_ipaddr(0, index)
if ipv4 is None or ipv4 not in clients_left:
continue
rack_id = inv.get_nodes_rack_id(index)
userid = inv.get_nodes_ipmi_userid(index)
password = inv.get_nodes_ipmi_password(index)
nodes[ipv4] = [rack_id, ipv4]
for i in range(2):
try:
bmc_dict[ipv4] = ipmi_command.Command(bmc=ipv4,
userid=userid,
password=password)
except pyghmi_exception.IpmiException as error:
log.error('IPMI login try {}, address {} - {}'.format(
i, ipv4, error.message))
time.sleep(1)
else:
break
for client in clients_left:
if client in bmc_dict:
try:
status = bmc_dict[client].set_bootdev(bootdev, persist)
if attempt in [2, 4, 8]:
print('Client node: {} - bootdev status: {}'.format(
client, status))
except pyghmi_exception.IpmiException as error:
msg = ('set_bootdev failed (device=%s persist=%s), '
'Rack: %s - IP: %s, %s' %
(bootdev, persist, nodes[client][0],
nodes[client][1], str(error)))
log.warning(msg)
finally:
if 'error' in status:
log.error(status)
time.sleep(1 + attempt)
for client in clients_left:
if client in bmc_dict:
try:
status = bmc_dict[client].get_bootdev()
if attempt in [2, 4, 8]:
print('{} - {}'.format(client, status))
except pyghmi_exception.IpmiException as error:
msg = ('get_bootdev failed - '
'Rack: %s - IP: %s, %s' %
(rack_id, ipv4, str(error)))
log.error(msg)
else:
if status['bootdev'] == bootdev and str(status['persistent']) \
== str(persist):
log.debug(
'set_bootdev successful (device=%s persist=%s) - '
'Rack: %s - IP: %s' %
(bootdev, persist, nodes[client][0],
nodes[client][1]))
clients_set += [client]
finally:
if 'error' in status:
log.error(status)
bmc_dict[client].ipmi_session.logout()
for client in clients_set:
clients_left.remove(client)
if attempt == max_attempts and clients_left:
log.error('Failed to set boot device for some clients')
log.debug(clients_left)
del bmc_dict
log.info('Set boot device to {} on {} of {} client devices.'.format(
bootdev,
len(client_list) - len(clients_left), len(client_list)))
"sccm_collection")
(options, args) = parser.parse_args()
config_parser = ConfigParser()
config = 'monitoring.ini'
config_parser.read(config)
json_file = config_parser.get('Monitoring', 'source_json')
logger.info("Loading json data from %s" % json_file)
if options.extra and not options.csv:
logger.critical("CSV extra options passed but the CSV flag was not set.")
sys.exit(-1)
inv = Inventory(json_file=json_file)
con = Constitution()
con.load_legislation(config_parser)
pol = Police(con, inv, logger)
if options.print_data:
print inv
elif options.show_detail:
print con
elif options.dry_run:
pol.dry_run()
elif options.csv:
additional_fields = []
"""
Arg1: inventory file
Arg2: switch type
Arg3: log level
"""
LOG = Logger(__file__)
if len(sys.argv) != 4:
try:
raise Exception()
except:
LOG.error('Invalid argument count')
sys.exit(1)
INV_FILE = sys.argv[1]
SWITCH_TYPE = sys.argv[2]
LOG.set_level(sys.argv[3])
INV = Inventory(LOG, INV_FILE)
if SWITCH_TYPE == 'mgmt':
result = validate_mgmt_mac_table_files(LOG, INV)
elif SWITCH_TYPE == 'data':
result = validate_data_mac_table_files(LOG, INV)
else:
LOG.error('Invalid "switch type" argument')
sys.exit(1)
if not result:
sys.exit(1)
def mock_inventory(cfg_file, inv_file, log):
# install.yml - include: lxc-update.yml
copy2(cfg_file, inv_file)
os.chmod(inv_file, 0o644)
for line in fileinput.input(inv_file, inplace=1):
print(line, end='')
if line.startswith('password-default'):
print('ansible_user: root')
print('ansible_ssh_private_key_file: '
'/home/ubuntu/.ssh/id_rsa_ansible-generated')
# install.yml - include: container/inv_add_ports.yml port_type=ipmi
inv = Inventory(log, inv_file)
(dhcp_mac_ip, mgmt_sw_cfg) = get_port_mac_ip(inv)
inv.create_nodes(dhcp_mac_ip, mgmt_sw_cfg)
# install.yml - include: container/inv_add_switches.yml
InventoryAddSwitches(log, inv_file)
# install.yml - include: container/inv_add_ports.yml port_type=pxe
inv = Inventory(log, inv_file)
inv.add_pxe(dhcp_mac_ip, mgmt_sw_cfg)
# install.yml - include: container/inv_add_ipmi_data.yml
inv = Inventory(log, inv_file)
add_ipmi_data(inv)
# install.yml - include: container/allocate_ip_addresses.yml
inv = Inventory(log, inv_file)
allocate_ips(inv_file)
# gather_mac_addresses.yml
inv = Inventory(log, inv_file)
switch_ip_to_port_to_macs = get_switch_ip_to_mac_map(inv)
inv.add_data_switch_port_macs(switch_ip_to_port_to_macs)
def main(log, inv_file):
inv = Inventory(log, inv_file)
print()
mgmt_network_ext_cidr = None
key_addr = None
try:
mgmt_network_port = inv.get_port_mgmt_network()
userid = inv.get_userid_mgmt_switch()
password = inv.get_password_mgmt_switch()
mgmt_network_gen = inv.get_ipaddr_mgmt_network()
mgmt_network_ext = inv.get_mgmt_switch_external_dev_ip()
mgmt_network_ext_prefix = inv.get_mgmt_switch_external_prefix()
mgmt_network_ext = mgmt_network_ext + '/' + mgmt_network_ext_prefix
mgmt_network_ext = netaddr.IPNetwork(mgmt_network_ext)
mgmt_network_ext_cidr = str(mgmt_network_ext.cidr)
except KeyError:
print('Switch access information not present in: {}'.format(inv_file))
print('Cluster Genesis may be in "passive" mode')
else:
output = subprocess.check_output(['bash', '-c',
'ip route']).decode("utf-8")
if mgmt_network_ext_cidr in output:
key_addr = 'addr_ext'
elif mgmt_network_gen in output:
key_addr = 'addr_gen'
else:
print('No route found using config file addresses')
if key_addr:
print('==============================')
print('Defined switches: ')
index = 1
switches_m = {}
for rack, ipv4 in inv.yield_mgmt_rack_ipv4():
switches_m[index] = {'rack': rack, 'addr_gen': ipv4}
index += 1
index = 1
for ipv4 in inv.yield_mgmt_switch_external_switch_ip():
switches_m[index]['addr_ext'] = ipv4
print(' ' + str(index) + ') rack: ' + switches_m[index]['rack'] +
', external address: ' + switches_m[index]['addr_ext'] +
', Genesis address: ' + switches_m[index]['addr_gen'])
index += 1
if not (len(switches_m) == 1):
sw = get_int_input("\n\nSelect a switch: ", 1, len(switches_m))
else:
sw = 1
addr = switches_m[sw][key_addr]
print()
else:
# output = subprocess.check_output(['bash', '-c', 'ip route'])
addr = '192.168.32.20/24'
userid = 'admin'
password = '******'
while 1:
addr = rlinput("Enter an address for the management switch: ",
addr)
mgmt_network_ext = netaddr.IPNetwork(addr)
mgmt_network_ext_cidr = str(mgmt_network_ext.cidr)
userid = rlinput("Enter a userid for the management switch: ",
userid)
password = rlinput(
"Enter a password for the management switch (last char = '.' to terminate): ",
password)
if password[-1:] == '.':
sys.exit(0)
output = subprocess.check_output(['bash', '-c',
'ip route']).decode("utf-8")
if mgmt_network_ext_cidr in output:
addr = addr[:addr.find('/')]
break
# the G8052 misbehaves & closes it's SSH connection
# after every paramiko 'exec_command', so using SSH
# with commands strung together
ssh = SSH(log)
cmd = 'show interface ip;show vlan;show interface port %s;' \
% (str(mgmt_network_port))
try:
_, switch_info, _ = ssh.exec_cmd(addr,
userid,
password,
cmd,
ssh_log=ssh_log,
look_for_keys=False)
except SSH_Exception as exc:
print('Failed to SSH to switch at {} using userid {} and password {}'.
format(addr, userid, password))
print(exc)
sys.exit(1)
print_lines(switch_info, ['Interface information:', 'IP4'])
print('\n\nVLAN information: ')
print_lines(switch_info, ['- ------ -', ' VLAN '])
print()
print('Deployer port: ')
print_lines(switch_info, ['Current port', 'VLANs'])
print()
def set_bootdev_clients(bootdev, persist=False, config_path=None, clients=None,
max_attempts=5):
"""Set boot device for multiple clients. If a list of ip addresses
are given they are assumed to be PXE addresses. Corresponding BMC addresses
are looked up in inventory file corresponding to the config file given in
the config_path. Similarly if no client list is given, all BMCs enumerated in
the inventory file corresponding to the config file specified in config_path
will be acted on. If clients is a dictionary, then the credentials are
taken from the dictionary values.
Args:
state (str) : 'on' or 'off'
config_path (str): path to a config file
clients (dict or list of str): list of IP addresses or
dict of ip addresses with values of credentials as tuple
ie {'192.168.1.2': ('user', 'password', 'bmc_type')}
"""
log = logger.getlogger()
if config_path:
inv = Inventory(cfg_file=config_path)
if type(persist) is not bool:
persist = (persist == 'True')
def _get_cred_list(client_list=None):
"""Returns dict with values of tuples or list. Each tuple/list
has the credentials for a node (userid, password, bmc_type).
If no client list is passed, all nodes are returned
Args:
client_list (list of str): each list item is an ipv4 address
"""
cred_list = {}
for index, hostname in enumerate(inv.yield_nodes_hostname()):
ipv4 = inv.get_nodes_ipmi_ipaddr(0, index)
if client_list and ipv4 not in client_list:
continue
userid = inv.get_nodes_ipmi_userid(index)
password = inv.get_nodes_ipmi_password(index)
bmc_type = inv.get_nodes_bmc_type(index)
cred_list[ipv4] = (userid, password, bmc_type)
return cred_list
# if client list passed, it is assumed to be pxe addresses which
# are used to look up the associated bmc addresses for the node.
# otherwise use the entire ipmi inventory list. This allows a
# subset of nodes to have their bootdev updated during install
if isinstance(clients, list):
# Get corresponing ipmi addresses
_clients = []
for index, hostname in enumerate(inv.yield_nodes_hostname()):
ipv4_ipmi = inv.get_nodes_ipmi_ipaddr(0, index)
ipv4_pxe = inv.get_nodes_pxe_ipaddr(0, index)
if ipv4_pxe is not None and ipv4_pxe in clients:
_clients.append(ipv4_ipmi)
if not clients:
log.debug('Retrieving IPMI address list from inventory')
clients = inv.get_nodes_ipmi_ipaddr(0)
_clients = clients[:]
if isinstance(clients, list):
log.debug('Retrieving client credentials from inventory')
cred_list = _get_cred_list(_clients)
else:
# insure cred info in tuple
cred_list = {}
for client in clients:
cred_list[client] = tuple(clients[client])
clients_left = list(cred_list.keys())
attempt = 0
clients_left.sort()
while clients_left and attempt < max_attempts:
attempt += 1
if attempt > 1:
log.info('Retrying set bootdev. Attempt {} of {}'.format(attempt, max_attempts))
log.info('Clients remaining: {}'.format(clients_left))
clients_set = []
bmc_dict = {}
for client in clients_left:
for i in range(3):
tmp = _bmc.Bmc(client, *cred_list[client])
if tmp.is_connected():
bmc_dict[client] = tmp
break
else:
log.debug(f'Failed BMC login attempt {i + 1} BMC: {client}')
if i > 0:
log.info(f'BMC login attempt {i + 1} BMC: {client}')
if attempt == max_attempts and i == 2:
log.error(f'Failed BMC login. BMC: {client}')
time.sleep(1)
del tmp
for client in clients_left:
if client in bmc_dict:
log.debug(f'Setting boot device to {bootdev}. '
f'Device: {client}')
if bootdev in ('setup'):
status = bmc_dict[client].host_boot_mode(bootdev)
else:
status = bmc_dict[client].host_boot_source(bootdev)
log.debug(f'status1 from set bootdev: {status}')
if status:
if attempt in [2, 4, 8]:
log.info(f'{client} - Boot source: {status} Required source: '
f'{bootdev}')
elif attempt == max_attempts:
log.error(f'Failed attempt {attempt} set boot source {bootdev} '
f'for node {client}')
time.sleep(1 + attempt)
for client in clients_left:
if client in bmc_dict:
if bootdev in ('setup'):
status = bmc_dict[client].host_boot_mode()
else:
status = bmc_dict[client].host_boot_source()
log.debug(f'status2 from set bootdev: {status}')
if status:
if attempt in [2, 4, 8]:
log.info(f'{client} - Boot source: {bootdev}')
if status == bootdev:
log.debug(f'Successfully set boot source to {bootdev} for '
f'node {client}')
clients_set += [client]
elif attempt == max_attempts:
log.error(f'Failed attempt {attempt} set host boot source to'
f'{bootdev} for node {client}')
bmc_dict[client].logout()
for client in clients_set:
clients_left.remove(client)
if attempt == max_attempts and clients_left:
log.error('Failed to set boot device for some clients')
log.debug(clients_left)
del bmc_dict
log.info('Set boot device to {} on {} of {} client devices.'
.format(bootdev, len(cred_list) - len(clients_left),
len(cred_list)))
def __init__(self, x, y, map, screen, uname, type, *groups):
super().__init__(x, y, type, map, screen, *groups)
self.inv = Inventory()
self.uname = uname
class InventoryNodes(object):
SWITCH_NOT_FOUND = \
"Node template '%s' did not have corresponding management switch '%s'"
def __init__(self, inv_path=None, cfg_path=None):
self.log = logger.getlogger()
self.cfg_path = cfg_path
self.inv = Inventory(cfg_path, inv_path)
def __del__(self):
self.inv.update_nodes()
def create_nodes(self):
cfg = Config(self.cfg_path)
interface_ip_lists = _gen_interface_ip_lists(cfg)
# Iterate over node templates
for index_ntmplt in cfg.yield_ntmpl_ind():
# Get Label
label = cfg.get_ntmpl_label(index_ntmplt)
# Get Hostname
hostname = cfg.get_ntmpl_os_hostname_prefix(index_ntmplt)
if hostname is None:
hostname = label
# Get bmc_type
bmc_type = cfg.get_ntmpl_bmc_type(index_ntmplt)
# Get Rack
switch_label = cfg.get_ntmpl_phyintf_ipmi_switch(index_ntmplt, 0)
switch_index = cfg.get_sw_mgmt_index_by_label(switch_label)
if switch_index is None:
node_template = cfg.get_ntmpl_label(index_ntmplt)
self.log.error(self.SWITCH_NOT_FOUND %
(node_template, switch_label))
# Iterate over client systems
index_host = 0
for index_port in cfg.yield_ntmpl_phyintf_ipmi_pt_ind(
index_ntmplt, 0):
# Set Label
self.inv.add_nodes_label(label)
# Set Hostname
self.inv.add_nodes_hostname(hostname + '-' +
str(index_host + 1))
# Set bmc_type
self.inv.add_nodes_bmc_type(bmc_type)
# Set Rack ID
switch_label = cfg.get_ntmpl_phyintf_ipmi_switch(
index_ntmplt, 0)
switch_index = cfg.get_sw_mgmt_index_by_label(switch_label)
self.inv.add_nodes_rack_id(
cfg.get_sw_mgmt_rack_id(switch_index))
# Copy OS settings dictionary
self.inv.add_nodes_os_dict(cfg.get_ntmpl_os_dict(index_ntmplt))
# Copy roles
self.inv.add_nodes_roles(cfg.get_ntmpl_roles(index_ntmplt))
ports_ipmi = []
ports_pxe = []
switches_ipmi = []
switches_pxe = []
macs_ipmi = []
macs_pxe = []
ipaddrs_ipmi = []
ipaddrs_pxe = []
devices_pxe = []
rename_pxe = []
# Iterate over IPMI members
for index_ipmi in cfg.yield_ntmpl_phyintf_ipmi_ind(
index_ntmplt):
# Create client system IPMI switch list
switches_ipmi.append(
cfg.get_ntmpl_phyintf_ipmi_switch(
index_ntmplt, index_ipmi))
# Create client system PXE switch list
switches_pxe.append(
cfg.get_ntmpl_phyintf_pxe_switch(
index_ntmplt, index_ipmi))
# Create client system IPMI port list
ports_ipmi.append(
cfg.get_ntmpl_phyintf_ipmi_ports(
index_ntmplt, index_ipmi, index_port))
# Create client system PXE port list
ports_pxe.append(
cfg.get_ntmpl_phyintf_pxe_ports(
index_ntmplt, index_ipmi, index_port))
# Create client system IPMI mac list
macs_ipmi.append(None)
# Create client system PXE mac list
macs_pxe.append(None)
# Create client system IPMI ipaddrs list
ipaddrs_ipmi.append(None)
# Create client system PXE ipaddrs list
ipaddrs_pxe.append(None)
# Create client PXE network device list
devices_pxe.append(
cfg.get_ntmpl_phyintf_pxe_dev(index_ntmplt))
# Create client PXE device rename list
rename_pxe.append(
cfg.get_ntmpl_phyintf_pxe_rename(index_ntmplt))
# Set client system IPMI switches
self.inv.add_nodes_switches_ipmi(switches_ipmi)
# Set client system PXE switches
self.inv.add_nodes_switches_pxe(switches_pxe)
# Set client system IPMI ports
self.inv.add_nodes_ports_ipmi(ports_ipmi)
# Set client system PXE ports
self.inv.add_nodes_ports_pxe(ports_pxe)
# Set client system IPMI macs
self.inv.add_nodes_macs_ipmi(macs_ipmi)
# Set client system PXE macs
self.inv.add_nodes_macs_pxe(macs_pxe)
# Set client system IPMI apaddrs
self.inv.add_nodes_ipaddrs_ipmi(ipaddrs_ipmi)
# Set client system PXE ipaddrs
self.inv.add_nodes_ipaddrs_pxe(ipaddrs_pxe)
# Set client system PXE rename
self.inv.add_nodes_rename_pxe(rename_pxe)
# Set client system IPMI userids
self.inv.add_nodes_userid_ipmi(
cfg.get_ntmpl_ipmi_userid(index_ntmplt))
# Set client system IPMI passwords
self.inv.add_nodes_password_ipmi(
cfg.get_ntmpl_ipmi_password(index_ntmplt))
# Set PXE network device
self.inv.add_nodes_devices_pxe(devices_pxe)
ports_data = []
switches_data = []
macs_data = []
devices_data = []
rename_data = []
# Iterate over data members
for index_data in cfg.yield_ntmpl_phyintf_data_ind(
index_ntmplt):
# Create client system data switch list
switches_data.append(
cfg.get_ntmpl_phyintf_data_switch(
index_ntmplt, index_data))
# Create client system data port list
ports_data.append(
cfg.get_ntmpl_phyintf_data_ports(
index_ntmplt, index_data, index_port))
# Create client system data mac list
macs_data.append(None)
# Create client data network device list
devices_data.append(
cfg.get_ntmpl_phyintf_data_dev(index_ntmplt,
index_data))
# Create client data device rename list
rename_data.append(
cfg.get_ntmpl_phyintf_data_rename(
index_ntmplt, index_data))
# Set client system data switches
self.inv.add_nodes_switches_data(switches_data)
# Set client system data ports
self.inv.add_nodes_ports_data(ports_data)
# Set client system data macs
self.inv.add_nodes_macs_data(macs_data)
# Set client system data devices
self.inv.add_nodes_devices_data(devices_data)
# Set client system data rename
self.inv.add_nodes_rename_data(rename_data)
index_host += 1
interfaces = cfg.get_ntmpl_interfaces(index_ntmplt)
interfaces, interface_ip_lists = _assign_interface_ips(
interfaces, interface_ip_lists)
self.inv.add_nodes_interfaces(interfaces)
self.log.info('Successfully created inventory file')
