def run(self):
""" 从队列中拿到一个包，做适当转换后，交给链路层 """
while True:
# 如果队列为空，那就等直到队列中有包
while route_send_package.qsize() == 0:
# NOTICE:此处循环可能会导致性能下降，CPU占用率100%
time.sleep(0.2)
continue
# 从队列中获得一个包
ip_package = route_send_package.get()
# DEBUG信息
logger.debug(' this package will be modiflied according to route table !')
logger.debug(ip_package)
# 使用成员函数处理IP包，修改其中的dest_ip字段，获得新的IP包
ret_ip_package = self.ip_package_modifier(ip_package) # type: Optional["IP_Package"]
if ret_ip_package == None:
logger.info('{} is unreachable. \nShow your route table by "show route table"'.format(ip_package.final_ip))
continue
# DEBUG信息
logger.debug('ip pkg has been modified. now forwarding...\n modified package is below')
logger.debug(ret_ip_package)
# 发送IP包
link_layer.send(ret_ip_package.to_bytes())
def run(self) -> None:
logger.debug('network layer listerner begin to work')
while True:
recv = self.network_layer.recv()
if recv:
logger.info('network layer pkg received\n{}'.format(recv))
time.sleep(0.1)
def onchange_refresh_route_table(src, dst, changeto):
graph[src][dst] = changeto
graph[dst][src] = changeto
ret = calculate_shortest_path(ROUTER_INDEX)
route.my_route_table.reset_route_table()
for item in ret:
route.my_route_table.update_item(*item)
logger.info('refresh route table fishied.\n%s', ret)
def run_ping(self):
logger.info("tracking direct router neighbor threading run...")
for interface in self.network_layer.interfaces:
src_ip = interface.vip
dst_ip = interface.counter_vip
netmask = interface.netmask
msg = {'code': 0, 'msg': "are you still here?"}
self.network_layer.send(src_ip, dst_ip, utilities.objEncode(msg),
100)
logger.debug('send ping from %s to %s', src_ip, dst_ip)
def run(self):
"""
Run all the steps at one time
"""
logger.info('Add the world condition')
logger.info('Create question for each country')
self.create_country_q()
# Run the condition formating for all the questions
self.format_condition()
self.insert_code_in_dict()
def logout_refresh_route_table(index):
if index in disable_node:
return
disable_node.append(index)
logger.info('refreshing router table ,logout index is %d', index)
for i in range(V):
graph[index][i] = -1
graph[i][index] = -1
ret = calculate_shortest_path(ROUTER_INDEX)
route.my_route_table.reset_route_table()
for a, b, c in ret:
route.my_route_table.update_item(a, b, c)
logger.info('refresh route table fishied.\n%s', ret)
def run(self):
while True:
time.sleep(5)
self.tracking_direct_router_neighbour.run_ping()
time.sleep(3)
#logger.debug('-----------------tracking is alive running-----------------')
for interface in self.track:
#logger.debug('--------------interface----------\n%s', interface)
if self.track[interface] == 0:
if interface not in self.dead_interfaces:
self.dead_interfaces.append(interface)
cvip = interface[1]
logger.info('######## ip %s logout! #########', cvip)
# broadcast
index = interface2index[(cvip,
24)] #TODO:: hard code subnet
logger.info('broadcast logout index ##### %d', index)
logout_refresh_route_table(index)
self.broadcast_logout(
index) #TODO: here, continue. not work
# self.track.remove(interface)
else:
self.track[interface] = 0
for interface in self.dead_interfaces:
ip = interface[1]
logger.info('[logout] logout ip is %s', ip)
index = interface2index[(ip, 24)]
logger.info('[logout] logout index is %d\n', index)
def SubsystemPortMapping(self, req):
portstatus = req.data[self.config['portstatus_index']]
vmname = req.data[self.config['vmname_index']]
guestport = req.data[self.config['guestport_index']]
hostport = req.data[self.config['hostport_index']]
vmip = socket.gethostbyname(vmname)
if portstatus == 'adding':
iptables_cmd = '%s %s PREROUTING -p tcp --dport %s -j DNAT --to %s:%s' \
%(self.config['cmd_iptables'], '-A', hostport, vmip, guestport)
logger.info('Add port mapping for %s, from %s to %s on hostmachine'%(vmname, guestport, hostport))
elif portstatus == 'deleting':
iptables_cmd = '%s %s PREROUTING -p tcp --dport %s -j DNAT --to %s:%s' \
%(cmd_iptables, '-D', hostport, vmip, guestport)
logger.info('Delete port mapping for %s, from %s to %s on hostmachine'%(vmname, guestport, hostport))
(result, value) = pexpect.run(iptables_cmd, withexitstatus = 1)
def run(self):
logger.info('network layer listener begin to work...')
while True:
ospf_pkg = self.network_layer.recv_ospf()
ordinary_pkg = self.network_layer.recv()
if ospf_pkg is None and ordinary_pkg is None:
time.sleep(0.01)
continue
if ospf_pkg:
src_ip = ospf_pkg.dest_ip
dest_ip = ospf_pkg.src_ip
netmask = ospf_pkg.net_mask
if ospf_pkg.protocol != 119:
logger.error(
'error! get ospf pkg, protocol is %d instead of 119',
ospf_pkg.protocol)
ospf_msg = utilities.objDecode(ospf_pkg.data)
logger.info("get ospf msg\n%s", ospf_msg)
if ospf_msg['code'] == 0:
if not is_controller:
logger.warn(
"IM NOT CONTROLLER. get request msg. ignore.")
continue
src_index = ospf_msg['src_index']
init_global_route_table(GLOBAL_ROUTE_INFORMATIOIN_FILE,
src_index)
sp = calculate_shortest_path(src_index)
response_msg = {
"code": 1,
"msg": "here's your route table",
"route_table": sp
}
response_msg_bytes = utilities.objEncode(response_msg)
pkg = route.IP_Package(src_ip, dest_ip, dest_ip, netmask,
response_msg_bytes)
pkg.protocol = 119
errno = route.link_layer.send(pkg.to_bytes())
if errno < 0:
logger.warning(
'fail to send to link layer. errno is %d\n', errno)
elif ospf_msg['code'] == 1:
logger.info('get route table response msg\n%s', ospf_msg)
route_table = ospf_msg['route_table']
for dest_net, netmask, dest_ip in route_table:
route.my_route_table.update_item(
dest_net, netmask, dest_ip)
if ordinary_pkg:
#TODO: refine here
logger.info("get odinary msg\n%s", ordinary_pkg)
def calculate_shortest_path(src: int):
ret = []
dist, prev = shortestPath.SPFA(graph, src)
logger.debug("[controller] finished run spfa\n dist %s \n prev %s\n", dist,
prev)
logger.debug("[controller, info] interface2index\n%s", interface2index)
logger.debug("[controller, info] index2interface\n%s", index2interface)
for ip, netmask in interface2index:
# 自己的端口不需要作转发
if interface2index[(ip, netmask)] == src:
continue
logger.debug('[controller] dealing with %s, %s', ip, netmask)
subnet = utilities.get_subnet(ip, netmask)
index = interface2index[(ip, netmask)]
prev_index = prev[index]
if prev_index == -1:
continue
if prev_index == src:
target_index = interface2index[(ip, netmask)]
(dst_ip, dst_nm) = index2interface[target_index]
# route.my_route_table.update_item(ip, netmask, dst_ip)
ret.append((ip, netmask, dst_ip))
logger.info(
'[1]add item into response msg\n \
%s, %s, %s', ip, netmask, dst_ip)
else:
try_get = index2interface.get(prev_index)
while try_get is None:
prev_index = prev[prev_index]
try_get = index2interface.get(prev_index)
prev_ip, prev_netmask = try_get
# route.my_route_table.update_item(ip, netmask, prev_ip)
ret.append((ip, netmask, prev_ip))
logger.info(
'[2]add item into response msg\n \
%s, %s, %s', ip, netmask, prev_ip)
logger.debug("calculation return value\n%s", ret)
return ret
def SubsystemPortmappingTest(self):
print 'hi this is portmapping'
vmid = 472
guestport = 22
vmname = 'ot32em-8-8'
portstatus = 'adding'
hostport = 4000
vmip = socket.gethostbyname(vmname)
if portstatus == 'adding':
iptables_cmd = '%s %s PREROUTING -p tcp --dport %s -j DNAT --to %s:%s' \
%(self.config['cmd_iptables'], '-A', hostport, vmip, guestport)
logger.info('Add port mapping for %s, from %s to %s on hostmachine'%(vmname, guestport, hostport))
elif portstatus == 'deleting':
iptables_cmd = '%s %s PREROUTING -p tcp --dport %s -j DNAT --to %s:%s' \
%(cmd_iptables, '-D', hostport, vmip, guestport)
logger.info('Delete port mapping for %s, from %s to %s on hostmachine'%(vmname, guestport, hostport))
(result, value) = pexpect.run(iptables_cmd, withexitstatus = 1)
def SubsystemPortMapping(self, req):
portstatus = req.data[self.config['portstatus_index']]
vmname = req.data[self.config['vmname_index']]
guestport = req.data[self.config['guestport_index']]
hostport = req.data[self.config['hostport_index']]
vmip = socket.gethostbyname(vmname)
if portstatus == 'adding':
iptables_cmd = '%s %s PREROUTING -p tcp --dport %s -j DNAT --to %s:%s' \
%(self.config['cmd_iptables'], '-A', hostport, vmip, guestport)
logger.info(
'Add port mapping for %s, from %s to %s on hostmachine' %
(vmname, guestport, hostport))
elif portstatus == 'deleting':
iptables_cmd = '%s %s PREROUTING -p tcp --dport %s -j DNAT --to %s:%s' \
%(cmd_iptables, '-D', hostport, vmip, guestport)
logger.info(
'Delete port mapping for %s, from %s to %s on hostmachine' %
(vmname, guestport, hostport))
(result, value) = pexpect.run(iptables_cmd, withexitstatus=1)
def SubsystemPortmappingTest(self):
print 'hi this is portmapping'
vmid = 472
guestport = 22
vmname = 'ot32em-8-8'
portstatus = 'adding'
hostport = 4000
vmip = socket.gethostbyname(vmname)
if portstatus == 'adding':
iptables_cmd = '%s %s PREROUTING -p tcp --dport %s -j DNAT --to %s:%s' \
%(self.config['cmd_iptables'], '-A', hostport, vmip, guestport)
logger.info(
'Add port mapping for %s, from %s to %s on hostmachine' %
(vmname, guestport, hostport))
elif portstatus == 'deleting':
iptables_cmd = '%s %s PREROUTING -p tcp --dport %s -j DNAT --to %s:%s' \
%(cmd_iptables, '-D', hostport, vmip, guestport)
logger.info(
'Delete port mapping for %s, from %s to %s on hostmachine' %
(vmname, guestport, hostport))
(result, value) = pexpect.run(iptables_cmd, withexitstatus=1)
def run(self) -> None:
logger.debug('network layer listener begin to work')
while True:
for protocol in ['rip', 'cost']:
if protocol == 'rip':
pkg = network_layer.recv_rip()
if pkg is None:
continue
if(pkg.protocol == 120):
rip_msg = utilities.objDecode(pkg.data)
rip_worker.process(rip_msg)
elif protocol == 'cost':
pkg = network_layer.recv_cost()
if pkg is None:
continue
if(pkg.protocol == 121):
cost_msg = utilities.objDecode(pkg.data)
_vip = cost_msg['vip']
_cost = cost_msg['cost']
for intf in rip_worker.interfaces:
if intf.vip == _vip:
logger.info('Cost %s -> %s changed to %d', rip_worker.route_name, intf.counter_name, _cost)
rip_worker.dis_vec[intf.counter_name]['cost'] = _cost
time.sleep(0.01)
def main():
# Get the file and transform it to create all the questions and conditions for each country
logger.info(
'Getting the file and transforming it for the country specific conditions'
)
getting_question = gettingQuestions()
getting_question.run()
# Init the survey creation process
logger.info('Init the survey creation')
creating_survey = surveyCreation(getting_question.dict_questions)
logger.info('Running the survey creation')
creating_survey.run()
def do_connectDevice(self, inp):
"""Connect to a serial device.
Shows list of open devices and prompts selection."""
logger.info("Listing devices")
# Get a list of the available serial ports
self.device.closePort()
ports = self.device.listDevices()
portNames = []
# Get device names and print to screen
i = 0
for port in ports:
logger.info("Device found: %s", port)
portNames.append(port.device)
# Format
print(str(i) + " " + str(port))
i = i + 1
# Prompt user to select serial device
while True:
selection = input("Enter selection[q(quit)]: ")
if selection is "q":
return False
# Verify valid selction
try:
selection = int(selection)
except:
print("Invalid option...try again")
continue
if selection < len(portNames):
self.device.setPort(portNames[selection])
self.device.openPort()
setLocalOption({'lastPort':portNames[selection]})
logger.info("Selecting device: %s", portNames[selection])
break
else:
print("Selection out of range...try again")
def task(self):
time.sleep(0.1)
msg_queue = []
msg_queue.append(self.network_layer.recv_ospf())
msg_queue.append(self.network_layer.recv())
msg_queue.append(self.network_layer.recv_ping())
available_msg = [msg for msg in msg_queue if not msg is None]
for msg in available_msg:
if msg.protocol == 100:
data = utilities.objDecode(msg.data)
sip = msg.src_ip
dip = msg.dest_ip
netmask = msg.net_mask
if data['code'] == 0:
# get ping request from other
logger.info('get ping from %s\n', sip)
msg = {'code': 1, 'msg': 'I am here.'}
self.network_layer.send(dip, sip, utilities.objEncode(msg),
100)
if data['code'] == 1:
# get ping response from it
logger.info('ping response. I know %s reachable', sip)
self.tracking_neighbour_alive.wakeup(dip, sip)
elif msg.protocol == 119:
data = utilities.objDecode(msg.data)
msgid = data['id']
if msgid in known_msgid_list:
# logger.debug('already know %d, continue', msgid)
continue
known_msgid_list.append(msgid)
self.broadcastMsg(data, 119)
msg_type = data['type']
if msg_type == 'logout':
# pass #TODO: here, maybe bugs
lgout_index = data['index']
logger.info(
'get logout broadcast. now refresh route table according to broadcast %d',
lgout_index)
logout_refresh_route_table(lgout_index)
else:
logger.debug('recv msg!!\n%s', msg)
def run(self):
""" 启动一个新的线程，监听一个端口 """
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
self.server_socket.bind(self.pip_port)
self.server_socket.listen(config.MAX_TCP_LINK)
# 等待网线那一头，直连的Interface与我建立连接
(client_socket, address) = self.server_socket.accept()
# 等待网线那一头的Interface给我发消息
rdt_s = rdt_socket.rdt_socket(client_socket)
while True:
data = rdt_s.recvBytes()
# NOTICE:应该直接将二进制对象放到队列中
# pkg = IP_Package.bytes_package_to_object(data)
link_buf.put(data)
if IP_Package.bytes_package_to_object(data).protocol == 120:
continue
logger.info('--------------------------------------------------')
logger.info("Link layer pkg received\n{}".format(
IP_Package.bytes_package_to_object(data)))
logger.info('--------------------------------------------------')
def portmapping(self, vmname, vmip, vmport, hostport, action):
if action == 'a':
iptables_cmd = '%s %s PREROUTING -p tcp --dport %s -j DNAT --to %s:%s' \
%(self.cmd_iptables, '-A', hostport, vmip, vmport)
logger.info('Add port mapping for %s, from %s to %s on hostmachine'%(vmname, vmport, hostport))
logger.debug(iptables_cmd)
elif action == 'd':
iptables_cmd = '%s %s PREROUTING -p tcp --dport %s -j DNAT --to %s:%s' \
%(self.cmd_iptables, '-D', hostport, vmip, vmport)
logger.info('Delete port mapping for %s, from %s to %s on hostmachine'%(vmname, vmport, hostport))
logger.debug(iptables_cmd)
else :
logger.error('Error argument!')
return 0
(result, value) = pexpect.run(iptables_cmd, withexitstatus = 1)
if value != 0 :
logger.error(result)
return 0
return 1
if connect:
logger.info('Start.')
logger.info('Database connected.')
while 1:
query_portreq = "SELECT * FROM %s WHERE state='adding' \
OR state='deleting 'ORDER BY hostport"%(porttb)
db.query(query_portreq)
req_res = db.store_result()
fetched_req_data = req_res.fetch_row()
while fetched_req_data:
state = fetched_req_data[0][idx_state]
vmname = fetched_req_data[0][idx_vmname]
vmport = fetched_req_data[0][idx_vmport]
oldhostport = fetched_req_data[0][idx_hostport]
if (state == 'adding') :
vmip = socket.gethostbyname(vmname)
newport = oldhostport
if (newport == '-1') :
newport = get_port()
if (newport != -1) :
portmapping(vmname, vmip, vmport, newport, 'a')
query = "UPDATE %s SET state='using', \
hostport='%s', ip='%s' \
WHERE hostport=%s"%(porttb, newport, vmip, oldhostport)
db.query(query)
else :
logger.error('No more port!')
elif (fetched_req_data[0][idx_state] == 'deleting') :
#delete port
vmip = fetched_req_data[0][idx_ip]
portmapping(vmname, vmip, vmport, oldhostport, 'd')
query = "DELETE FROM %s WHERE hostport=%s"%(porttb, oldhostport)
db.query(query)
else :
logger.error("I don't know what's wrong!")
fetched_req_data = req_res.fetch_row()
time.sleep(sleep_time)
def portmapping(self, vmname, vmip, vmport, hostport, action):
if action == 'a':
iptables_cmd = '%s %s PREROUTING -p tcp --dport %s -j DNAT --to %s:%s' \
%(self.cmd_iptables, '-A', hostport, vmip, vmport)
logger.info(
'Add port mapping for %s, from %s to %s on hostmachine' %
(vmname, vmport, hostport))
logger.debug(iptables_cmd)
elif action == 'd':
iptables_cmd = '%s %s PREROUTING -p tcp --dport %s -j DNAT --to %s:%s' \
%(self.cmd_iptables, '-D', hostport, vmip, vmport)
logger.info(
'Delete port mapping for %s, from %s to %s on hostmachine' %
(vmname, vmport, hostport))
logger.debug(iptables_cmd)
else:
logger.error('Error argument!')
return 0
(result, value) = pexpect.run(iptables_cmd, withexitstatus=1)
if value != 0:
logger.error(result)
return 0
return 1
if connect:
logger.info('Start.')
logger.info('Database connected.')
while 1:
query_portreq = "SELECT * FROM %s WHERE state='adding' \
OR state='deleting 'ORDER BY hostport" % (porttb)
db.query(query_portreq)
req_res = db.store_result()
fetched_req_data = req_res.fetch_row()
while fetched_req_data:
state = fetched_req_data[0][idx_state]
vmname = fetched_req_data[0][idx_vmname]
vmport = fetched_req_data[0][idx_vmport]
oldhostport = fetched_req_data[0][idx_hostport]
if (state == 'adding'):
vmip = socket.gethostbyname(vmname)
newport = oldhostport
if (newport == '-1'):
newport = get_port()
if (newport != -1):
portmapping(vmname, vmip, vmport, newport, 'a')
query = "UPDATE %s SET state='using', \
hostport='%s', ip='%s' \
WHERE hostport=%s" % (porttb, newport, vmip,
oldhostport)
db.query(query)
else:
logger.error('No more port!')
elif (fetched_req_data[0][idx_state] == 'deleting'):
#delete port
vmip = fetched_req_data[0][idx_ip]
portmapping(vmname, vmip, vmport, oldhostport, 'd')
query = "DELETE FROM %s WHERE hostport=%s" % (
porttb, oldhostport)
db.query(query)
else:
logger.error("I don't know what's wrong!")
fetched_req_data = req_res.fetch_row()
time.sleep(sleep_time)
def run(self):
logger.info('network layer listener begin to work...')
while True:
self.task()
elif main_action == 'start':
# 开启RIP协议
rip_worker.start()
elif main_action == 'add':
# 往路由表中增加表项
route.my_route_table.update_item(user_args[1], int(user_args[2]), user_args[3])
elif main_action == 'delete':
# 删除某一项
route.my_route_table.delete_item(user_args[1], int(user_args[2]))
for rname, lvip_mask in rip_worker.topo.items():
for lvip, lmask in lvip_mask:
if user_args[1] == lvip and int(user_args[2]) == lmask:
if rname in rip_worker.direct_routes:
print("Cannot delete, {} is a directly connected route")
else:
logger.info('[RIP] Reset cost %s to %s to INF', network_layer.name, rname)
rip_worker.dis_vec[rname]['cost'] = DV_INF
rip_worker.dis_vec[rname]['path'] = []
elif main_action == 'send':
# 发送信息
network_layer.send(user_args[1], user_args[2], user_args[3].encode('ascii'))
elif main_action == 'recv':
# 非阻塞接受IP包
ip_pkg = network_layer.recv()
if ip_pkg == None:
print('no receive!')
else:
print(ip_pkg)
elif main_action == 'offline':
rip_worker.working_flag = False
for rname, detail in rip_worker.dis_vec.items():
@require_device
def do_getSpiState(self, inp):
"Get SPI State"
STMReceiveCode = 3 # Integer code that the STM looks for
self.device.writeInt8(STMReceiveCode)
state = self.device.readBytes(1)
states = ["HAL_SPI_STATE_RESET: Peripheral not Initialized",
"HAL_SPI_STATE_READY: Peripheral Initialized and ready for use",
"HAL_SPI_STATE_BUSY: an internal process is ongoing",
"HAL_SPI_STATE_BUSY_TX: Data Transmission process is ongoing",
"HAL_SPI_STATE_BUSY_RX: Data Reception process is ongoing",
"HAL_SPI_STATE_BUSY_TX_RX: Data Transmission and Reception process is ongoing",
"HAL_SPI_STATE_ERROR: SPI error state",
"HAL_SPI_STATE_ABORT: Abort state"]
print("State: "+str(state[0]))
print(states[state[0]])
if __name__ == '__main__':
logger.info("---Starting rUI---")
# Driver
p = rUI()
p.cmdloop()
def process(self, rip_msg : dict):
medium = rip_msg['from']
# 步骤一：阻止含有之前已经处理过的离线的路由器的信息的rip报文
if medium in self.tear_down:
return
for rname, detail in rip_msg['dv'].items():
for drname in self.tear_down:
if drname in detail['path']:
logger.debug("[RIP] [Dropped] DV of %s contain offline route %s", medium, drname)
return
for rname in rip_msg['topo'].keys():
if rname in self.tear_down:
logger.debug("[RIP] [Dropped] TOPO of %s contain offline route %s", medium, rname)
return
logger.debug("[RIP] received rip package from %s", medium)
new_tear_down = set(rip_msg['tear_down']) - set(self.tear_down)
self.tear_down = list(set().union(self.tear_down, rip_msg['tear_down']))
# 步骤二：删除自身所有有关新得知的离线了的路由器的信息
# 删除距离向量中的这一行
if len(new_tear_down) != 0:
to_del = []
for drname in new_tear_down:
if drname in self.dis_vec.keys():
to_del.append(drname)
for drname in to_del:
del self.dis_vec[drname]
# 删除距离向量中所有途径offline路由器的
to_del = []
for drname in new_tear_down:
for rname, detail in self.dis_vec.items():
if drname in detail['path']:
to_del.append(rname)
for rname in to_del:
del self.dis_vec[rname]
for drname in new_tear_down:
# 删除路由表中有关的
for vip, nm in self.topo[drname]:
route.my_route_table.delete_item(vip, nm)
route.my_route_table.delete_item(utilities.get_subnet(vip, nm), nm)
# 网络层端口中将其设为offline
for intf in network_layer.interfaces:
if intf.counter_name == drname:
intf.status = "offline"
# 删除关于它的拓扑记录
del self.topo[drname]
self.dis_mat = {}
for intf in self.interfaces:
self.dis_mat[intf.counter_name] = {}
return
for dest, intfs in rip_msg['topo'].items():
if dest not in self.topo:
self.topo[dest] = intfs
logger.info("[RIP] learned topo of {} : {}".format(dest, intfs))
if dest in self.direct_routes:
for vip, netmask in intfs:
logger.info("[RIP] Updating route table\n{} {} THROUTH {}".format(vip, netmask, self.next_hop[dest]))
route.my_route_table.update_item(vip, netmask, self.next_hop[dest])
# 步骤三：更新自己的距离向量和拓扑图,因为可能学习到新的节点
# if medium not in self.topo.keys():
# self.topo[medium] = rip_msg['intfs']
if medium not in self.dis_vec.keys():
logger.critical("Unexpected rip msg from %s", rip_msg['from'])
else:
mininum = DV_INF
for dest, detail in rip_msg['dv'].items():
if not dest in self.topo.keys():
continue
cost = detail['cost']
newcost = self.dis_vec[medium]['cost'] + cost
if dest == self.route_name:
continue
elif dest not in self.dis_vec.keys():
newpath = detail['path']
newpath.insert(0, self.route_name)
self.dis_vec[dest] = \
{
"cost": newcost,
"path": newpath
}
logger.info("[RIP] New shortest path found\n{} -> {} cost {}, path: {}".format(
self.route_name, dest, self.dis_vec[dest]['cost'], self.dis_vec[dest]['path']))
for vip, netmask in self.topo[dest]:
logger.info("[RIP] Updating route table\n{} {} THROUTH {}".format(vip, netmask, self.next_hop[medium]))
route.my_route_table.update_item(vip, netmask, self.next_hop[medium])
# 步骤四：更新距离矩阵中的一行
self.dis_mat[medium] = rip_msg['dv']
logger.debug('{}'.format(utilities.obj_to_beautiful_json(self.dis_mat)))
# 步骤五：运行核心的dv算法
for dest, detail in self.dis_vec.items():
# 直连的链路cost不在这里更新cost，只在cost change protocol中更新
if dest in self.direct_routes:
continue
# 不需要对未知子网Interfaces情况的路由器计算距离，计算了也没用，也加不了路由表
if not dest in self.topo.keys():
continue
mininum = DV_INF
new_path = []
medium = ''
for entry_route, dv in self.dis_mat.items():
# 去不到就continue，相当于设置了正无穷
if dest not in dv.keys():
continue
new_cost = self.dis_vec[entry_route]['cost'] + dv[dest]['cost']
if new_cost < mininum:
# 毒性逆转(poisoned reverse)
# 如果可能的最短路径中包含目的节点自身
if dest in dv[dest]['path'] and dest != dv[dest]['path'][-1]:
continue
logger.debug('maybe shortest : {} to {}'.format(self.route_name, dest))
logger.debug('{} plus {}'.format(dest, dv[dest]['path']))
mininum = new_cost
medium = entry_route
new_path = dv[dest]['path']
if new_path[0] != self.route_name:
new_path.insert(0, self.route_name)
# 更新距离向量和路由表，并打印适量调试信息
old_cost = detail['cost']
detail['cost'] = mininum
if mininum >= DV_INF:
detail['path'] = []
else:
logger.debug("{} to {} now walks {}".format(self.route_name, dest, new_path))
detail['path'] = new_path
if medium != '':
for vip, netmask in self.topo[dest]:
route.my_route_table.update_item(vip, netmask, self.next_hop[medium])
if old_cost != detail['cost']:
logger.info("[RIP] New shortest path found\n{} -> {} cost {}, path: {}".format(
self.route_name, dest, self.dis_vec[dest]['cost'], self.dis_vec[dest]['path']))
def create_survey_settings(self):
"""
Add the welcome and the end message and set up the different setting in the survey
"""
def get_text(type_message, lang=None):
"""
"""
if lang and lang != "en":
filename = "{}_message_{}.md".format(type_message, lang)
else:
filename = "{}_message.md".format(type_message)
folder = os.path.join(self.year, "texts")
path = os.path.join(folder, filename)
with open(path, "r") as f:
html_file = markdown(f.read())
# Need to add target="_blank" to the link for opening in new tab in limesurvey
soup = BeautifulSoup(html_file, "html.parser")
links = soup.find_all("a")
for link in links:
link["target"] = "_blank"
return soup
for lang in self.languages:
logger.info(
'Creating the questions for the language: {}'.format(lang))
# All these None are a workaround to fix the bug that add
# two titles for the second language. No idea why
survey_settings = None
setting_with_lang = None
survey_title = None
survey_title_row = None
# Get the welcome message
welcome_message = get_text("welcome", lang)
# Get the end message
end_message = get_text("end", lang)
survey_settings = self._to_modify(
static_headers.global_settings,
specific_config.settings_to_modify)
survey_settings = self._to_add(survey_settings,
specific_config.settings_to_add)
survey_title = specific_config.survey_title[lang]
survey_title_row = {
"class": "SL",
"name": "surveyls_title",
"text": survey_title,
}
survey_settings.insert(0, survey_title_row)
survey_settings = self._add_text_message(survey_settings,
welcome_message,
"welcome")
survey_settings = self._add_text_message(survey_settings,
end_message, "end")
# adding the policy data
# consent_message = get_text('consent', lang)
# survey_settings = self._add_text_message(survey_settings, consent_message, 'policy_notice')
# Add the appropriate language field for each of the dictionary
setting_with_lang = list()
for d in survey_settings:
d["language"] = lang
setting_with_lang.append(d)
self._record_list(setting_with_lang)
