def create_network_map(filenames):
out = {}
out_uniq = {}
for files in filenames:
#print(files)
f = open("/home/vagrant/my_repo/online-8-oleg-bosyuk/exercises/11_modules/" + files)
for line in f:
line.split("\n")
#print(line.split("\n"))
if 'cdp' in line:
local_dev = (line.split('>'))[0]
#print(local_dev)
elif 'Eth' in line:
value_in_line = line.split()
rem_info = (value_in_line[0], value_in_line[-2] + value_in_line[-1])
local_info = (local_dev, value_in_line[1] + value_in_line[2])
out[local_info] = rem_info
#print(out)
uniq_out = {}
for (key, value) in out.items():
if key not in uniq_out.values() and key not in uniq_out.keys() and value not in uniq_out.keys() and value not in uniq_out.values():
uniq_out[key] = value
#elif value not in uniq_out.keys():
# uniq_out[key] = [value]
#print(uniq_out)
return(uniq_out)
draw_topology(uniq_out, '/home/vagrant/my_repo/online-8-oleg-bosyuk/exercises/11_modules/1.svg')
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 transform_topology(load_file_yaml: str):
with open(load_file_yaml, 'r') as f:
read_file = yaml.load(f, Loader=yaml.BaseLoader)
dict_topology = dict(read_file)
topology = dict()
for host, intfs in dict_topology.items():
for intf, r_device in intfs.items():
r_device_tuple = tuple(*r_device.items())
if not (r_device_tuple in topology):
topology[(host, intf)] = r_device_tuple
draw_topology(topology, 'topology.svg')
return topology
def transform_topology(file):
with open(file) as f:
data = yaml.safe_load(f)
#pprint (data)
topology = {}
for l_id, did_data in data.items():
for l_port, remote_data in did_data.items():
for r_id, r_port in remote_data.items():
topology[(l_id, l_port)] = (r_id, r_port)
draw_topology(topology)
def create_network_map(filenames):
full_topology = {}
result = {}
for filename in filenames:
with open(filename, 'r') as f:
full_topology.update(parse_cdp_neighbors(f.read()))
# В result записываем только уникальные элементы
for key, value in full_topology.items():
if result.get(key) == value or result.get(value) == key:
continue
else:
result[key] = value
draw_topology(result, output_filename='task_11_2a_topology_my')
return result
def complite_topology_cdp(dict_topology):
#{('R4', 'Eth0/1'): ('R5', 'Eth0/1'),
#('R4', 'Eth0/2'): ('R6', 'Eth0/0')}
#'R6': {'Eth 0/1': {'R2': 'Eth 0/2'}},
dict_test = dict()
for key, val in dict_topology.items():
for sub_key, sub_val in val.items():
if not tuple(*sub_val.items()) in dict_test:
dict_test[(key, sub_key)] = tuple(*sub_val.items())
pprint(dict_test)
draw_topology(dict_test)
def main():
key = []
res_keys = []
from draw_network_graph import draw_topology
from task_11_1 import parse_cdp_neighbors
list_of_files = ['sh_cdp_n_r1.txt','sh_cdp_n_r2.txt','sh_cdp_n_r3.txt','sh_cdp_n_sw1.txt']
res = {}
for i in range(len(list_of_files)):
k = parse_cdp_neighbors(list_of_files[i])
key = list(k.keys())
for j in range(len(key)):
if res.get(k[key[j]],'no') =='no':
res.update(k)
print(res)
draw_topology(res)
def create_network_map(filenames):
'''
Поочередно открываем каждый файл, обновляем словарь с помощью функции parse_cdp_neighbors
В цикле проверяем, равен ли ключ значению второго словаря, если нет-добавляем
'''
draw_dict = {}
fin_dict = {}
for name in filenames:
with open(name, 'r') as file:
draw_dict.update(parse_cdp_neighbors(file.read()))
for key in draw_dict.keys():
if key not in fin_dict.values(): # Проверяем, нет ли зеркальных строк
fin_dict[key] = draw_dict[
key] # Если нет, добавляем значение в словарь
draw_topology(fin_dict)
return fin_dict
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 transform_topology(yaml_topology_file):
topology_dict = {}
with open(yaml_topology_file, encoding='UTF-8') as f:
from_yaml_dict = yaml.safe_load(f)
for key, value in from_yaml_dict.items():
topology_dict.update({(key, k): (kk, vv)
for k, v in value.items()
for kk, vv in v.items()})
a = set(topology_dict.keys())
b = set(topology_dict.values())
c = list(a | b)
topology_dict_new = {}
for d in c:
if d not in topology_dict_new.values():
topology_dict_new.update({d: topology_dict[d]})
draw_topology(topology_dict_new)
return topology_dict
def create_network_map(filenames):
result1 = {}
result = {}
for name in filenames:
with open(name, 'r') as f:
source = f.read()
parse = parse_cdp_neighbors(source)
result1.update(parse)
keys_result = set(result1.keys())
key_result = []
for key in keys_result:
result2 = {}
if not (result1[key] in key_result):
key_result.append(key)
result2 = {key: result1[key]}
result.update(result2)
draw_topology(result)
return result
def create_network_map(filenames):
topology_dict_temp = {}
topology_dict = {}
key_list = []
value_list = []
for item in filenames:
with open(item) as file:
show = file.read()
temp_output = parse_cdp_neighbors(show)
topology_dict_temp.update(temp_output)
for key, value in topology_dict_temp.items():
key_list.append(key)
value_list.append(value)
if key in value_list and value in key_list:
pass
else:
topology_dict[key] = value
return topology_dict
draw_topology(topology_dict)
def create_network_map(filenames):
'''
Функция create_network_map обрабатывает вывод команды show cdp neighbors
из нескольких файлов и объединяет его в одну общую топологию.
У функции должен быть один параметр filenames (вместо него *args),
который ожидает как аргумент список с именами файлов, в которых находится
вывод команды show cdp neighbors.
С помощью функции draw_topology из файла draw_network_graph.py рисуем схему на основании
топологии, полученной с помощью функции create_network_map.
Результат помещается в 'img/topology'
'''
map = {}
key_list = []
# открываем каждый файл как строку, формируем общий словарь из всех файлов-аргументов
# с помощью функции parse_cdp_neighbors()
for file in filenames:
with open(file) as f:
f_line = f.read()
a = parse_cdp_neighbors(f_line)
map.update(a)
# проверяем полученный словарь на дублирование ключей и значений, исключаем дубли
# всё, что дублируется, помещаем в список key_list
for key in map.keys():
for value in map.values():
if key == value:
key_list.append(key)
# теперь удаляем из списка key_list первую половину значений (например, первые 3 из списка из 6 значений)
# т.к. нужно удалить только дублирующиеся значения, а не все повторяющиеся
for i in range(0, int((len(key_list)) / 2)):
key_list.pop(0)
for key1 in key_list:
del map[key1]
# рисуем топологию в 'img/topology'
draw_topology(map)
return map
def transform_topology(inputYamlFile): with open(inputYamlFile) as f: dict_topology = yaml.safe_load(f) #pprint (dict_topology) for key, value in dict_topology.items(): #print (value) for sub_key1, sub_value1 in value.items(): tuple_key = (key, sub_key1) #print (tuple_key) for sub_key2, sub_value2 in sub_value1.items(): tuple_value = (sub_key2, sub_value2) if tuple_key not in final_dict.values(): #print (tuple_value) final_dict[tuple_key] = tuple_value #pprint (final_dict) draw_topology(final_dict) return final_dict
def create_network_map(filenames):
from task_11_1 import parse_cdp_neighbors
from draw_network_graph import draw_topology
dictionary = {}
for file in filenames:
with open(file) as f:
dictionary.update(parse_cdp_neighbors(f.read()))
#print(dictionary)
clean_dict = {}
for key, value in dictionary.items() or dictionary.keys():
if value in clean_dict.keys():
pass
elif key in clean_dict.items():
pass
else:
clean_dict[key] = value
#print(clean_dict)
#draw_topology(clean_dict)
return(draw_topology(clean_dict))
сгенерировать топологию, которая соответствует выводу
команды sh cdp neighbor в файле sw1_sh_cdp_neighbors.txt
Не копировать код функций parse_cdp_neighbors и draw_topology.
В итоге, должен быть сгенерировано изображение топологии.
Результат должен выглядеть так же, как схема в файле task_11_2_topology.svg
При этом:
* Интерфейсы могут быть записаны с пробелом Fa 0/0 или без Fa0/0.
* Расположение устройств на схеме может быть другим
* Соединения должны соответствовать схеме
Ограничение: Все задания надо выполнять используя только пройденные темы.
'''
from task_11_1 import parse_cdp_neighbors
from draw_network_graph import draw_topology
input = open('input2.txt')
topology_dict = (parse_cdp_neighbors(input))
#if __name__ == '__main__':
# print (parse_cdp_neighbors(input))
print(topology_dict)
draw_topology(topology_dict)
input.close()
> apt-get install graphviz
> И модуль python для работы с graphviz:
> pip install graphviz
'''
def create_network_map(filenames):
d = {}
for file in filenames:
with open(file) as src:
d.update(parse_cdp_neighbors(src.read()))
dd = d.copy()
ddd = d.copy()
for key, value in d.items():
is_dubl = False
for key1, value1 in dd.items():
if key == value1 and value == key1:
is_dubl = True
break
if key in dd: del dd[key]
if is_dubl:
del dd[value]
del ddd[value]
return ddd
files = [
'sh_cdp_n_sw1.txt', 'sh_cdp_n_r1.txt', 'sh_cdp_n_r2.txt', 'sh_cdp_n_r3.txt'
]
draw_topology(create_network_map(files))
with open(yaml_filename) as f:
templates = yaml.safe_load(f)
for device, link in templates.items():
for local_intf, remote in link.items():
result.update({(device, local_intf): list(remote.items())[0]})
for key, value in result.copy().items():
if result.get(value) == key:
del result[key]
return result
if __name__ == "__main__":
#pprint(transform_topology('topology.yaml'))
draw_topology(transform_topology('topology.yaml'))
"""
Натальино решение - заполнять пустой словарь, проверяя нет ли в нем уже вносимых данных
def transform_topology(topology_filename):
with open(topology_filename) as f:
raw_topology = yaml.load(f)
formatted_topology = {}
for l_device, peer in raw_topology.items():
for l_intf, remote in peer.items():
r_device, r_intf = list(remote.items())[0]
if not (r_device, r_intf) in formatted_topology:
formatted_topology[(l_device, l_intf)] = (r_device, r_intf)
return formatted_topology
Результат должен выглядеть так же, как схема в файле task_17_2b_topology.svg
При этом:
* Интерфейсы должны быть записаны с пробелом Fa 0/0
* Расположение устройств на схеме может быть другим
* Соединения должны соответствовать схеме
* На схеме не должно быть дублирующихся линков
> Для выполнения этого задания, должен быть установлен graphviz:
> apt-get install graphviz
> И модуль python для работы с graphviz:
> pip install graphviz
'''
with open('topology.yaml', 'r') as f:
topology = yaml.safe_load(f)
def transform_topology(i_topology):
result = {}
for m_key in i_topology.keys():
for intf_key in i_topology[m_key].keys():
for re_host, re_port in i_topology[m_key][intf_key].items():
if (re_host, re_port) not in result.keys():
result[(m_key, intf_key)] = (re_host, re_port)
return result
#print(transform_topology(topology))
draw_topology(transform_topology(topology))
Не копировать код функций parse_cdp_neighbors и draw_topology.
В итоге, должен быть сгенерировано изображение топологии.
Результат должен выглядеть так же, как схема в файле task_11_2_topology.svg
При этом:
* Интерфейсы могут быть записаны с пробелом Fa 0/0 или без Fa0/0.
* Расположение устройств на схеме может быть другим
* Соединения должны соответствовать схеме
Ограничение: Все задания надо выполнять используя только пройденные темы.
> Для выполнения этого задания, должен быть установлен graphviz:
> apt-get install graphviz
> И модуль python для работы с graphviz:
> pip install graphviz
'''
from draw_network_graph import draw_topology
from task_11_1 import parse_cdp_neighbors
with open('sw1_sh_cdp_neighbors.txt') as file:
oneline = file.read()
cdp_dict = parse_cdp_neighbors(oneline)
draw_topology(cdp_dict)
remote_device.append(line[0])
#local_interface.append(local_device + ', ' + ''.join(map(str, line[1:3])))
#remote_interface.append(str(line[0]) + ', ' + ''.join(map(str, line[-2:])))
local_interface1 = (local_device + ' ' + ''.join(map(str, line[1:3])))
#print(tuple(local_interface.split()))
local_interface2 = tuple(local_interface1.split())
remote_interface1 = (str(line[0]) + ' ' + ''.join(map(str, line[-2:])))
#print(tuple(remote_interface.split()))
remote_interface2 = tuple(remote_interface1.split())
local_interface.append(local_interface2)
remote_interface.append(remote_interface2)
#local_interface1 = []
#remote_interface1 = []
#for i in local_interface:
# local_interface1.append(tuple(i.split()))
#for j in remote_interface:
# remote_interface1.append(tuple(j.split()))
cdp_dict = dict(zip(local_interface, remote_interface))
#print(cdp_dict)
return cdp_dict
#parse_cdp_neighbors('sh_cdp_n_sw1.txt')
cdp = parse_cdp_neighbors('sh_cdp_n_sw1.txt')
#cdp = {('sw1', 'eth0/1'): ('r1', 'eth0/0'), ('sw1', 'eth0/2'): ('r2', 'eth0/0'), ('sw1', 'eth0/3'): ('r3', 'eth0/0'), ('sw1', 'eth0/5'): ('r6', 'eth0/1')}
print(cdp)
#for key, item in cdp.items():
# print(type(key), type(item))
draw_topology(cdp)
Результат должен выглядеть так же, как схема в файле task_11_2_topology.svg
При этом:
* Интерфейсы могут быть записаны с пробелом Fa 0/0 или без Fa0/0.
* Расположение устройств на схеме может быть другим
* Соединения должны соответствовать схеме
Ограничение: Все задания надо выполнять используя только пройденные темы.
> Для выполнения этого задания, должен быть установлен graphviz:
> apt-get install graphviz
> И модуль python для работы с graphviz:
> pip install graphviz
'''
from sys import argv
from task_11_1 import parse_cdp_neighbors
from draw_network_graph import draw_topology
if __name__ == '__main__':
in_file_name = argv[1].strip()
result_dict = {}
f = open(in_file_name, 'r')
result_dict = parse_cdp_neighbors(f.read())
f.close()
draw_topology(result_dict)
* На схеме не должно быть "дублирующихся" линков
> Для выполнения этого задания, должен быть установлен graphviz:
> apt-get install graphviz
> И модуль python для работы с graphviz:
> pip install graphviz
"""
import yaml
from draw_network_graph import draw_topology
def transform_topology(topology_filename):
with open(topology_filename) as f:
raw_topology = yaml.safe_load(f)
formatted_topology = {}
for l_device, peer in raw_topology.items():
for l_int, remote in peer.items():
r_device, r_int = list(remote.items())[0]
if not (r_device, r_int) in formatted_topology:
formatted_topology[(l_device, l_int)] = (r_device, r_int)
return formatted_topology
if __name__ == "__main__":
formatted_topology = transform_topology("topology.yaml")
draw_topology(formatted_topology)
> Для выполнения этого задания, должен быть установлен graphviz:
> apt-get install graphviz
> И модуль python для работы с graphviz:
> pip install graphviz
"""
import yaml
from pprint import pprint
from draw_network_graph import draw_topology
def transform_topology(yfile):
res = {}
with open(yfile) as f:
topo = yaml.safe_load(f)
for lh, nei0 in topo.items():
for lp, nei1 in nei0.items():
for rp, rh in nei1.items():
if res.get((rp, rh)) == None:
res[(lh, lp)] = (rp, rh)
return (res)
if __name__ == '__main__':
topo = transform_topology('topology.yaml')
draw_topology(topo, 'topo')
'Eth 0/1': {'R5': 'Eth 0/0'},
'Eth 0/2': {'R6': 'Eth 0/1'}},
...
We need to convert it to smth like this:
('R1', 'Eth 0/0'):('SW1', 'Eth 0/1')
('R2', 'Eth 0/0'):('SW1', 'Eth 0/2')
('R2', 'Eth 0/1'):('R5', 'Eth 0/0')
...
'''
topology_dict = {}
for local_host, topo in from_yaml.items():
for local_interface, remote in topo.items():
for remote_host, remote_interface in remote.items():
topology_dict[(local_host, local_interface)] = (remote_host,
remote_interface)
'''
topology_dict has duplicates
{('R1', 'Eth 0/0'): ('SW1', 'Eth 0/1'),
...
('SW1', 'Eth 0/1'): ('R1', 'Eth 0/0'),
We need to clear them.
Form a new dictionary, if key is not in values in new dict, add this key-value pair to new dict.
'''
topology_cleared = {}
for key, value in topology_dict.items():
if key not in topology_cleared.values():
topology_cleared[key] = value
draw_topology(topology_cleared)
# рисоваться топология (после вызова функции)
import draw_network_graph as dng
from task_11_1 import parse_cdp_neighbors
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
if __name__ == "__main__":
infiles = [
"sh_cdp_n_sw1.txt",
"sh_cdp_n_r1.txt",
"sh_cdp_n_r2.txt",
"sh_cdp_n_r3.txt",
]
topology = create_network_map(infiles)
dng.draw_topology(topology)
# рисуем топологию:
# draw_topology(topology)
# эти заготовки написаны чтобы показать в какой момент должна
# рисоваться топология (после вызова функции)
from pprint import pprint
from draw_network_graph import draw_topology
from task_11_1 import parse_cdp_neighbors
def create_network_map(filenames):
neighbors = []
slovar = {}
for chek in filenames:
with open(chek) as files:
parse_cdp_neighbors(files.read())
pass
print(slovar)
if __name__ == "__main__":
infiles = [
"sh_cdp_n_sw1.txt",
"sh_cdp_n_r1.txt",
"sh_cdp_n_r2.txt",
"sh_cdp_n_r3.txt",
]
topology = create_network_map(infiles)
# рисуем топологию:
draw_topology(topology)
* Соединения должны соответствовать схеме
* На схеме не должно быть дублирующихся линков
> Для выполнения этого задания, должен быть установлен graphviz:
> apt-get install graphviz
> И модуль python для работы с graphviz:
> pip install graphviz
'''
import yaml
from pprint import pprint
from draw_network_graph import draw_topology
def transform_topology(yaml_filename):
draw_dict = {}
with open(yaml_filename) as top:
topology = yaml.safe_load(top)
for k1, v1 in topology.items():
for k2, v2 in v1.items():
if not set(v2.items()) & set(draw_dict.keys()):
draw_dict.update({(k1, k2): (k3, v3)
for k3, v3 in v2.items()})
return draw_dict
pprint(transform_topology('topology.yaml'))
draw_topology(transform_topology('topology.yaml'),
out_filename='my_17b_topology')
Ограничение: Все задания надо выполнять используя только пройденные темы.
> Для выполнения этого задания, должен быть установлен graphviz:
> apt-get install graphviz
> И модуль python для работы с graphviz:
> pip install graphviz
'''
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
files = [
'sh_cdp_n_sw1.txt', 'sh_cdp_n_r1.txt', 'sh_cdp_n_r2.txt', 'sh_cdp_n_r3.txt'
]
dict = create_network_map(files)
pprint(dict)
draw_topology(dict)
> Для выполнения этого задания, должен быть установлен graphviz:
> apt-get install graphviz
> И модуль python для работы с graphviz:
> pip install graphviz
R2 {'Eth 0/0': {'SW1': 'Eth 0/2'}, 'Eth 0/1': {'R5': 'Eth 0/0'}, 'Eth 0/2': {'R6': 'Eth 0/1'}}
R4 {'Eth 0/0': {'SW1': 'Eth 0/4'}, 'Eth 0/1': {'R5': 'Eth 0/1'}}
R6 {'Eth 0/1': {'R2': 'Eth 0/2'}}
"""
import yaml
from draw_network_graph import draw_topology
def transform_topology(fname):
with open(fname) as f:
raw=yaml.safe_load(f)
dict1={}
for dev,neigh in raw.items():
#print(dev,neigh)
for l_intf,remote in neigh.items():
#print(l_intf,remote)
r_dev, r_intf = list(remote.items())[0]
if not (r_dev,r_intf) in dict1:
dict1[(dev,l_intf)] = (r_dev,r_intf)
return dict1
if __name__ == '__main__':
a=transform_topology('topology.yaml')
draw_topology(a)