def _test_import_firmware(self):
"""
Try's to get the firmware-image two times. At least the second try the firmware should be stored on the device
and imported.
"""
print("Test FirmwareHandler: import_firmware ...")
# Create router
router = Router(1, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1",
24, "root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
assert isinstance(router, Router)
# Create firmware_handler
release_model = "stable"
url = "https://firmware.darmstadt.freifunk.net"
download_all = False
firmware_handler = FirmwareHandler(url)
assert isinstance(firmware_handler, FirmwareHandler)
# Downloads the firmware-image
firmware_handler.download_firmware(router.model, release_model)
# Imports the firmware-image from the local storage
firmware = firmware_handler.get_firmware(router.model, release_model,
download_all)
assert isinstance(firmware, Firmware)
assert firmware.name == "gluon-ffda-0.7.3-tp-link-tl-wr841n-nd-v9-sysupgrade.bin"
assert firmware.version == "0.7.3"
assert firmware.freifunk_verein == "ffda"
assert firmware.release_model == "stable"
assert firmware.file == (
FIRMWARE_PATH +
'/stable/sysupgrade/gluon-ffda-0.7.3-tp-link-tl-wr841n-nd-v9-sysupgrade.bin'
)
def _test_check_hash_firmware(self):
"""
Downloads a single firmware-image.
"""
print("Test FirmwareHandler: check_hash_firmware ...")
# Create router
router = Router(1, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1",
24, "root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
assert isinstance(router, Router)
# Create firmware_handler
release_model = "stable"
url = "https://firmware.darmstadt.freifunk.net"
download_all = False
firmware_handler = FirmwareHandler(url)
assert isinstance(firmware_handler, FirmwareHandler)
# Imports the Firmware if already existing or downloads it
firmware = firmware_handler.get_firmware(router.model, release_model,
download_all)
assert isinstance(firmware, Firmware)
incorrect_hash = "2b83a03e961f2e0a7fe1817e86e9caf248fbe440d12acda5a5c78de8a7d4f25ec48282cb8562d4b3b5e3c0"
assert not firmware.check_hash(incorrect_hash)
assert firmware.check_hash(firmware.hash)
def _test_get_single_firmware(self):
"""
Downloads a single firmware-image.
"""
print("Test FirmwareHandler: get_single_firmware ...")
# Create router
router = Router(1, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1",
24, "root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
assert isinstance(router, Router)
# Create firmware_handler
release_model = "stable"
url = "https://firmware.darmstadt.freifunk.net"
download_all = False
firmware_handler = FirmwareHandler(url)
assert isinstance(firmware_handler, FirmwareHandler)
# Imports the Firmware if already existing or downlaods it
firmware = firmware_handler.get_firmware(router.model, release_model,
download_all)
assert isinstance(firmware, Firmware)
assert firmware.name == "gluon-ffda-0.7.3-tp-link-tl-wr841n-nd-v9-sysupgrade.bin"
assert firmware.version == "0.7.3"
assert firmware.freifunk_verein == "ffda"
assert firmware.release_model == "stable"
assert firmware.file == (
FIRMWARE_PATH +
'/stable/sysupgrade/gluon-ffda-0.7.3-tp-link-tl-wr841n-nd-v9-sysupgrade.bin'
)
def test_router_wget(self):
# Create router
router = Router(1, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1",
24, "root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
# Has to be matched with the current mode (normal, configuration)
router.mode = Mode.configuration
assert isinstance(router, Router)
# Create NetworkCrtl
network_ctrl = NetworkCtrl(router, 'eth0')
assert isinstance(network_ctrl, NetworkCtrl)
self.assertRaises(Exception, network_ctrl.connect_with_remote_system())
# Create test file 'test_wget.txt'
path = os.path.dirname(__file__)
file = open(path + '/test_wget.txt', 'w+')
# The Router downloads this file via wget from the raspberryPi
network_ctrl.remote_system_wget(path + '/test_wget.txt', '/tmp/')
# Tests if the file has successful downloaded
output = network_ctrl.send_command(
"test -f '/tmp/test_wget.txt' && echo True")
self.assertEqual(output, "['True\\n']")
# Test
output = network_ctrl.send_command(
"rm '/tmp/test_wget.txt' && echo True")
self.assertEqual(output, "['True\\n']")
file.close()
network_ctrl.exit()
def test_setup_expert(self):
"""
This UnitTest executes the wca_setup_expert-function with the given config-file.
It sets the values of all the from WebInterface of the Router.
"""
# Create router
router = Router(1, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1",
24, "root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
router.mode = Mode.configuration
assert isinstance(router, Router)
# Config
config = ConfigManager().get_web_interface_dict()[0]
self.assertEqual(len(config), 30, "Wrong size of the Config-Directory")
# Create NetworkCrtl
network_ctrl = NetworkCtrl(router, 'eth0')
assert isinstance(network_ctrl, NetworkCtrl)
try:
web_config_assist = RouterWebConfiguration(router,
config,
wizard=True)
web_config_assist.start()
web_config_assist.join()
except Exception as e:
Logger().error(str(e))
finally:
assert router.mode == Mode.normal
network_ctrl.exit()
def get_router_manual_list() -> []:
"""
Read the Router Manual Config file
:return: List with any Router objects from the file
"""
output = ConfigManager.get_router_manual_config()
router_list = []
for i in range(0, len(output)):
router_info = output[i]
if not len(router_info) == 9:
Logger().error(
"List must be length of 9 but has a length of {0}".format(
len(output)))
return
try:
v = Router(i, router_info['Name'], router_info['Id'],
router_info['IP'], router_info['IP_Mask'],
router_info['CONFIG_IP'],
router_info['CONFIG_IP_MASK'],
router_info['Username'], router_info['Password'],
router_info['PowerSocket'])
router_list.append(v)
except Exception as ex:
Logger().error(
"Error at building the list of Router's\nError: {0}".
format(ex))
return router_list
def test_create_Router(self):
router = Router(0, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1", 24, "root", "root", 1)
router.mode = Mode.normal
assert isinstance(router, Router)
assert router.ip == "10.223.254.254"
assert router.ip_mask == 16
def __init__(self):
load_dotenv()
self.__branch_nbr = STARTER
self.__page_nbr = INITIAL_PAGE
self.__next_page_nbr = 0
self.__beverages_subcategories = set()
self.__food_subcategories = set()
self.__list_of_prods = None
self.__subcategory = None
self.__product = None
self.__router = Router()
self.__view = View()
self.__starter_controller = StarterController()
self.__substitute_controller = SubstituteController()
self.__favorites_controller = FavoritesController()
self.__trunk_controller = TrunkController()
self.__root_controller = RootController()
self.memory = {
"best_products": None,
"chosen_pair": None,
"fav_prod": None,
"list_of_pairs__original_v_substitutes": None,
"list_of_products": None,
"product": None,
"subcategory_name": None,
"substitute_product": None
}
def _create_router(self):
# Create router
router = Router(0, "vlan21", 21, "10.223.254.254", 16, "192.168.1.1",
24, "root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
assert isinstance(router, Router)
return router
def test_add_information(self):
router = Router(1, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1",
24, "root", "root", 1)
router.ssid = "lol funk"
router.wlan_mode = WlanMode.master
assert router.ssid == "lol funk"
assert router.wlan_mode == WlanMode.master
def _create_router(self):
# Create router
router = Router(0, "vlan21", 21, "10.223.254.254", 16, "192.168.1.1", 24, "root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
# Has to be matched with the current mode (normal, configuration)
router.mode = Mode.normal
assert isinstance(router, Router)
return router
def _create_router(self):
# Create router
router = Router(0, "vlan21", 21, "10.223.254.254", 16, "192.168.1.1", 24, "root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
router.node_name = "64293-testframework1"
router.public_key = "483938492329bc12aa1212d1b"
assert isinstance(router, Router)
return router
def test_router_info(self):
# Create router
router = Router(1, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1", 24, "root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
router.mode = Mode.normal
router_info = RouterInfo(router)
router_info.start()
router_info.join()
def test_reboot_into_config(self):
# Create router
router = Router(1, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1",
24, "root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
router.mode = Mode.normal
assert isinstance(router, Router)
RouterReboot().configmode(router)
assert router.mode == Mode.configuration
def test_optional_getter_setter(self):
router = Router(0, "vlan21", 21, "10.223.254.254", 16, "192.168.1.1",
24, "root", "root", 1)
assert isinstance(router, Router)
router.mode = Mode.configuration
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
router.node_name = "64293-testframework1"
router.public_key = "1234567890abcdef16171819"
network_interface = NetworkInterface(0, "eth0")
assert isinstance(network_interface, NetworkInterface)
router.network_interfaces[network_interface.name] = network_interface
cpu_process = CPUProcess(11, "root", 1.1, 11.2, "echo")
assert isinstance(cpu_process, CPUProcess)
router.cpu_processes.append(cpu_process)
socket = InternetSocket()
assert isinstance(socket, InternetSocket)
router.sockets.append(socket)
ram = RAM(8000, 4000, 4000, 0, 0)
assert isinstance(ram, RAM)
router.ram = ram
flash_driver = Flashdriver(8000, 2000, 6000)
assert isinstance(flash_driver, Flashdriver)
router.flashdriver = flash_driver
router.uci["autoupdater.settings.enabled"] = "1"
bat_originator = BatOriginator(
"00:00:00:00:00:00", 12.2, "01:00:01:00:01:00", "mesh0",
["01:00:01:00:01:00", "21:00:21:00:21:00", "03:00:03:00:03:00"])
assert isinstance(bat_originator, BatOriginator)
router.bat_originators.append(bat_originator)
self.assertEqual(Mode.configuration, router.mode)
self.assertEqual("TP-LINK TL-WR841N/ND v9", router.model)
self.assertEqual("e8:de:27:b7:7c:e2", router.mac)
self.assertEqual("64293-testframework1", router.node_name)
self.assertEqual("1234567890abcdef16171819", router.public_key)
self.assertEqual(network_interface,
router.network_interfaces[network_interface.name])
self.assertEqual(cpu_process, router.cpu_processes.pop())
self.assertEqual(socket, router.sockets.pop())
self.assertEqual(ram, router.ram)
self.assertEqual(flash_driver, router.flashdriver)
self.assertEqual('Firmware not known', router.firmware.name)
self.assertEqual("1", router.uci["autoupdater.settings.enabled"])
self.assertEqual(bat_originator, router.bat_originators.pop())
def get_router_auto_list(count: int = 0) -> []:
"""
Read the Router Manual Config file
:param count: Count of the Router
:return: List with any Router objects from the file
"""
output = ConfigManager.get_router_auto_config()
if not len(output) == 10:
Logger().error(
"List must be length of 10 but has a length of {0}".format(
len(output)))
return
try:
router_count = output[0]
name = output[1]
identifier = output[2]
ip = output[3]
ip_mask = output[4]
config_ip = output[5]
config_ip_mask = output[6]
username = output[7]
password = output[8]
power_socket = output[9]
i = identifier['default_Start_Id']
socket_id = power_socket['powerSocket_Start_Id']
router_list = []
if count <= 0:
count = router_count['router_Count']
else:
count = count
for x in range(0, count):
v = Router(x, name['default_Name'] + "{0}".format(i), i,
ip['default_IP'], ip_mask['default_IP_Mask'],
config_ip['default_CONFIG_IP'],
config_ip_mask['default_CONFIG_IP_MASK'],
username['default_Username'],
password['default_Password'], socket_id)
router_list.append(v)
i += 1
socket_id += 1
return router_list
except Exception as ex:
Logger().error(
"Error at building the list of Router's\nError: {0}".format(
ex))
def main():
bootstrap()
display_introduction()
factory = Router()
command = None
while not is_command_exit(command):
clear_screen()
command = get_command()
try:
factory.execute_command(command)
except Exception as e:
print(e)
def get_routers_list() -> []:
"""
Read the routers from the config
:return: List with any router objects from the file
"""
output = ConfigManager.get_routers_dict()
routers = []
# i must defined before 'for', because 'default' increase i and then the router.id has wrong count
i = 0
for data in output.items():
name, router_info = data
if 'default' in name:
continue
if len(router_info) != 9: # FixMe ist eher eine schlechte idee
logging.error(
"List must be length of 9 but has a length of {0}".format(
len(output)))
return None
# TODO:
# wenn die keys im "router_info" dict mit den argument namen von `Router` passt kann man das so machen:
# router = Router(i, **router_info)
try:
router = Router(i, router_info['Name'], router_info['Id'],
router_info['IP'], router_info['IP_Mask'],
router_info['CONFIG_IP'],
router_info['CONFIG_IP_MASK'],
router_info['Username'],
router_info['Password'],
router_info['PowerSocket'])
routers.append(router)
i += 1
except KeyError as ex:
logging.error(
"Error at building the list of Router's\nError: {0}".
format(ex))
return None
if len(routers) > 0:
routers = sorted(routers, key=lambda e: e.id)
return routers
def test_connection(self):
# Create router
router = Router(1, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1",
24, "root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
# Has to be matched with the current mode (normal, configuration)
router.mode = Mode.configuration
assert isinstance(router, Router)
# Create NetworkCrtl
network_ctrl = NetworkCtrl(router, 'eth0')
assert isinstance(network_ctrl, NetworkCtrl)
# network_ctrl.connect_with_router()
network_ctrl.exit()
def get_routers_list() -> []:
"""
Read the Routers from the config.
:return: List with any Router-Obj from the file
"""
output = ConfigManager.get_routers_dict()
if not output[0]:
return []
routers = []
for data in output[1].items():
name, router_info = data
if 'default' in name:
continue
# TODO:
# wenn die keys im "router_info" dict mit den argument namen von `Router` passt kann man das so machen:
# router = Router(i, **router_info)
try:
router = Router(0, router_info['Name'], router_info['Id'],
router_info['IP'], router_info['IP_Mask'],
router_info['CONFIG_IP'],
router_info['CONFIG_IP_MASK'],
router_info['Username'],
router_info['Password'],
router_info['PowerSocket'])
routers.append(router)
except KeyError as ex:
logging.error(
"Error at building the list of Router's\nError: {0}".
format(ex))
return None
if routers:
routers = sorted(routers, key=lambda e: e.vlan_iface_id)
for i, r in enumerate(routers):
r.set_id(i)
return routers
def test_send_command(self):
# Create router
router = Router(1, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1",
24, "root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
# Has to be matched with the current mode (normal, configuration)
router.mode = Mode.configuration
assert isinstance(router, Router)
# Create NetworkCrtl
network_ctrl = NetworkCtrl(router, 'eth0')
assert isinstance(network_ctrl, NetworkCtrl)
# Test if the command 'uname' could be send via ssh
self.assertRaises(Exception, network_ctrl.connect_with_remote_system())
output = network_ctrl.send_command("uname")
self.assertEqual(output, "['Linux\\n']")
network_ctrl.exit()
def test_create_Router(self):
router = Router(0, "vlan21", 21, "10.223.254.254", 16, "192.168.1.1",
24, "root", "root", 1)
assert isinstance(router, Router)
self.assertEqual(0, router.id)
self.assertEqual("vlan21", router.vlan_iface_name)
self.assertEqual(21, router.vlan_iface_id)
self.assertEqual("nsp21", router.namespace_name)
self.assertEqual("10.223.254.254", router._ip)
self.assertEqual(16, router._ip_mask)
self.assertEqual("192.168.1.1", router._config_ip)
self.assertEqual(24, router._config_ip_mask)
self.assertEqual("root", router.usr_name)
self.assertEqual("root", router.usr_password)
self.assertEqual(1, router.power_socket)
def __init__(self):
self.file_lines = [EMPTY_LINE]
self.current_line_index = FIRST_LINE_INDEX
self.router = Router(self)
self.end = False
import logging
from flask import Flask, request
from router.router import Router, CommandExecutor
from router.interface_finder import InterfaceFinder
from config.flask_config import get_config
app = Flask('Router')
config = get_config()
debug_mode = config.getboolean('router', 'debug')
logging.basicConfig(level=logging.DEBUG)
router = Router(CommandExecutor, InterfaceFinder)
@app.route('/create/network', methods=['POST'])
def create_network():
data = request.get_json()
router.add_network(name=data['id'])
return 'Success\n'
@app.route('/create/logical_port', methods=['POST'])
def create_logical_port():
data = request.get_json()
router.add_logical_port(net=data['net_id'], ip=data['ip'])
return 'Success\n'
app.run(config.get('router', 'listen_address'),
config.getint('router', 'listen_port'), debug_mode)
def route(fin, fout):
r = Router(grid_size=.5, maxflow_enforcement_level=3)
r.route(fin, fout)
from util.router_flash_firmware import RouterFlashFirmware
from router.router import Router, Mode
from config.configmanager import ConfigManager
# Create router
router = Router(1, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1", 24,
"root", "root", 1)
router.model = "TP-LINK TL-WR841N/ND v9"
router.mac = "e8:de:27:b7:7c:e2"
router.mode = Mode.configuration
# Create firware configuration
firmware_config = ConfigManager.get_firmware_dict()[0]
RouterFlashFirmware.sysupdate(router, firmware_config)
RouterFlashFirmware.sysupgrade(router, n=True)
def test_add_information(self):
router = Router(0, "vlan1", 21, "10.223.254.254", 16, "192.168.1.1", 24, "root", "root", 1)
router.ssid = "lol funk"
assert router.ssid == "lol funk"
