def __init__(self, prefix, macaddr, gateway=None):
self.prefix = ipaddress.IPv4Interface(prefix)
self.macaddr = macaddr
self.gateway = gateway
return
def __init__(self, *args, **kwargs):
"""Instance initialization."""
deprecate(
"Warning!",
message="This DebianBox class is deprecated",
category=UserWarning,
)
self.args = args
self.kwargs = kwargs
name = kwargs.pop("name", None)
ipaddr = kwargs.pop("ipaddr", None)
color = kwargs.pop("color", "black")
username = kwargs.pop("username", "root")
password = kwargs.pop("password", "bigfoot1")
port = kwargs.pop("port", "22")
output = kwargs.pop("output", sys.stdout)
reboot = kwargs.pop("reboot", False)
location = kwargs.pop("location", None)
self.dev_array = kwargs.pop("dev_array", None)
pre_cmd_host = kwargs.pop("pre_cmd_host", None)
cmd = kwargs.pop("cmd", None)
post_cmd_host = kwargs.pop("post_cmd_host", None)
post_cmd = kwargs.pop("post_cmd", None)
cleanup_cmd = kwargs.pop("cleanup_cmd", None)
lan_network = ipaddress.IPv4Interface(
six.text_type(kwargs.pop("lan_network", "192.168.1.0/24"))).network
lan_gateway = ipaddress.IPv4Interface(
six.text_type(kwargs.pop("lan_gateway", "192.168.1.1/24"))).ip
self.http_proxy = kwargs.pop("http_proxy", ipaddr + ":8080")
if pre_cmd_host is not None:
sys.stdout.write("\tRunning pre_cmd_host.... ")
sys.stdout.flush()
phc = bft_pexpect_helper.spawn(command="bash",
args=["-c", pre_cmd_host],
env=self.dev.env)
phc.expect(pexpect.EOF, timeout=120)
print("\tpre_cmd_host done")
self.legacy_add = False
# introducing a hack till json schema does not get updated
if not self.dev_array:
self.legacy_add = True
arr_names = {"lan": "lan_clients", "wan": "wan_clients"}
for k, v in arr_names.items():
if k in name:
self.dev_array = v
if ipaddr is not None:
bft_pexpect_helper.spawn.__init__(
self,
command="ssh",
args=[
"%s@%s" % (username, ipaddr),
"-p",
port,
"-o",
"StrictHostKeyChecking=no",
"-o",
"UserKnownHostsFile=/dev/null",
"-o",
"ServerAliveInterval=60",
"-o",
"ServerAliveCountMax=5",
],
)
self.ipaddr = ipaddr
if cleanup_cmd is not None:
self.cleanup_cmd = cleanup_cmd
atexit.register(self.run_cleanup_cmd)
if cmd is not None:
sys.stdout.write("\tRunning cmd.... ")
sys.stdout.flush()
bft_pexpect_helper.spawn.__init__(self,
command="bash",
args=["-c", cmd],
env=self.dev.env)
self.ipaddr = None
print("\tcmd done")
self.name = name
self.color = color
self.output = output
self.username = username
if username != "root":
self.prompt.append("%s\\@.*:.*$" % username)
self.password = password
self.port = port
self.location = location
self.lan_network = lan_network
self.lan_gateway = lan_gateway
self.tftp_device = self
self.dante = False
self.check_connection(username, name, password)
# attempts to fix the cli columns size
self.set_cli_size(200)
# we need to pick a non-conflicting private network here
# also we want it to be consistent and not random for a particular
# board
if self.gw is None:
if (lan_gateway - lan_network.num_addresses).is_private:
self.gw = lan_gateway - lan_network.num_addresses
else:
self.gw = lan_gateway + lan_network.num_addresses
self.gw_ng = ipaddress.IPv4Interface(
six.text_type(str(self.gw) + "/" + str(lan_network.prefixlen)))
self.nw = self.gw_ng.network
self.gw_prefixlen = self.nw.prefixlen
# override above values if set in wan options
if "options" in kwargs:
options = [x.strip() for x in kwargs["options"].split(",")]
for opt in options:
if opt.startswith("wan-static-ip:"):
value = six.text_type(opt.replace("wan-static-ip:", ""))
if "/" not in value:
value = value + (u"/24")
self.gw_ng = ipaddress.IPv4Interface(value)
self.nw = self.gw_ng.network
self.gw_prefixlen = self.nw._prefixlen
self.gw = self.gw_ng.ip
self.static_ip = True
if opt.startswith("wan-static-ipv6:"):
ipv6_address = six.text_type(
opt.replace("wan-static-ipv6:", ""))
if "/" not in opt:
ipv6_address += "/%s" % six.text_type(
str(self.ipv6_prefix))
self.ipv6_interface = ipaddress.IPv6Interface(ipv6_address)
self.ipv6_prefix = self.ipv6_interface._prefixlen
self.gwv6 = self.ipv6_interface.ip
if opt.startswith("wan-static-route:"):
self.static_route = opt.replace("wan-static-route:",
"").replace("-", " via ")
# TODO: remove wan-static-route at some point above
if opt.startswith("static-route:"):
self.static_route = opt.replace("static-route:",
"").replace("-", " via ")
if opt == "wan-dhcp-client":
self.wan_dhcp = True
if opt == "wan-no-eth0":
self.wan_no_eth0 = True
if opt == "wan-no-dhcp-server":
self.wan_dhcp_server = False
if opt == "wan-dhcp-client-v6":
self.wan_dhcpv6 = True
if opt.startswith("mgmt-dns:"):
value = six.text_type(opt.replace("mgmt-dns:", ""))
self.mgmt_dns = ipaddress.IPv4Interface(value).ip
else:
self.mgmt_dns = "8.8.8.8"
if opt == "dante":
self.dante = True
if ipaddr is None:
self.sendline("hostname")
self.expect("hostname")
self.expect(self.prompt)
ipaddr = self.ipaddr = self.before.strip()
self.print_connected_console_msg(ipaddr, port, color, name)
if post_cmd_host is not None:
sys.stdout.write("\tRunning post_cmd_host.... ")
sys.stdout.flush()
phc = bft_pexpect_helper.spawn(command="bash",
args=["-c", post_cmd_host],
env=self.dev.env)
i = phc.expect([pexpect.EOF, pexpect.TIMEOUT, "password"])
if i > 0:
print("\tpost_cmd_host did not complete, it likely failed\n")
else:
print("\tpost_cmd_host done")
if post_cmd is not None:
sys.stdout.write("\tRunning post_cmd.... ")
sys.stdout.flush()
env_prefix = ""
for k, v in self.dev.env.items():
env_prefix += "export %s=%s; " % (k, v)
self.sendline(env_prefix + post_cmd)
self.expect(self.prompt)
print("\tpost_cmd done")
if reboot:
self.reset()
self.logfile_read = output
def unformat_api_ip4_address_with_prefix_t(o):
return ipaddress.IPv4Interface((o.address, o.len))
def run(self, params, args):
networks = []
for row in self.call('list.network', [ 'dns=true' ]):
networks.append(row)
local_conf = pathlib.Path('/opt/stack/share/templates/named.conf.j2')
if local_conf.is_file():
template_file = jinja2.Template(local_conf.read_text(), lstrip_blocks=True, trim_blocks=True)
else:
raise CommandError(self, 'Unable to parse template file: /opt/stack/share/templates/named.conf.j2')
s = '<stack:file stack:name="/etc/named.conf" stack:perms="0644">\n'
template_vars = {'edit_warning': stack.text.DoNotEdit()}
acl = ['127.0.0.0/24']
for network in networks:
acl.append(str(ipaddress.IPv4Interface(f"{network['address']}/{network['mask']}")))
template_vars['acl_list'] = acl
fwds = self.getAttr('Kickstart_PublicDNSServers')
if fwds is None:
#
# in the case of only one interface on the frontend,
# then Kickstart_PublicDNSServers will not be
# defined and Kickstart_PrivateDNSServers will have
# the correct DNS servers
#
fwds = self.getAttr('Kickstart_PrivateDNSServers')
if fwds is not None:
fwds = fwds.strip()
if fwds:
template_vars['forwarders'] = ';'.join(fwds.split(','))
if self.os == 'redhat':
template_vars.update({
'directory': '/var/named',
'dumpfile': '/var/named/data/cache_dump.db',
'statfile': '/var/named/data/named_stats.txt',
'hintfile': 'named.ca',
'localzone': 'named.localhost',
'loopzone': 'named.local',
})
elif self.os == 'sles':
template_vars.update({
'directory': '/var/lib/named',
'dumpfile': '/var/log/named_dump.db',
'statfile': '/var/log/named.stats',
'hintfile': 'root.hint',
'localzone': 'localhost.zone',
'loopzone': '127.0.0.zone',
})
# Generate the Forward Lookups
fw_zones = []
for network in networks:
fw_zones.append({'name': network["network"], 'zone': network["zone"]})
template_vars['fwzones'] = fw_zones
# Generate the reverse lookups
# For every network, get the base subnet,
# and reverse it. This is the format
# that named understands
rev_zones = []
z = {}
for network in networks:
sn = self.getSubnet(network['address'], network['mask'])
sn.reverse()
r_sn = '.'.join(sn)
if not r_sn in z:
z[r_sn] = []
z[r_sn].append(network)
for zone in z:
if len(z[zone]) == 1:
name = z[zone][0]["network"]
comment_name = name
else:
n = '.'.join(list(map(lambda x: x["network"], z[zone]))).encode()
name = hex(zlib.crc32(n) & 0xffffffff)[2:]
comment_name = "networks - %s" % ','.join(list(map(lambda x: x["network"], z[zone])))
rev_zones.append({'name': name, 'zone': zone, 'comment_name': comment_name})
template_vars['revzones'] = rev_zones
# Check if there are local modifications to named.conf
local_conf = pathlib.Path('/etc/named.conf.local')
if local_conf.is_file():
template_vars['local_conf'] = local_conf.read_text()
s += template_file.render(template_vars)
s += '</stack:file>\n'
self.beginOutput()
self.addOutput('', s)
self.endOutput(padChar='')
def get_kubernetes_service_ip():
'''Get the IP address for the kubernetes service based on the cidr.'''
interface = ipaddress.IPv4Interface(service_cidr())
# Add .1 at the end of the network
ip = interface.network.network_address + 1
return ip.exploded
def ipv4(self):
return ipaddress.IPv4Interface(self.get_metadata("ipv4"))
def jvision_init(self, **kwargs):
"""
Initialize keyword for Jvision Server. The parameters are
device, interface, server_ip_address, dut_ip_address
decoder_path, decoder_port
Usage:
jvision init device=<server handle> interface=<Interface of server facing DUT>
server_ip_address=<server ip address> dut_ip_address=<dut ip address>
decoder_path=<location of decoder> decoder_port=<decoder part> mgmt_ip=<flag for mgmt_ip>
Example :
jvision init device=${h0} interface=eth1
server_ip_address=1.1.1.1/24 dut_ip_address=1.1.1.2/24
decoder_path= grpc=/opt/jvision/grpc/oc/ decoder_port=4321 mgmt_ip=False
"""
if not kwargs.get('device') or not kwargs.get('interface') \
or not kwargs.get('server_ip_address') or not kwargs.get('dut_ip_address'):
t.log(level='ERROR',
message='missing mandatory server '
'or interface or server ip address or dut ip address')
raise ValueError(
"server & dut information are mandatory arguments")
count = 5
server = kwargs.get('device')
interface = kwargs.get('interface')
if kwargs.get('mgmt_ip'):
mgmt_ip = ast.literal_eval(kwargs.get('mgmt_ip'))
else:
mgmt_ip = False
self.server_ip_address = kwargs.get('server_ip_address')
self.dut_ip_address = kwargs.get('dut_ip_address')
if not server.su():
raise ValueError("cannot login to server as root user")
if mgmt_ip == False:
try:
t.log(level='INFO',
message='configuring IP address on interface facing DUT')
server.shell(command="ifconfig %s 0" % interface + '\n')
server.shell(command='ifconfig ' + interface + ' ' +
self.server_ip_address + '\n')
t.log(level='INFO',
message='verify IP address configuration on interface')
response = server.shell(command="ifconfig %s" % interface +
'\n')
server_ip = str(ipaddress.IPv4Interface(
self.server_ip_address)).split("/")
match = re.search(
'inet' + '.*' + server_ip[0] + '.*' + 'Mask:',
response.response())
if match:
t.log(
level='INFO',
message="Server IP address is configured successfully")
else:
t.log(level='ERROR',
message=
"Server IP address is not configured successfully")
t.log(level='INFO', message='configuring static route to DUT')
dut_network = str(
ipaddress.IPv4Network(
self.dut_ip_address,
strict=False).with_netmask).split("/")
dut_ip = str(ipaddress.IPv4Interface(
self.dut_ip_address)).split("/")
server.shell(command='route add -net ' + dut_network[0] + ' ' +
'netmask' + ' ' + dut_network[1] + ' ' + 'dev' +
' ' + interface + '\n')
response = server.shell(command="netstat -nr" + '\n')
match = re.search(
dut_network[0] + '.*' + dut_network[1] + '.*',
response.response())
if match:
t.log(level='INFO',
message="Route to DUT is configured successfully")
else:
t.log(
level='ERROR',
message="Route to DUT is not configured successfully")
except:
t.log(level='ERROR', message='shell command execution failed')
raise ValueError(
"cannot configure IP address and route on server")
dut_ip = str(ipaddress.IPv4Interface(self.dut_ip_address)).split("/")
t.log(level='INFO', message='Verify if DUT is reachable')
response = server.shell(
command=('ping ' + dut_ip[0] + ' ' + '-c' + ' ' + str(count)) +
'\n')
match = re.search(
str(count) + ' ' + 'packets transmitted,' + ' ' + str(count) +
' ' + 'received,' + ' ' + '0% packet loss', response.response())
if match:
t.log(level='INFO', message="Ping successful to DUT")
else:
t.log(level='ERROR', message="Ping unsuccessful to DUT")
if not kwargs.get('decoder_path'):
t.log(level='ERROR', message='missing mandatory params')
raise ValueError("missing mandatory params")
if not isinstance(kwargs.get('decoder_port'), dict) and \
isinstance(kwargs.get('decoder_path'), dict):
t.log(level='ERROR', message='params must be dictionary')
raise TypeError("params must be dictionary")
else:
if kwargs.get('decoder_path').get('grpc'):
self.decoder_path['grpc'] = str(
kwargs.get('decoder_path')['grpc'])
self.decoder_port['grpc'] = int(
kwargs.get('decoder_port')['grpc'])
if kwargs.get('decoder_path').get('udp'):
self.decoder_path['udp'] = str(
kwargs.get('decoder_path')['udp'])
self.decoder_port['udp'] = int(
kwargs.get('decoder_port')['udp'])
if kwargs.get('decoder_path').get('gnmi'):
self.decoder_path['gnmi'] = str(
kwargs.get('decoder_path')['gnmi'])
self.decoder_port['gnmi'] = int(
kwargs.get('decoder_port')['gnmi'])
if kwargs.get('decoder_path').get('gnmi-dialout'):
self.decoder_path['gnmi-dialout'] = str(
kwargs.get('decoder_path')['gnmi-dialout'])
self.decoder_port['gnmi-dialout'] = int(
kwargs.get('decoder_port')['gnmi-dialout'])
self.jv_db_server = kwargs.get('db_server', None)
def interface_lookup(ip_address, interfaces, routes):
ip_address = ipaddress.ip_address(ip_address)
interface_networks = {}
matching_interfaces = {}
selected_interface = ""
route_networks = {}
matching_routes = {}
selected_route = ""
# lookup interface subnets
## build dictionary of all interface networks
for interface, attributes in interfaces.items():
if attributes["ipv4_config"]:
for ipv4_config in attributes["ipv4_config"]:
interface_networks[interface] = ipaddress.IPv4Interface(
ipv4_config["ip_address"] + "/" + ipv4_config["mask"])
## check if ip address matches any interface networks
for interface, network in interface_networks.items():
if ip_address in network.network:
matching_interfaces[interface] = network
## if multiple matching interfaces find the most specific
if len(matching_interfaces) == 1:
selected_interface = list(matching_interfaces)[0]
elif len(matching_interfaces) > 1:
for interface, network in matching_interfaces.items():
if selected_interface:
if network.network.netmask > selected_interface_network.network.netmask:
selected_interface = interface
selected_interface_network = network
else:
selected_interface = interface
selected_interface_network = network
else:
selected_interface = ""
## return if an interface selected
if selected_interface:
return selected_interface
# lookup routes if no interface found
## build dictionary of all routes
for id, route in enumerate(routes):
route_networks[id] = ipaddress.IPv4Network(route["network"] + "/" +
route["mask"])
## check if ip address matches any routes
for id, route in route_networks.items():
if ip_address in route:
matching_routes[id] = route
## if multiple matching routes find the most specific
if len(matching_routes) == 1:
selected_route = list(matching_routes)[0]
elif len(matching_routes) > 1:
for id, route in matching_routes.items():
if selected_route:
if route.netmask > selected_route_network.netmask:
selected_route = id
selected_route_network = route
else:
selected_route = id
selected_route_network = route
else:
selected_route = ""
## resolve interface if a route selected
if str(selected_route):
selected_interface = routes[selected_route]["interface"]
## return if an interface selected
if selected_interface:
return selected_interface
else:
return ""
#!/usr/bin/env python3
import json
import requests
import ipaddress
import sys
aws_ip_url = 'https://ip-ranges.amazonaws.com/ip-ranges.json'
try:
ip = sys.argv[1]
except IndexError:
raise SystemExit(f"Usage: {sys.argv[0]} <ip address to check>")
try:
ip_ranges = requests.get(aws_ip_url, timeout=30).json()['prefixes']
except requests.exceptions.HTTPError as errh:
raise SystemExit(errh)
except requests.exceptions.ConnectionError as errc:
raise SystemExit(errc)
except requests.exceptions.Timeout as errt:
raise SystemExit(errt)
except requests.exceptions.RequestException as err:
raise SystemExit(err)
for net in ip_ranges:
if ipaddress.IPv4Interface(ip) in ipaddress.IPv4Network(net["ip_prefix"]):
print(json.dumps(net, indent=1))
partitionName = "test-partition"
# some lists for passed/failed test info
TESTS_PASSED = []
TESTS_FAILED = []
configChecks = ConfigChecks()
staticIPsChecks = ConfigChecks('/usr/local/etc/tredly/static-ips.conf')
sshChecks = ConfigChecks('/etc/ssh/sshd_config', ' ')
unboundChecks = ConfigChecks('/usr/local/etc/unbound/unbound.conf', ': ')
rcConfChecks = ConfigChecks('/etc/rc.conf', '=')
containerNetworkInterface = 'bridge1'
containerNetworkIP = '10.0.0.0'
containerNetworkCIDR = '16'
containerNetwork = ipaddress.IPv4Interface(containerNetworkIP + '/' +
containerNetworkCIDR)
containerNetworkNetmask = str(containerNetwork.with_netmask).split('/', 1)[-1]
e_header("Running container subnet change test")
# modify the container subnet
cmd = [
'tredly', 'config', 'container', 'subnet',
str(containerNetwork.network)
]
process = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
stdOut, stdErr = process.communicate()
stdOutString = stdOut.decode("utf-8", "replace")
stdErrString = stdErr.decode('utf-8', 'replace')
print(stdOutString)
# get the interface for the bridge
def ext_pillar(minion_id, pillar, *args, **kwargs):
"""
Query NetBox API for minion data
"""
if minion_id == "*":
log.info("There's no data to collect from NetBox for the Master")
return {}
# Pull settings from kwargs
api_url = kwargs["api_url"].rstrip("/")
api_token = kwargs.get("api_token")
site_details = kwargs.get("site_details", True)
site_prefixes = kwargs.get("site_prefixes", True)
proxy_username = kwargs.get("proxy_username", None)
proxy_return = kwargs.get("proxy_return", True)
ret = {}
# Fetch device from API
headers = {}
if api_token:
headers = {"Authorization": f"Token {api_token}"}
device_search_url = "{api_url}/{app}/{endpoint}".format(
api_url=api_url, app="dcim", endpoint="devices"
)
device_search_results = salt.utils.http.query(
device_search_url, params={"name": minion_id}, header_dict=headers, decode=True
)
search_results = device_search_results
if len(search_results["dict"]["results"]) == 0:
vm_search_url = "{api_url}/{app}/{endpoint}".format(
api_url=api_url, app="virtualization", endpoint="virtual-machines"
)
vm_search_results = salt.utils.http.query(
vm_search_url, params={"name": minion_id}, header_dict=headers, decode=True
)
search_results = vm_search_results
# Check status code for API call
if "error" in search_results:
log.error(
f'API query failed for "{minion_id}", status code: {search_results["status"]}'
)
log.error(search_results["error"])
return ret
# Assign results from API call to "netbox" key
if len(search_results["dict"]["results"]) == 0:
log.error(f'No device found for "{minion_id}"')
return ret
if len(search_results["dict"]["results"]) > 1:
log.error(f'More than one device found for "{minion_id}"')
return ret
if "vcpus" not in search_results["dict"]["results"][0]:
device_url = "{api_url}/{app}/{endpoint}/{id}/".format(
api_url=api_url,
app="dcim",
endpoint="devices",
id=search_results["dict"]["results"][0]["id"],
)
device_results = salt.utils.http.query(
device_url, header_dict=headers, decode=True
)
else:
device_url = "{api_url}/{app}/{endpoint}/{id}/".format(
api_url=api_url,
app="virtualization",
endpoint="virtual-machines",
id=search_results["dict"]["results"][0]["id"],
)
device_results = salt.utils.http.query(
device_url, header_dict=headers, decode=True
)
if "error" in device_results:
log.error(
f'API query failed for "{minion_id}", status code: {search_results["status"]}'
)
log.error(search_results["error"])
return ret
ret["netbox"] = device_results["dict"]
site_id = 0
site_name = ""
if not ret["netbox"]["site"]:
# eg virtual maschine in multi-site cluster
site_details = False
site_prefixes = False
else:
site_id = ret["netbox"]["site"]["id"]
site_name = ret["netbox"]["site"]["name"]
service_url = "{api_url}/{app}/{endpoint}".format(
api_url=api_url, app="ipam", endpoint="services"
)
service_results = salt.utils.http.query(
service_url, header_dict=headers, decode=True
)
services = service_results["dict"]["results"]
if len(services) >= 1:
ret["netbox"]["services"] = {}
for service in services:
ret["netbox"]["services"][service["name"]] = service
query_param = "device_id"
app = "dcim"
if "vcpus" in ret["netbox"]:
app = "virtualization"
query_param = "virtual_machine_id"
ret["netbox"]["interfaces"] = {}
interface_url = "{api_url}/{app}/{endpoint}/".format(
api_url=api_url, app=app, endpoint="interfaces"
)
interface_results = salt.utils.http.query(
interface_url,
params={query_param: search_results["dict"]["results"][0]["id"], "limit": 1000},
header_dict=headers,
decode=True,
)
if "error" in interface_results:
log.error(
f'API query failed for "{minion_id}", status code: {interface_results["status"]}'
)
log.error(interface_results["error"])
return ret
else:
for interface in interface_results["dict"]["results"]:
ret["netbox"]["interfaces"][interface["name"]] = interface
ret["netbox"]["interfaces"][interface["name"]]["ipaddresses"] = []
if "vcpus" in ret["netbox"]:
query_param = "virtual_machine_id"
ipaddress_url = "{api_url}/{app}/{endpoint}/".format(
api_url=api_url, app="ipam", endpoint="ip-addresses"
)
ipaddress_results = salt.utils.http.query(
ipaddress_url,
params={query_param: search_results["dict"]["results"][0]["id"]},
header_dict=headers,
decode=True,
)
if "error" in ipaddress_results:
log.error(
f'API query failed for "{minion_id}", status code: {ipaddress_results["status"]}'
)
log.error(ipaddress_results["error"])
return ret
ipaddresses = ipaddress_results["dict"]["results"]
## Get all interfaces for device
for ipaddress in ipaddresses:
interface_id = ipaddress["assigned_object_id"]
app = "dcim"
if "vcpus" in ret["netbox"]:
app = "virtualization"
interface_url = "{api_url}/{app}/{endpoint}/{id}/".format(
api_url=api_url, app=app, endpoint="interfaces", id=interface_id
)
interface_results = salt.utils.http.query(
interface_url, header_dict=headers, decode=True
)
if "error" in interface_results:
log.error(
f'API query failed for "{minion_id}", status code: {interface_results["status"]}'
)
log.error(interface_results["error"])
return ret
if interface_results["dict"]["name"] not in ret["netbox"]["interfaces"]:
ret["netbox"]["interfaces"][
interface_results["dict"]["name"]
] = interface_results["dict"]
if (
"ipaddresses"
not in ret["netbox"]["interfaces"][interface_results["dict"]["name"]]
):
ret["netbox"]["interfaces"][interface_results["dict"]["name"]][
"ipaddresses"
] = []
ret["netbox"]["interfaces"][interface_results["dict"]["name"]][
"ipaddresses"
].append(ipaddress)
if site_details:
log.debug(
f'Retrieving site details for "{minion_id}" - site {site_name} (ID {site_id})'
)
site_url = "{api_url}/{app}/{endpoint}/{site_id}/".format(
api_url=api_url, app="dcim", endpoint="sites", site_id=site_id
)
site_details_ret = salt.utils.http.query(
site_url, header_dict=headers, decode=True
)
if "error" in site_details_ret:
log.error(f"Unable to retrieve site details for {site_name} (ID {site_id})")
log.error(
f'Status code: {site_details_ret["status"]}, error: {site_details_ret["error"]}'
)
else:
ret["netbox"]["site"] = site_details_ret["dict"]
if site_prefixes:
log.debug(
f'Retrieving site prefixes for "{minion_id}" - site {site_name} (ID {site_id})'
)
prefixes_url = "{api_url}/{app}/{endpoint}".format(
api_url=api_url, app="ipam", endpoint="prefixes"
)
site_prefixes_ret = salt.utils.http.query(
prefixes_url, params={"site_id": site_id}, header_dict=headers, decode=True
)
if "error" in site_prefixes_ret:
log.error(
f"Unable to retrieve site prefixes for {site_name} (ID {site_id})"
)
log.error(
f'Status code: {site_prefixes_ret["status"]}, error: {site_prefixes_ret["error"]}'
)
else:
ret["netbox"]["site"]["prefixes"] = site_prefixes_ret["dict"]["results"]
if proxy_return:
# Attempt to add "proxy" key, based on platform API call
try:
# Fetch device from API
platform_results = salt.utils.http.query(
ret["netbox"]["platform"]["url"], header_dict=headers, decode=True
)
# Check status code for API call
if "error" in platform_results:
log.info(
f'API query failed for "{minion_id}": {platform_results["error"]}'
)
# Assign results from API call to "proxy" key if the platform has a
# napalm_driver defined.
napalm_driver = platform_results["dict"].get("napalm_driver")
if napalm_driver:
ret["proxy"] = {
"host": str(
ipaddress.IPv4Interface(
ret["netbox"]["primary_ip4"]["address"]
).ip
),
"driver": napalm_driver,
"proxytype": "napalm",
}
if proxy_username:
ret["proxy"]["username"] = proxy_username
except Exception:
log.debug(f'Could not create proxy config data for "{minion_id}"')
tag_list = []
for tag in ret["netbox"]["tags"]:
tag_list.append(tag["slug"])
ret["netbox"]["tag_list"] = tag_list
return ret
print(ip_list2)
#Main
for i in range(len(ip_list2)):
ipf = 0
ip = ip_list2[i]
date_list = []
ping_list = []
#print (ip)
length = len(data)
for index,column in df.iterrows() :
#print(list)
if ip == str(ipaddress.IPv4Interface(column["ipv4"]).network):
date_list.append(column["date"])
ping_list.append(column["ping"])
#print(date_list)
#print(ping_list)
ipf = func3(ip,date_list,ping_list,n,ipf)
print()
func4(ip,date_list,ping_list,m,t,ipf)
def func3(ip,date_list,ping_list,n,ipf):
#故障状態算出プログラム
f = 0
time1 = datetime.datetime.now()
time2 = datetime.datetime.now()
def addIPv4Address (self, value): self._v4addresses.append(ipaddress.IPv4Interface(unicode(value)))
def __init__(self, prefix):
self.prefix = ipaddress.IPv4Interface(prefix)
# new_mask = u'0.0.0.255'
new_mask = new.hostmask
new_mask_bin = struct.unpack("!L", new_mask.packed)[0]
new_netip_bin = struct.unpack("!L", new_netip.packed)[0]
# because origin ip address does not provide mask info
# 0.0.0.5 = 172.30.1.5 & 0.0.0.255
org_hostonly_bin = org_ip_bin & new_mask_bin
# 172.30.2.5 = 172.30.2.0 | 0.0.0.5
new_ip_bin = new_netip_bin | org_hostonly_bin
new_ip = socket.inet_ntoa(struct.pack("!L", new_ip_bin))
new_prefix = new.network.prefixlen
new_addr = new_ip + '/' + str(new_prefix)
return new_addr
if __name__ == '__main__':
org_addr = unicode(sys.argv[1])
new_netrange = unicode(sys.argv[2])
new = ipaddress.IPv4Interface(new_netrange)
if new.network.prefixlen == 32:
sys.exit(1)
new_addr = generate_new_addr(org_addr, new_netrange)
# 172.30.10.81/24
print new_addr
add action=drop chain=wan_fwdin comment="Drop all packets from public internet which should not exist in public network" src-address-list=RFC6890
add action=accept chain=wan_fwdin comment="Allow dst-natted packets" connection-nat-state=dstnat
add action=drop chain=wan_fwdout comment="Drop all packets from local network to internet which should not exist in public network" dst-address-list=RFC6890
add action=accept chain=wan_fwdout comment="Allow all other connections"
}""")
lans = [ x.strip() for x in config["DEFAULT"]["LanInterfaces"].split(",") ]
lan_networks = [ ipaddress.ip_network(x.strip()) for x in config["DEFAULT"]["LanNetworks"].split(",")]
wans = list()
for wan in [ x.strip() for x in config["DEFAULT"]["WanInterfaces"].split(",") ]:
if config.has_section(wan):
wans.append({
"interface": config[wan]["interface"],
"ip": ipaddress.IPv4Interface(config[wan]["ip"]),
"gateway": config[wan]["gateway"],
"monitor": config[wan]["link monitor"],
"weight": int(config[wan]["weight"])
})
# calculate weights
weight_sum = 0
for wan in wans:
if "weight" in wan:
weight_sum += wan["weight"]
else:
weight_sum += 1
# interface lists
def network(address):
return str(ipa.IPv4Interface(address).network)
def __call__(self, form, field):
try:
ip = ipaddress.IPv4Interface(f'192.168.0.1/{field.data}')
except ipaddress.NetmaskValueError:
raise ValidationError(self.message)
for each_device in cfg_devices:
print("Device: " + each_device['name'] + " - SN: " + each_device['serial'] + " ip-device: "+ each_device['primary_ip']['address'])
try:
nb_import[each_device['serial']]
except:
nb_import[each_device['serial']]=dict()
# MAC
mac = macs[each_device.get('name')]
if mac != 'None' and mac is not None:
nb_import[each_device['serial']]['mac'] = mac
#Hostname
nb_import[each_device['serial']]['hostname'] = each_device['name']
# IP + Mask
nb_import[each_device['serial']]['ip'] = str(ipaddress.IPv4Interface(each_device['primary_ip']['address']).ip)
nb_import[each_device['serial']]['subnet_mask'] = str(ipaddress.IPv4Interface(each_device['primary_ip']['address']).netmask)
# Router / Geteway
device_network = ipaddress.ip_interface(each_device['primary_ip']['address']).network
if valid_ip(nb_cfg['config']['router']):
nb_import[each_device['serial']]['router'] = nb_cfg['config']['router']
elif nb_cfg['config']['router'] == -1:
gw = ipaddress.IPv4Network(device_network)[-2]
nb_import[each_device['serial']]['router'] = str(gw)
else:
gw = ipaddress.IPv4Network(device_network)[1]
nb_import[each_device['serial']]['router'] = str(gw)
# Domain
if nb_cfg['config'].get('domain') is not None:
def returnNetworkZone(inputIP): #Input should be 192.168.0.1/24
if (isinstance(inputIP, str)):
ip = ipaddress.IPv4Interface(inputIP)
output = str(ip.network)
return output
def get_dns_ip():
'''Get an IP address for the DNS server on the provided cidr.'''
interface = ipaddress.IPv4Interface(service_cidr())
# Add .10 at the end of the network
ip = interface.network.network_address + 10
return ip.exploded
def _parse_to_from(linedata, direction, rule_obj=None):
if rule_obj is None:
rule_obj = {}
# pull out rule index, if they exist: [ 1]
if direction == 'to':
RE_LINE_NUM = re.compile(r'\[[ 0-9]+\]\s')
line_number_match = re.search(RE_LINE_NUM, linedata)
if line_number_match:
rule_obj['index'] = line_number_match.group(0).replace('[', '').replace(']', '').strip()
linedata = re.sub(RE_LINE_NUM, '', linedata)
else:
rule_obj['index'] = None
# pull out comments, if they exist
if direction == 'from':
RE_COMMENT = re.compile(r'#.+$')
comment_match = re.search(RE_COMMENT, linedata)
if comment_match:
rule_obj['comment'] = comment_match.group(0).lstrip('#').strip()
linedata = re.sub(RE_COMMENT, '', linedata)
else:
rule_obj['comment'] = None
# pull (v6)
RE_V6 = re.compile(r'\(v6\)')
v6_match = re.search(RE_V6, linedata)
if v6_match:
rule_obj['network_protocol'] = 'ipv6'
linedata = re.sub(RE_V6, '', linedata)
elif not rule_obj.get('network_protocol'):
rule_obj['network_protocol'] = 'ipv4'
# pull 'Anywhere' if exists. Assign to 0.0.0.0/0 or ::/0 depending on if (v6) is found
if 'Anywhere' in linedata:
if rule_obj.get('network_protocol') == 'ipv6':
rule_obj[direction + '_ip'] = '::'
rule_obj[direction + '_ip_prefix'] = '0'
elif rule_obj.get('network_protocol') == 'ipv4':
rule_obj[direction + '_ip'] = '0.0.0.0'
rule_obj[direction + '_ip_prefix'] = '0'
linedata = linedata.replace('Anywhere', '')
# pull out interface (after 'on')
linedata_list = linedata.split(' on ', maxsplit=1)
if len(linedata_list) > 1:
rule_obj[direction + '_interface'] = linedata_list[1].strip()
linedata = linedata_list[0]
else:
rule_obj[direction + '_interface'] = 'any'
# pull tcp/udp/etc. transport - strip on '/'
linedata_list = linedata.rsplit('/', maxsplit=1)
if len(linedata_list) > 1:
if linedata_list[1].strip() in ['tcp', 'udp', 'ah', 'esp', 'gre', 'ipv6', 'igmp']:
rule_obj[direction + '_transport'] = linedata_list[1].strip()
linedata = linedata_list[0]
else:
rule_obj[direction + '_transport'] = 'any'
else:
rule_obj[direction + '_transport'] = 'any'
# pull out ipv4 or ipv6 addresses
linedata_list = linedata.split()
new_linedata_list = []
valid_ip = None
for item in linedata_list:
try:
valid_ip = ipaddress.IPv4Interface(item)
except Exception:
try:
valid_ip = ipaddress.IPv6Interface(item)
except Exception:
new_linedata_list.append(item)
if valid_ip:
rule_obj[direction + '_ip'] = str(valid_ip.ip)
rule_obj[direction + '_ip_prefix'] = str(valid_ip.with_prefixlen.split('/')[1])
linedata = ' '.join(new_linedata_list)
# find the numeric port(s)
linedata_list = linedata.split(',')
port_list = []
port_ranges = []
for item in linedata_list:
if item.strip().isnumeric():
port_list.append(item.strip())
elif ':' in item:
p_range = item.strip().split(':', maxsplit=1)
port_ranges.append(
{
"start": p_range[0],
"end": p_range[1]
}
)
if port_list or port_ranges:
rule_obj[direction + '_service'] = None
linedata = ''
if port_list:
rule_obj[direction + '_ports'] = port_list
if port_ranges:
rule_obj[direction + '_port_ranges'] = port_ranges
# only thing left should be the service name.
if linedata.strip():
rule_obj[direction + '_service'] = linedata.strip()
rule_obj[direction + '_transport'] = None
# check if to/from IP addresses exist. If not, set to 0.0.0.0/0 or ::/0
if direction + '_ip' not in rule_obj:
if rule_obj.get('network_protocol') == 'ipv6':
rule_obj[direction + '_ip'] = '::'
rule_obj[direction + '_ip_prefix'] = '0'
elif rule_obj.get('network_protocol') == 'ipv4':
rule_obj[direction + '_ip'] = '0.0.0.0'
rule_obj[direction + '_ip_prefix'] = '0'
# finally set default ports if no ports exist and there should be some
if direction + '_transport' in rule_obj:
if rule_obj[direction + '_transport'] in ['tcp', 'udp', 'any']:
if not port_list and not port_ranges:
rule_obj[direction + '_port_ranges'] = [
{
'start': '0',
'end': '65535'
}
]
rule_obj[direction + '_service'] = None
return rule_obj
def get_deprecated_dns_ip():
'''We previously hardcoded the dns ip. This function returns the old
hardcoded value for use with older versions of cdk_addons.'''
interface = ipaddress.IPv4Interface(service_cidr())
ip = interface.network.network_address + 10
return ip.exploded
def __init__(self, name, ip, description, status="down"):
self.name = name
self.ip = ipaddress.IPv4Interface(ip)
self.description = description
self.status = status
from tests.common import config_reload
from test_voq_init import check_voq_interfaces
from tests.common.helpers.sonic_db import VoqDbCli, SonicDbKeyNotFound
from tests.common.helpers.assertions import pytest_assert
from tests.common.utilities import wait_until
from test_voq_disrupts import check_bgp_neighbors
logger = logging.getLogger(__name__)
pytestmark = [
pytest.mark.topology('t2')
]
ADDR = ipaddress.IPv4Interface(u"50.1.1.1/24")
def test_cycle_voq_intf(duthosts, all_cfg_facts, nbrhosts, nbr_macs):
"""
Delete and recreate VOQ interface through config save/load. Verify interface
is removed after configdb reload and then recreated after loading initial minigraph.
Args:
duthosts: The duthosts fixture
all_cfg_facts: all_cfg_facts fixture from voq conftest
nbrhosts: nbrhosts fixture
nbr_macs: nbr_macs fixture from voq conftest
"""
import ipaddress
f = open("extrentiable_attibutes.csv", "r")
data = f.readlines()
ex = {}
for info in data:
info = info.split(",")
ex[info[0]] = info[1]
fw = open("result2.csv", "w")
fw.write("sep=;\n")
for line in data:
if "network" not in line:
line = line.split(",")
key = unicode(line[0])
print key
ip = ipaddress.IPv4Interface(key)
ip = ip.with_netmask
ip = ip.split("/")
ip = ["network"] + ip + [line[1]] + ["OVERRIDE"]
print ip
for data in ip:
data = data.replace("\n", "")
fw.write(data)
fw.write(";")
fw.write("\n")
else:
line = line.split(",")
header = [
"header-network", "address*", "netmask*", "EA-" + line[1],
"EAInherited-" + line[1]
]
def unformat_api_address_with_prefix_t(o):
if o.address.af == 1:
return ipaddress.IPv6Interface((o.address.un.ip6, o.len))
if o.address.af == 0:
return ipaddress.IPv4Interface((o.address.un.ip4, o.len))
raise ValueError('Unknown address family {}'.format(o))
def python_value(self, value):
return None if value is None else ipaddress.IPv4Interface(value)
def __init__(self):
ip = self._findIPAddr()
mask = self._findSubnetMask(ip)
self.interface = ipaddress.IPv4Interface("%s/%s" % (ip, mask))
from openpyxl import Workbook
way = glob.glob("C:\\test\config_files\*.txt")
prob = '____________________________________________'
IPadd = []
for file in way:
with open(file) as newfile:
for line in newfile:
IP = re.match(
"^ ip address (([0-9]{1,3}\.){3}[0-9]{1,3}) (([0-9]{1,3}\.){3}[0-9]{1,3})",
line)
if IP:
IPadd.append(
ipaddress.IPv4Interface(
str(IP.group(1)) + "/" + str(IP.group(3))))
wb = Workbook()
ws = wb.active
ws['A1'] = 'Subnet'
ws['B1'] = 'Mask'
ws['C1'] = 'GW'
coll = 2
p = 0
print("%20s" % "Net", "%20s" % "GW")
while p < len(IPadd) - 1:
print("%20s" % IPadd[p].network.network_address,
"%10s" % IPadd[p].network.prefixlen, "%20s" % IPadd[p].ip)
p += 1
n = str(IPadd[p].network.network_address)
