pvc/client-common/client_lib/network.py

618 lines
24 KiB
Python
Raw Normal View History

#!/usr/bin/env python3
2018-09-23 15:26:20 -04:00
# network.py - PVC client function library, Network fuctions
# Part of the Parallel Virtual Cluster (PVC) system
#
# Copyright (C) 2018 Joshua M. Boniface <joshua@boniface.me>
#
# 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 3 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#
###############################################################################
import os
import socket
import time
import uuid
import re
import tempfile
import subprocess
import difflib
import colorama
import click
import lxml.objectify
import configparser
import kazoo.client
2018-09-23 15:26:20 -04:00
import client_lib.ansiiprint as ansiiprint
2018-09-25 01:47:29 -04:00
import client_lib.zkhandler as zkhandler
2018-09-23 15:26:20 -04:00
import client_lib.common as common
#
# Cluster search functions
#
2018-09-23 15:26:20 -04:00
def getClusterNetworkList(zk_conn):
# Get a list of VNIs by listing the children of /networks
vni_list = zk_conn.get_children('/networks')
description_list = []
# For each VNI, get the corresponding description from the data
for vni in vni_list:
description_list.append(zk_conn.get('/networks/{}'.format(vni))[0].decode('ascii'))
return vni_list, description_list
def searchClusterByVNI(zk_conn, vni):
try:
# Get the lists
2018-09-23 15:26:20 -04:00
vni_list, description_list = getClusterNetworkList(zk_conn)
# We're looking for UUID, so find that element ID
2018-09-23 15:26:20 -04:00
index = vni_list.index(vni)
# Get the name_list element at that index
2018-09-23 15:26:20 -04:00
description = description_list[index]
except ValueError:
# We didn't find anything
return None
2018-09-23 15:26:20 -04:00
return description
2018-09-23 15:26:20 -04:00
def searchClusterByDescription(zk_conn, description):
try:
# Get the lists
2018-09-23 15:26:20 -04:00
vni_list, description_list = getClusterNetworkList(zk_conn)
# We're looking for name, so find that element ID
2018-09-23 15:26:20 -04:00
index = description_list.index(description)
# Get the uuid_list element at that index
2018-09-23 15:26:20 -04:00
vni = vni_list[index]
except ValueError:
# We didn't find anything
return None
2018-09-23 15:26:20 -04:00
return vni
2018-09-23 15:26:20 -04:00
def getNetworkVNI(zk_conn, network):
# Validate and obtain alternate passed value
if network.isdigit():
net_description = searchClusterByVNI(zk_conn, network)
net_vni = searchClusterByDescription(zk_conn, net_description)
else:
net_vni = searchClusterByDescription(zk_conn, network)
net_description = searchClusterByVNI(zk_conn, net_vni)
2018-09-23 15:26:20 -04:00
return net_vni
2018-09-23 15:26:20 -04:00
def getNetworkDescription(zk_conn, network):
# Validate and obtain alternate passed value
2018-09-23 15:26:20 -04:00
if network.isdigit():
net_description = searchClusterByVNI(zk_conn, network)
net_vni = searchClusterByDescription(zk_conn, net_description)
else:
2018-09-23 15:26:20 -04:00
net_vni = searchClusterByDescription(zk_conn, network)
net_description = searchClusterByVNI(zk_conn, net_vni)
2018-09-23 15:26:20 -04:00
return net_description
def getNetworkDHCPLeases(zk_conn, vni):
# Get a list of DHCP leases by listing the children of /networks/<vni>/dhcp_leases
dhcp_leases = zk_conn.get_children('/networks/{}/dhcp_leases'.format(vni))
return sorted(dhcp_leases)
2018-09-23 15:26:20 -04:00
def getNetworkDHCPReservations(zk_conn, vni):
# Get a list of VNIs by listing the children of /networks/<vni>/dhcp_leases
2018-09-30 11:22:25 -04:00
dhcp_reservations = []
dhcp_leases = getNetworkDHCPLeases(zk_conn, vni)
2018-09-30 11:22:25 -04:00
for lease in dhcp_leases:
timestamp = zkhandler.readdata(zk_conn, '/networks/{}/dhcp_leases/{}'.format (vni, lease))
2018-09-30 11:22:25 -04:00
if timestamp == 'static':
dhcp_reservations.append(lease)
return sorted(dhcp_reservations)
2018-09-23 15:26:20 -04:00
def getNetworkFirewallRules(zk_conn, vni):
firewall_rules = zk_conn.get_children('/networks/{}/firewall_rules'.format(vni))
2018-09-23 15:26:20 -04:00
return None
2018-09-23 15:26:20 -04:00
def getNetworkInformation(zk_conn, vni):
description = zkhandler.readdata(zk_conn, '/networks/{}'.format(vni))
domain = zkhandler.readdata(zk_conn, '/networks/{}/domain'.format(vni))
ip_network = zkhandler.readdata(zk_conn, '/networks/{}/ip_network'.format(vni))
ip_gateway = zkhandler.readdata(zk_conn, '/networks/{}/ip_gateway'.format(vni))
dhcp_flag = zkhandler.readdata(zk_conn, '/networks/{}/dhcp_flag'.format(vni))
dhcp_start = zkhandler.readdata(zk_conn, '/networks/{}/dhcp_start'.format(vni))
dhcp_end = zkhandler.readdata(zk_conn, '/networks/{}/dhcp_end'.format(vni))
return description, domain, ip_network, ip_gateway, dhcp_flag, dhcp_start, dhcp_end
def getDHCPLeaseInformation(zk_conn, vni, mac_address):
hostname = zkhandler.readdata(zk_conn, '/networks/{}/dhcp_leases/{}/hostname'.format(vni, mac_address))
ip_address = zkhandler.readdata(zk_conn, '/networks/{}/dhcp_leases/{}/ipaddr'.format(vni, mac_address))
timestamp = zkhandler.readdata(zk_conn, '/networks/{}/dhcp_leases/{}'.format(vni, mac_address))
return hostname, ip_address, mac_address, timestamp
2018-09-23 15:26:20 -04:00
def formatNetworkInformation(zk_conn, vni, long_output):
description, domain, ip_network, ip_gateway, dhcp_flag, dhcp_start, dhcp_end = getNetworkInformation(zk_conn, vni)
if dhcp_flag == "True":
2018-09-25 13:58:52 -04:00
dhcp_flag_colour = ansiiprint.green()
else:
dhcp_flag_colour = ansiiprint.blue()
colour_off = ansiiprint.end()
2018-09-23 15:26:20 -04:00
# Format a nice output: do this line-by-line then concat the elements at the end
ainformation = []
ainformation.append('{}Virtual network information:{}'.format(ansiiprint.bold(), ansiiprint.end()))
ainformation.append('')
# Basic information
2018-09-29 02:56:36 -04:00
ainformation.append('{}VNI:{} {}'.format(ansiiprint.purple(), ansiiprint.end(), vni))
ainformation.append('{}Description:{} {}'.format(ansiiprint.purple(), ansiiprint.end(), description))
ainformation.append('{}Domain:{} {}'.format(ansiiprint.purple(), ansiiprint.end(), domain))
ainformation.append('{}IP network:{} {}'.format(ansiiprint.purple(), ansiiprint.end(), ip_network))
ainformation.append('{}IP gateway:{} {}'.format(ansiiprint.purple(), ansiiprint.end(), ip_gateway))
ainformation.append('{}DHCP enabled:{} {}{}{}'.format(ansiiprint.purple(), ansiiprint.end(), dhcp_flag_colour, dhcp_flag, colour_off))
if dhcp_flag == "True":
2018-09-29 02:56:36 -04:00
ainformation.append('{}DHCP range:{} {} - {}'.format(ansiiprint.purple(), ansiiprint.end(), dhcp_start, dhcp_end))
2018-09-23 15:26:20 -04:00
if long_output:
dhcp_reservations_list = getNetworkDHCPReservations(zk_conn, vni)
if dhcp_reservations_list:
2018-09-23 15:26:20 -04:00
ainformation.append('')
ainformation.append('{}Client DHCP reservations:{}'.format(ansiiprint.bold(), ansiiprint.end()))
ainformation.append('')
# Only show static reservations in the detailed information
dhcp_reservations_string = formatDHCPLeaseList(zk_conn, vni, dhcp_reservations_list)
for line in dhcp_reservations_string.split('\n'):
ainformation.append(line)
2018-09-30 11:22:25 -04:00
firewall_rules = zk_conn.get_children('/networks/{}/firewall_rules'.format(vni))
2018-09-23 15:26:20 -04:00
if firewall_rules:
ainformation.append('')
ainformation.append('{}Network firewall rules:{}'.format(ansiiprint.bold(), ansiiprint.end()))
ainformation.append('')
formatted_firewall_rules = get_list_firewall_rules(zk_conn, vni)
2018-09-23 15:26:20 -04:00
# Join it all together
information = '\n'.join(ainformation)
return information
def formatNetworkList(zk_conn, net_list):
net_list_output = []
description = {}
2018-09-28 20:42:24 -04:00
domain = {}
ip_network = {}
ip_gateway = {}
dhcp_flag = {}
dhcp_flag_colour = {}
dhcp_start = {}
dhcp_end = {}
dhcp_range = {}
colour_off = ansiiprint.end()
# Gather information for printing
for net in net_list:
# get info
description[net], domain[net], ip_network[net], ip_gateway[net], dhcp_flag[net], dhcp_start[net], dhcp_end[net] = getNetworkInformation(zk_conn, net)
if dhcp_flag[net] == "True":
dhcp_flag_colour[net] = ansiiprint.green()
dhcp_range[net] = '{} - {}'.format(dhcp_start[net], dhcp_end[net])
else:
dhcp_flag_colour[net] = ansiiprint.blue()
dhcp_range[net] = 'N/A'
# Determine optimal column widths
# Dynamic columns: node_name, hypervisor, migrated
net_vni_length = 5
net_description_length = 13
2018-09-28 20:42:24 -04:00
net_domain_length = 8
net_ip_network_length = 12
net_ip_gateway_length = 9
net_dhcp_range_length = 12
for net in net_list:
# vni column
_net_vni_length = len(net) + 1
if _net_vni_length > net_vni_length:
net_vni_length = _net_vni_length
# description column
_net_description_length = len(description[net]) + 1
if _net_description_length > net_description_length:
net_description_length = _net_description_length
2018-09-28 20:42:24 -04:00
# domain column
_net_domain_length = len(domain[net]) + 1
if _net_domain_length > net_domain_length:
net_domain_length = _net_domain_length
# ip_network column
_net_ip_network_length = len(ip_network[net]) + 1
if _net_ip_network_length > net_ip_network_length:
net_ip_network_length = _net_ip_network_length
# ip_gateway column
_net_ip_gateway_length = len(ip_gateway[net]) + 1
if _net_ip_gateway_length > net_ip_gateway_length:
net_ip_gateway_length = _net_ip_gateway_length
# dhcp_range column
_net_dhcp_range_length = len(dhcp_range[net]) + 1
if _net_dhcp_range_length > net_dhcp_range_length:
net_dhcp_range_length = _net_dhcp_range_length
# Format the string (header)
net_list_output_header = '{bold}\
{net_vni: <{net_vni_length}} \
{net_description: <{net_description_length}} \
2018-09-28 20:42:24 -04:00
{net_domain: <{net_domain_length}} \
{net_ip_network: <{net_ip_network_length}} \
{net_ip_gateway: <{net_ip_gateway_length}} \
{net_dhcp_flag: <6} \
{net_dhcp_range: <{net_dhcp_range_length}} \
{end_bold}'.format(
bold=ansiiprint.bold(),
end_bold=ansiiprint.end(),
net_vni_length=net_vni_length,
net_description_length=net_description_length,
2018-09-28 20:42:24 -04:00
net_domain_length=net_domain_length,
net_ip_network_length=net_ip_network_length,
net_ip_gateway_length=net_ip_gateway_length,
net_dhcp_range_length=net_dhcp_range_length,
net_vni='VNI',
net_description='Description',
2018-09-28 20:42:24 -04:00
net_domain='Domain',
net_ip_network='Network',
net_ip_gateway='Gateway',
net_dhcp_flag='DHCP',
net_dhcp_range='Range',
)
for net in net_list:
net_list_output.append(
'{bold}\
{net_vni: <{net_vni_length}} \
{net_description: <{net_description_length}} \
2018-09-28 20:42:24 -04:00
{net_domain: <{net_domain_length}} \
{net_ip_network: <{net_ip_network_length}} \
{net_ip_gateway: <{net_ip_gateway_length}} \
{dhcp_flag_colour}{net_dhcp_flag: <6}{colour_off} \
{net_dhcp_range: <{net_dhcp_range_length}} \
{end_bold}'.format(
bold='',
end_bold='',
net_vni_length=net_vni_length,
net_description_length=net_description_length,
2018-09-28 20:42:24 -04:00
net_domain_length=net_domain_length,
net_ip_network_length=net_ip_network_length,
net_ip_gateway_length=net_ip_gateway_length,
net_dhcp_range_length=net_dhcp_range_length,
net_vni=net,
net_description=description[net],
2018-09-28 20:42:24 -04:00
net_domain=domain[net],
net_ip_network=ip_network[net],
net_ip_gateway=ip_gateway[net],
net_dhcp_flag=dhcp_flag[net],
net_dhcp_range=dhcp_range[net],
dhcp_flag_colour=dhcp_flag_colour[net],
colour_off=colour_off
)
)
output_string = net_list_output_header + '\n' + '\n'.join(sorted(net_list_output))
return output_string
def formatDHCPLeaseList(zk_conn, vni, dhcp_leases_list):
dhcp_lease_list_output = []
hostname = {}
ip_address = {}
mac_address = {}
timestamp = {}
# Gather information for printing
for dhcp_lease in dhcp_leases_list:
# get info
hostname[dhcp_lease], ip_address[dhcp_lease], mac_address[dhcp_lease], timestamp[dhcp_lease] = getDHCPLeaseInformation(zk_conn, vni, dhcp_lease)
# Determine optimal column widths
lease_hostname_length = 13
lease_ip_address_length = 11
lease_mac_address_length = 13
for dhcp_lease in dhcp_leases_list:
# hostname column
_lease_hostname_length = len(hostname[dhcp_lease]) + 1
if _lease_hostname_length > lease_hostname_length:
lease_hostname_length = _lease_hostname_length
# ip_network column
_lease_ip_address_length = len(ip_address[dhcp_lease]) + 1
if _lease_ip_address_length > lease_ip_address_length:
lease_ip_address_length = _lease_ip_address_length
# ip_gateway column
_lease_mac_address_length = len(mac_address[dhcp_lease]) + 1
if _lease_mac_address_length > lease_mac_address_length:
lease_mac_address_length = _lease_mac_address_length
# Format the string (header)
dhcp_lease_list_output_header = '{bold}\
{lease_hostname: <{lease_hostname_length}} \
{lease_ip_address: <{lease_ip_address_length}} \
{lease_mac_address: <{lease_mac_address_length}} \
{lease_timestamp: <{lease_timestamp_length}} \
{end_bold}'.format(
bold=ansiiprint.bold(),
end_bold=ansiiprint.end(),
lease_hostname_length=lease_hostname_length,
lease_ip_address_length=lease_ip_address_length,
lease_mac_address_length=lease_mac_address_length,
lease_timestamp_length=12,
lease_hostname='Hostname',
lease_ip_address='IP Address',
lease_mac_address='MAC Address',
lease_timestamp='Timestamp'
)
for dhcp_lease in dhcp_leases_list:
dhcp_lease_list_output.append('{bold}\
{lease_hostname: <{lease_hostname_length}} \
{lease_ip_address: <{lease_ip_address_length}} \
{lease_mac_address: <{lease_mac_address_length}} \
{lease_timestamp: <{lease_timestamp_length}} \
{end_bold}'.format(
bold='',
end_bold='',
lease_hostname_length=lease_hostname_length,
lease_ip_address_length=lease_ip_address_length,
lease_mac_address_length=lease_mac_address_length,
lease_timestamp_length=12,
lease_hostname=hostname[dhcp_lease],
lease_ip_address=ip_address[dhcp_lease],
lease_mac_address=mac_address[dhcp_lease],
lease_timestamp=timestamp[dhcp_lease]
)
)
output_string = dhcp_lease_list_output_header + '\n' + '\n'.join(sorted(dhcp_lease_list_output))
return output_string
def isValidMAC(macaddr):
allowed = re.compile(r"""
(
^([0-9A-F]{2}[:]){5}([0-9A-F]{2})$
)
""",
re.VERBOSE|re.IGNORECASE)
if allowed.match(macaddr) is None:
return False
else:
return True
def isValidIP(ipaddr):
ip_blocks = str(ipaddr).split(".")
if len(ip_blocks) == 4:
for block in ip_blocks:
# Check if number is digit, if not checked before calling this function
if not block.isdigit():
return False
tmp = int(block)
if 0 > tmp > 255:
return False
return True
return False
2018-09-23 15:26:20 -04:00
#
# Direct functions
#
def add_network(zk_conn, vni, description, domain, ip_network, ip_gateway, dhcp_flag, dhcp_start, dhcp_end):
2018-09-23 15:26:20 -04:00
if description == '':
description = vni
if dhcp_flag and ( not dhcp_start or not dhcp_end ):
return False, 'ERROR: DHCP start and end addresses are required for a DHCP-enabled network.'
2018-09-23 15:26:20 -04:00
# Check if a network with this VNI already exists
if zk_conn.exists('/networks/{}'.format(vni)):
return False, 'ERROR: A network with VNI {} already exists!'.format(vni)
2018-09-23 15:26:20 -04:00
# Add the new network to Zookeeper
zkhandler.writedata(zk_conn, {
'/networks/{}'.format(vni): description,
'/networks/{}/domain'.format(vni): domain,
'/networks/{}/ip_network'.format(vni): ip_network,
'/networks/{}/ip_gateway'.format(vni): ip_gateway,
'/networks/{}/dhcp_flag'.format(vni): str(dhcp_flag),
'/networks/{}/dhcp_start'.format(vni): dhcp_start,
'/networks/{}/dhcp_end'.format(vni): dhcp_end,
'/networks/{}/dhcp_leases'.format(vni): '',
'/networks/{}/firewall_rules'.format(vni): ''
})
2018-09-23 15:26:20 -04:00
return True, 'Network "{}" added successfully!'.format(description)
2018-09-23 15:26:20 -04:00
def modify_network(zk_conn, vni, **parameters):
# Add the new network to Zookeeper
transaction = zk_conn.transaction()
zk_data = {}
2018-09-23 15:26:20 -04:00
if parameters['description'] != None:
zk_data.update({'/networks/{}'.format(vni): parameters['description']})
2018-09-23 15:26:20 -04:00
if parameters['ip_network'] != None:
zk_data.update({'/networks/{}/ip_network'.format(vni): parameters['ip_network']})
2018-09-23 15:26:20 -04:00
if parameters['ip_gateway'] != None:
zk_data.update({'/networks/{}/ip_gateway'.format(vni): parameters['ip_gateway']})
2018-09-23 15:26:20 -04:00
if parameters['dhcp_flag'] != None:
zk_data.update({'/networks/{}/dhcp_flag'.format(vni): str(parameters['dhcp_flag'])})
zkhandler.writedata(zk_conn, zk_data)
2018-09-23 15:26:20 -04:00
return True, 'Network "{}" modified successfully!'.format(vni)
2018-09-23 15:26:20 -04:00
def remove_network(zk_conn, network):
# Validate and obtain alternate passed value
2018-09-23 15:26:20 -04:00
vni = getNetworkVNI(zk_conn, network)
description = getNetworkDescription(zk_conn, network)
if not vni:
return False, 'ERROR: Could not find network "{}" in the cluster!'.format(network)
2018-09-23 15:26:20 -04:00
# Delete the configuration
try:
2018-09-23 15:26:20 -04:00
zk_conn.delete('/networks/{}'.format(vni), recursive=True)
except:
pass
2018-09-23 15:26:20 -04:00
return True, 'Network "{}" removed successfully!'.format(description)
def add_dhcp_reservation(zk_conn, network, ipaddress, macaddress, hostname):
# Validate and obtain standard passed value
net_vni = getNetworkVNI(zk_conn, network)
if net_vni == None:
return False, 'ERROR: Could not find network "{}" in the cluster!'.format(network)
2018-09-30 11:22:25 -04:00
# Use uppercase MAC format exclusively
macaddress = macaddress.upper()
if not isValidMAC(macaddress):
return False, 'ERROR: MAC address "{}" is not valid! Always use ":" as a separator.'.format(macaddress)
if not isValidIP(ipaddress):
return False, 'ERROR: IP address "{}" is not valid!'.format(macaddress)
2018-09-30 11:22:25 -04:00
if zk_conn.exists('/networks/{}/dhcp_leases/{}'.format(net_vni, macaddress)):
return False, 'ERROR: A reservation with MAC "{}" already exists!'.format(macaddress)
# Add the new static lease to ZK
try:
zkhandler.writedata(zk_conn, {
'/networks/{}/dhcp_leases/{}'.format(net_vni, macaddress): 'static',
'/networks/{}/dhcp_leases/{}/hostname'.format(net_vni, macaddress): hostname,
'/networks/{}/dhcp_leases/{}/ipaddr'.format(net_vni, macaddress): ipaddress
})
except Exception as e:
return False, 'ERROR: Failed to write to Zookeeper! Exception: "{}".'.format(e)
return True, 'DHCP reservation "{}" added successfully!'.format(macaddress)
def remove_dhcp_lease(zk_conn, network, lease):
# Validate and obtain standard passed value
net_vni = getNetworkVNI(zk_conn, network)
if net_vni == None:
return False, 'ERROR: Could not find network "{}" in the cluster!'.format(network)
match_description = ''
# Check if the reservation matches a description, a mac, or an IP address currently in the database
dhcp_leases_list = zk_conn.get_children('/networks/{}/dhcp_leases'.format(net_vni))
for macaddr in dhcp_leases_list:
hostname = zkhandler.readdata(zk_conn, '/networks/{}/dhcp_leases/{}/hostname'.format(net_vni, macaddr))
2018-09-30 11:22:25 -04:00
ipaddress = zkhandler.readdata(zk_conn, '/networks/{}/dhcp_leases/{}/ipaddr'.format(net_vni, macaddr))
if lease == macaddr or lease == hostname or lease == ipaddress:
2018-09-30 11:22:25 -04:00
match_description = macaddr
if not match_description:
return False, 'ERROR: No DHCP lease exists matching "{}"!'.format(reservation)
# Remove the entry from zookeeper
try:
2018-09-30 11:22:25 -04:00
zk_conn.delete('/networks/{}/dhcp_leases/{}'.format(net_vni, match_description), recursive=True)
except:
return False, 'ERROR: Failed to write to Zookeeper!'
return True, 'DHCP lease "{}" removed successfully!'.format(match_description)
def get_info(zk_conn, network, long_output):
# Validate and obtain alternate passed value
2018-09-23 15:26:20 -04:00
net_vni = getNetworkVNI(zk_conn, network)
if net_vni == None:
return False, 'ERROR: Could not find network "{}" in the cluster!'.format(network)
2018-09-25 01:32:52 -04:00
information = formatNetworkInformation(zk_conn, net_vni, long_output)
click.echo(information)
click.echo('')
2018-09-23 15:26:20 -04:00
return True, ''
def get_list(zk_conn, limit):
2018-09-25 01:47:29 -04:00
net_list = []
full_net_list = zk_conn.get_children('/networks')
2018-09-25 02:20:32 -04:00
2018-09-25 01:47:29 -04:00
for net in full_net_list:
description = zkhandler.readdata(zk_conn, '/networks/{}'.format(net))
if limit != None:
try:
2018-09-25 02:20:32 -04:00
# Implcitly assume fuzzy limits
if re.match('\^.*', limit) == None:
limit = '.*' + limit
if re.match('.*\$', limit) == None:
limit = limit + '.*'
if re.match(limit, net) != None:
net_list.append(net)
if re.match(limit, description) != None:
net_list.append(net)
2018-09-25 01:47:29 -04:00
except Exception as e:
return False, 'Regex Error: {}'.format(e)
2018-09-25 02:20:32 -04:00
else:
net_list.append(net)
output_string = formatNetworkList(zk_conn, net_list)
click.echo(output_string)
return True, ''
2018-09-25 13:58:52 -04:00
2018-10-02 00:14:08 -04:00
def get_list_dhcp_leases(zk_conn, network, limit, only_static=False):
# Validate and obtain alternate passed value
net_vni = getNetworkVNI(zk_conn, network)
if net_vni == None:
return False, 'ERROR: Could not find network "{}" in the cluster!'.format(network)
dhcp_leases_list = []
full_dhcp_leases_list = getNetworkDHCPLeases(zk_conn, net_vni)
if limit:
try:
# Implcitly assume fuzzy limits
if re.match('\^.*', limit) == None:
limit = '.*' + limit
if re.match('.*\$', limit) == None:
limit = limit + '.*'
except Exception as e:
return False, 'Regex Error: {}'.format(e)
for lease in full_dhcp_leases_list:
valid_lease = False
2018-10-02 00:14:08 -04:00
if only_static:
lease_timestamp = zkhandler.readdata(zk_conn, '/networks/{}/dhcp_leases/{}'.format(net_vni, lease))
if lease_timestamp == 'static':
if limit:
if re.match(limit, lease) != None:
valid_lease = True
if re.match(limit, lease) != None:
valid_lease = True
else:
valid_lease = True
else:
2018-10-02 00:14:08 -04:00
if limit:
if re.match(limit, lease) != None:
valid_lease = True
if re.match(limit, lease) != None:
valid_lease = True
else:
valid_lease = True
if valid_lease:
dhcp_leases_list.append(lease)
output_string = formatDHCPLeaseList(zk_conn, net_vni, dhcp_leases_list)
click.echo(output_string)
2018-09-23 15:26:20 -04:00
return True, ''
def get_list_firewall_rules(zk_conn, network):
# Validate and obtain alternate passed value
net_vni = getNetworkVNI(zk_conn, network)
if net_vni == None:
return False, 'ERROR: Could not find network "{}" in the cluster!'.format(network)
firewall_rules = getNetworkFirewallRules(zk_conn, net_vni)
return firewall_rules