def create_network_map(filenames):
'''
Функция create_network_map обрабатывает вывод команды show cdp neighbors из нескольких файлов и объединяет его в одну общую топологию.
один параметр filenames, который ожидает как аргумент список с именами файлов, в которых находится вывод команды show cdp neighbors.
Функция возвращает словарь, который описывает соединения между устройствами.
Структура словаря такая же, как в задании 11.1:
{('R4', 'Fa0/1'): ('R5', 'Fa0/1'),
('R4', 'Fa0/2'): ('R6', 'Fa0/0')}
:param filenames:
:return: dict
'''
result = {}
# Разбираем первый файл.
with open(filenames.pop(0)) as f1:
result = parse_cdp_neighbors(f1.read())
#print(filenames)
for file in filenames:
with open(file) as f:
for key, value in parse_cdp_neighbors(f.read()).items():
if not value in result.keys(
): # Если значение не в ключах, то добавляем в словарь
result[key] = value
return result
def create_network_map(filenames):
neighbors = []
slovar = {}
for chek in filenames:
with open(chek) as files:
parse_cdp_neighbors(files.read())
pass
print(slovar)
def test_function_return_value():
"""
Function check
"""
sh_cdp_n_sw1 = (
"SW1>show cdp neighbors\n\n"
"Capability Codes: R - Router, T - Trans Bridge, B - Source Route Bridge\n"
" S - Switch, H - Host, I - IGMP, r - Repeater, P - Phone\n\n"
"Device ID Local Intrfce Holdtme Capability Platform Port ID\n"
"R1 Eth 0/1 122 R S I 2811 Eth 0/0\n"
"R2 Eth 0/2 143 R S I 2811 Eth 0/0\n"
"R3 Eth 0/3 151 R S I 2811 Eth 0/0\n"
"R6 Eth 0/5 121 R S I 2811 Eth 0/1"
)
correct_return_value = {
("SW1", "Eth0/1"): ("R1", "Eth0/0"),
("SW1", "Eth0/2"): ("R2", "Eth0/0"),
("SW1", "Eth0/3"): ("R3", "Eth0/0"),
("SW1", "Eth0/5"): ("R6", "Eth0/1"),
}
return_value = task_11_1.parse_cdp_neighbors(sh_cdp_n_sw1)
assert return_value != None, "The function returns None"
assert (
type(return_value) == dict
), f"The function should return a dict, instead it returns a {type(return_value).__name__}"
assert correct_return_value == return_value, "Function returns wrong value"
def create_network_map(filenames):
filal_dict = {}
'''
Функция должна возвращать словарь, который описывает соединения между устройствами.
'''
with open(filenames, 'r') as f:
for file in f:
with open(file.rstrip(), 'r') as f:
all_output_lines = f.read()
current_dict = parse_cdp_neighbors(all_output_lines)
filal_dict = merge_two_dicts(filal_dict, current_dict)
duble_flug = True
# Идея алгоритма:
# беру список значений словаря и список ключей словаря на каждой итерации цикла while
# прохожу по спискам на предмет совпадающих элементов (функция find_matched_element)
#
# Если совпадение найдено (функция find_matched_element вернула совпадение) -
# - удаляю значение по ключу
#
# На следующей итерации снова формируются списки ключей и значений (обновленного словаря)
# и процесс повторяется, пока ф-я find_matched_element не выдаст отсутствие совпадений
while duble_flug is True:
value_list = list(filal_dict.values())
key_list = list(filal_dict.keys())
matching = find_matched_element(value_list, key_list)
if matching:
# удаление совпадающего элемента
filal_dict.pop(matching)
else:
# выход из while
duble_flug = False
return filal_dict
def create_network_map(filenames):
tplg = {}
for files in filenames:
with open(files) as f:
ngbr = parse_cdp_neighbors(f.read())
tplg.update({k: v for k, v in ngbr.items() if not (v in tplg)})
return tplg
def test_function_return_value():
"""
Проверка работы функции
"""
sh_cdp_n_sw1 = (
"SW1>show cdp neighbors\n\n"
"Capability Codes: R - Router, T - Trans Bridge, B - Source Route Bridge\n"
" S - Switch, H - Host, I - IGMP, r - Repeater, P - Phone\n\n"
"Device ID Local Intrfce Holdtme Capability Platform Port ID\n"
"R1 Eth 0/1 122 R S I 2811 Eth 0/0\n"
"R2 Eth 0/2 143 R S I 2811 Eth 0/0\n"
"R3 Eth 0/3 151 R S I 2811 Eth 0/0\n"
"R6 Eth 0/5 121 R S I 2811 Eth 0/1"
)
correct_return_value = {
("SW1", "Eth0/1"): ("R1", "Eth0/0"),
("SW1", "Eth0/2"): ("R2", "Eth0/0"),
("SW1", "Eth0/3"): ("R3", "Eth0/0"),
("SW1", "Eth0/5"): ("R6", "Eth0/1"),
}
return_value = task_11_1.parse_cdp_neighbors(sh_cdp_n_sw1)
assert return_value != None, "Функция ничего не возвращает"
assert (
type(return_value) == dict
), f"По заданию функция должна возвращать словарь, а возвращает {type(return_value).__name__}"
assert (correct_return_value == return_value
), "Функция возвращает неправильное значение"
def create_network_map(filenames):
result = {}
for i in filenames:
with open(i) as f:
a = parse_cdp_neighbors(f.read())
result.update(a)
return result
def create_network_map(filenames):
topology_dict = {}
for filename in filenames:
with open(filename) as file:
pprint(filename)
command_output = file.read()
pprint(parse_cdp_neighbors(command_output))
def test_function_return_value_different_args():
"""
Проверка работы функции на другом выводе
"""
sh_cdp_n_r3 = (
"R3>show cdp neighbors\n"
"Capability Codes: R - Router, T - Trans Bridge, B - Source Route Bridge\n"
" S - Switch, H - Host, I - IGMP, r - Repeater\n\n"
"Device ID Local Intrfce Holdtme Capability Platform Port ID\n"
"SW1 Eth 0/0 131 S I WS-C3750- Eth 0/3\n"
"R4 Eth 0/1 145 R S I 2811 Eth 0/0\n"
"R5 Eth 0/2 123 R S I 2811 Eth 0/0\n"
)
correct_return_value = {
("R3", "Eth0/0"): ("SW1", "Eth0/3"),
("R3", "Eth0/1"): ("R4", "Eth0/0"),
("R3", "Eth0/2"): ("R5", "Eth0/0"),
}
return_value = task_11_1.parse_cdp_neighbors(sh_cdp_n_r3)
assert return_value != None, "Функция ничего не возвращает"
assert (
type(return_value) == dict
), f"По заданию функция должна возвращать словарь, а возвращает {type(return_value).__name__}"
assert (correct_return_value == return_value
), "Функция возвращает неправильное значение"
def create_network_map(filenames):
'''
параметр filenames, который ожидает как аргумент список с именами файлов,
в которых находится вывод команды show cdp neighbors.
Функция возвращет словарь, который описывает соединения между устройствами.
Структура словаря:
{('R4', 'Fa0/1'): ('R5', 'Fa0/1'),
('R4', 'Fa0/2'): ('R6', 'Fa0/0')}
'''
topology = {}
dup = []
for sh_cdp in filenames:
with open(sh_cdp, 'r') as f:
top = task_11_1.parse_cdp_neighbors(f.read())
topology.update(top)
for k, v in topology.items():
if k in topology.values():
dup.append(k)
ctop = topology.copy()
for k, v in topology.items():
if k in topology.values():
for i in range(0, len(dup) // 2):
try:
ctop.pop(dup[i])
except KeyError:
k = dup[i]
return ctop
def create_network_map(filenames):
result = dict()
for file in filenames:
with open(file, 'r') as f:
for value, key in parse_cdp_neighbors(f.read()).items():
result[value] = key
return result
def create_network_map(filenames):
network_map = {}
for filename in filenames:
with open(filename) as show_command:
parsed = parse_cdp_neighbors(show_command.read())
network_map.update(parsed)
return network_map
def main():
from draw_network_graph import draw_topology
from task_11_1 import parse_cdp_neighbors
list_of_files = [
'sh_cpd_n_r1.txt', 'sh_cpd_n_r2.txt', 'sh_cpd_n_r3.txt',
'sh_cpd_n_r1.txt'
]
draw_topology(parse_cdp_neighbors('sw1_sh_cdp_neighbors.txt'))
def draw_topology_multi_devices(*args):
files = {}
for arg in args:
files.update({
k: v
for k, v in parse_cdp_neighbors(arg).items() if files.get(v) != k
})
return draw_topology(files)
def create_network_map(filenames):
file = []
for i in filenames:
with open(i) as f:
file.append(f.read())
dct = parse_cdp_neighbors('\n'.join(file))
return dct
def create_network_map(filenames):
net_map = {}
for filename in filenames:
with open(filename) as src:
parsed = parse_cdp_neighbors(src.read())
for key, value in parsed.items():
key, value = sorted([key, value])
net_map[key] = value
return net_map
def create_network_map(filenames):
network_map = {}
for filename in filenames:
with open(filename) as command_output:
parsed = parse_cdp_neighbors(command_output.read())
network_map.update(parsed)
return network_map
def create_network_map(filenames):
network_map = {}
for infile in filenames:
with open(infile, "r") as infile:
parsed = parse_cdp_neighbors(infile.read())
for key, value in parsed.items():
if not network_map.get(value) == key:
network_map[key] = value
return network_map
def create_network_map(filenames):
dict1={}
for fname in filenames:
with open(fname) as f:
b=parse_cdp_neighbors(f.read())
for k,v in b.items():
dict1[k]=v
#print(dict1)
return dict1
def create_network_map(filenames):
rmap = {}
for fname in filenames:
rlines = open(fname, 'r').readlines()
# rmap.update(parse_cdp_neighbors(rlines))
for kport, port in parse_cdp_neighbors(rlines).items():
if not port in rmap.keys():
rmap[kport] = port
return rmap
def test_function_return_value(sh_cdp_n_sw1):
correct_return_value = {('SW1', 'Eth0/1'): ('R1', 'Eth0/0'),
('SW1', 'Eth0/2'): ('R2', 'Eth0/0'),
('SW1', 'Eth0/3'): ('R3', 'Eth0/0'),
('SW1', 'Eth0/5'): ('R6', 'Eth0/1')}
return_value = task_11_1.parse_cdp_neighbors(sh_cdp_n_sw1)
assert return_value != None, "Функция ничего не возвращает"
assert type(return_value) == dict, "Функция должна возвращать словарь"
assert return_value == correct_return_value, "Функция возвращает неправильное значение"
def create_network_map(filenames):
topol = dict()
for file in filenames:
with open(file) as f:
topol.update(parse_cdp_neighbors(f.read()))
for item in dict(topol):
if item[0] in [val[0] for val in topol.values()] and topol[item][0] in [key[0] for key in topol.keys()]:
topol.pop(item)
print(topol)
return topol
def create_network_map(filenames):
network_map = {}
for filename in filenames:
with open(filename) as show_command:
parsed = parse_cdp_neighbors(show_command.read())
for key, value in parsed.items():
if not network_map.get(value) == key:
network_map[key] = value
return network_map
def create_network_map(filenames):
'''
Cкрипт, который будет обрабатывать конфигурационный файл config_sw1.txt.
мя файла передается как аргумент скрипту.
'''
network = {}
for num in filenames:
with open(num, "r") as f:
#pprint(parse_cdp_neighbors(f.read()))
network.update(parse_cdp_neighbors(f.read()))
return network
def create_network_map(filenames):
result_dict = {}
for filename in filenames:
with open(filename) as f:
for key, value in parse_cdp_neighbors(f.read()).items():
if not value in result_dict.keys():
result_dict.update({key: value})
return result_dict
def create_network_map(filenames):
r = {}
res = {}
for f in filenames:
with open(f, 'r') as ff:
l = ff.read()
r = parse_cdp_neighbors(l)
for k, v in r.items():
if not res.get(k) and not res.get(v):
res[k] = v
return res
def create_network_map(filenames):
devs_dict, devs_lst = {}, []
for config in filenames:
with open(config) as f:
devs_dict.update(parse_cdp_neighbors(f.read()))
for devA, devB in devs_dict.items():
for devb, deva in devs_dict.items():
if devA == deva and devB == devb:
if deva not in devs_lst: devs_lst.append(devb)
for i in devs_lst:
del devs_dict[i]
return devs_dict
def create_network_map(filenames):
topol = {}
for filename in filenames:
with open(filename) as f:
topol_add = parse_cdp_neighbors(f.read())
copy = topol_add.copy()
for key, value in topol_add.items():
for key2, value2 in topol.items():
if key == value2 and value == key2:
del copy[key]
topol.update(copy)
return topol
def create_network_map(filenames):
result = {}
for file in filenames:
with open(file, "r") as f:
p_result = parse_cdp_neighbors("".join(f.readlines()))
for key, value in p_result.items():
if value in result.keys() and result[value] == key:
pass
else:
result.update({key: value})
return result
def create_network_map(filenames):
topology_dict = {}
for line in filenames:
filename_output = line
with open(filename_output) as f:
command_output = f.read()
topology_dict.update(parse_cdp_neighbors(command_output))
command_output = " "
right_topology = dict(topology_dict)
for words in topology_dict:
if topology_dict[words] in right_topology:
right_topology.pop(words)
return right_topology
