def connection_present_for_device(device, netbox_api):
mapper = NetboxMapper(netbox_api, "dcim", "interface-connections")
try:
next(mapper.get(device=device.name))
return True
except StopIteration:
return False
def create_manufacturers(netbox_api):
mapper = NetboxMapper(netbox_api, "dcim", "manufacturers")
manufacturers = {}
for name in ("Cisco", "Juniper"):
name = str(name)
try:
manufacturer = next(mapper.get(slug=name.lower()))
except StopIteration:
manufacturer = mapper.post(name=name, slug=name.lower())
manufacturers[name.lower()] = manufacturer
return manufacturers
def test_put_with_null_foreign_key(self, mapper):
"""
Test PUT with an object previously having a null foreign key
"""
expected_attr = {
"id": 1,
"name": "test",
"vrf": None,
}
child_mapper = self._get_child_mapper_variable_attr(
mapper, expected_attr)
vrf_mapper = NetboxMapper(self.api, "ipam", "vrfs")
child_vrf_mapper = self._get_child_mapper_variable_attr(
vrf_mapper, {
"count": 1,
"next": None,
"previous": None,
"results": [{
"id": 1,
"name": "test_vrf"
}]
})
with requests_mock.Mocker() as m:
child_mapper_url = (self.get_mapper_url(child_mapper) +
"{}/".format(child_mapper.id))
m.register_uri("put",
child_mapper_url,
json=self.update_or_create_resource_json_callback)
child_mapper.vrf = child_vrf_mapper
req_json = child_mapper.put()
assert req_json["vrf"] == child_vrf_mapper.id
def test_put_with_foreign_key(self, mapper):
"""
Test that objects that are foreign keys are put by their ID
"""
child_mapper = self.get_child_mapper_foreign_key(mapper)
vrf_mapper = NetboxMapper(self.api, "ipam", "vrfs")
with requests_mock.Mocker() as m:
m.register_uri("get",
self.get_mapper_url(vrf_mapper) + "1/",
json={
"count": 1,
"next": None,
"previous": None,
"results": [{
"id": 1,
"name": "test_vrf"
}]
})
child_mapper_url = (self.get_mapper_url(child_mapper) +
"{}/".format(child_mapper.id))
received_req = m.register_uri(
"put",
child_mapper_url,
json=self.update_or_create_resource_json_callback)
child_mapper.put()
req_json = received_req.last_request.json()
assert isinstance(req_json["vrf"], int)
def create_device_type_interfaces(netbox_api, manufacturer, device_type,
ports):
mapper = NetboxMapper(netbox_api, "dcim", "interface-templates")
for port_type, nb in ports.items():
if nb > 1:
start = 1 if manufacturer == "cisco" else 0
port_names = ("{}/{}".format(port_type, i)
for i in range(start, nb + start))
else:
port_names = (port_type, )
upstream_ports = {
p.name
for p in mapper.get(devicetype_id=device_type)
}
for name in port_names:
if name not in upstream_ports:
mapper.post(name=name, device_type=device_type)
def create_device_types(netbox_api, types, manufacturers):
mapper = NetboxMapper(netbox_api, "dcim", "device-types")
for name, props in types.items():
manufacturer_name = props.pop("manufacturer")
name = str(name)
try:
t = next(mapper.get(slug=name.lower()))
except StopIteration:
t = mapper.post(model=name,
slug=name.lower(),
manufacturer=manufacturers[manufacturer_name])
update_netbox_obj_from(t, props)
# Until issue #2272 is fixed on netbox
t.__upstream_attrs__.remove("subdevice_role")
t.put()
create_device_type_interfaces(netbox_api, manufacturer_name, t,
props["ports"])
def __init__(self, netbox_api, *args, **kwargs):
self.netbox_api = netbox_api
self._mappers = {
"dcim_choices":
NetboxMapper(self.netbox_api, app_name="dcim", model="_choices"),
"devices":
NetboxMapper(self.netbox_api, app_name="dcim", model="devices"),
"interfaces":
NetboxMapper(self.netbox_api, app_name="dcim", model="interfaces"),
"interface-connections":
NetboxMapper(self.netbox_api,
app_name="dcim",
model="interface-connections"),
"ip":
NetboxMapper(self.netbox_api,
app_name="ipam",
model="ip-addresses")
}
self._choices_cache = {}
def print_orphans(parsed_args):
netbox_api = NetboxAPI(**get_config()["netbox"])
devices_mapper = NetboxMapper(netbox_api, "dcim", "devices")
threads = parsed_args.threads
if parsed_args.device_role_id:
iter_devices = devices_mapper.get(role_id=parsed_args.device_role_id,
limit=threads)
else:
iter_devices = devices_mapper.get(limit=threads)
with ThreadPoolExecutor(max_workers=threads) as executor:
futures = {}
for d in tqdm.tqdm(iter_devices):
future = executor.submit(connection_present_for_device, d,
netbox_api)
futures[future] = d
for f in concurrent.futures.as_completed(futures):
if not f.result():
print(futures[f].name)
def test_post_foreign_key(self, mapper):
url = self.get_mapper_url(mapper)
fk_mapper = NetboxMapper(mapper.netbox_api, "foo", "bar")
fk_mapper.id = 2
with requests_mock.Mocker() as m:
received_req = m.register_uri("post",
url,
json={
"id": 1,
"name": "testname",
"fk": {
"id": 2
}
})
m.register_uri("get",
url + "1/",
json={
"count":
1,
"next":
None,
"previous":
None,
"results": [{
"id": 1,
"name": "testname",
"fk": {
"id": 2,
"url":
self.get_mapper_url(fk_mapper) + "2/"
}
}]
})
mapper.post(name="testname", fk=fk_mapper)
assert received_req.last_request.json()["fk"] == 2
def test_post_foreign_key_broken_mapper(self, mapper):
url = self.get_mapper_url(mapper)
fk_mapper = NetboxMapper(mapper.netbox_api, "foo", "bar")
with requests_mock.Mocker() as m:
m.register_uri("post",
url,
json={
"id": 1,
"name": "testname",
"fk": {
"id": 2
}
})
with pytest.raises(ValueError):
mapper.post(name="testname", fk=fk_mapper)
def get_orphans(netbox_api):
ip_mapper = NetboxMapper(netbox_api, "ipam", "ip-addresses")
prefixes_mapper = NetboxMapper(netbox_api, "ipam", "prefixes")
missing_prefixes = set()
for i in ip_mapper.get():
ip_prefix = ipaddress.ip_interface(i.address).network
if ip_prefix in missing_prefixes:
continue
try:
next(prefixes_mapper.get(within_include=i.address))
except StopIteration:
missing_prefixes.add(ip_prefix)
yield ip_prefix
def fix_vrf(parsed_args):
netbox_api = NetboxAPI(**get_config()["netbox"])
ip_mapper = NetboxMapper(netbox_api, "ipam", "ip-addresses")
prefixes_mapper = NetboxMapper(netbox_api, "ipam", "prefixes")
for i in tqdm(ip_mapper.get()):
try:
p = next(prefixes_mapper.get(within_include=i.address))
if p.vrf != i.vrf:
print(i.address)
i.vrf = p.vrf
try:
i.put()
except Exception as e:
logger.error("Error with IP %s", i.address)
logger.exception(e)
except StopIteration:
continue
def create_devices(netbox_api, devices, role_id, site_id, threads=10):
device_types_mapper = NetboxMapper(netbox_api, "dcim", "device-types")
platforms_mapper = NetboxMapper(netbox_api, "dcim", "platforms")
caches = {
"device_types":
LRU(on_miss=lambda slug: next(device_types_mapper.get(slug=slug))),
"platforms":
LRU(on_miss=lambda slug: next(platforms_mapper.get(slug=slug)))
}
device_mapper = NetboxMapper(netbox_api, "dcim", "devices")
with ThreadPoolExecutor(max_workers=threads) as executor:
futures = []
for name, props in devices.items():
future = executor.submit(_thread_push_device, device_mapper,
caches, name, props, role_id, site_id)
futures.append(future)
try:
[future.result() in concurrent.futures.as_completed(futures)]
except requests.exceptions.HTTPError as e:
print(e.response.data)
raise
def mapper(self):
return NetboxMapper(self.api, self.test_app_name, self.test_model)
def test_eq_not_equals(self, mapper):
assert mapper != NetboxMapper(self.api, "an_app", "a_model")
