298 lines
8.9 KiB
Python
298 lines
8.9 KiB
Python
import ipaddress
|
|
import json
|
|
import textwrap
|
|
from enum import Enum
|
|
import random
|
|
from typing import List, Optional, Union, Dict
|
|
|
|
|
|
class IpMethod(Enum):
|
|
Manual = 0
|
|
Management = 1
|
|
Auto4 = 2
|
|
Auto6 = 3
|
|
Dhcp4 = 4
|
|
Dhcp6 = 5
|
|
|
|
|
|
class Interface:
|
|
def __init__(self, method: IpMethod, rate: Optional[int] = None):
|
|
self._method: IpMethod
|
|
|
|
self._node: Optional[Node] = None
|
|
self._rate: Optional[int] = None
|
|
self._bridge: Optional[Bridge] = None
|
|
|
|
self._method = method
|
|
self._rate = rate
|
|
self._address: ipaddress.ip_address = None
|
|
|
|
def get_method(self):
|
|
return self._method
|
|
|
|
def set_node(self, node):
|
|
self._node = node
|
|
|
|
def get_node(self):
|
|
return self._node
|
|
|
|
def set_bridge(self, bridge):
|
|
self._bridge = bridge
|
|
|
|
def get_bridge(self):
|
|
return self._bridge
|
|
|
|
def set_address(self, addr: ipaddress.ip_address):
|
|
self._address = addr
|
|
|
|
def get_address(self) -> ipaddress.ip_address:
|
|
return self._address
|
|
|
|
def get_rate(self) -> Optional[int]:
|
|
return self._rate
|
|
|
|
def set_rate(self, rate: Optional[int]):
|
|
self._rate = rate
|
|
|
|
|
|
class Bridge:
|
|
def __init__(self, *interfaces: Interface):
|
|
self._interfaces: List[Interface] = []
|
|
self._name: str = ''
|
|
|
|
for interface in interfaces:
|
|
self._interfaces.append(interface)
|
|
interface.set_bridge(self)
|
|
|
|
# Generate a random class c private range by default (10.0.0.0)
|
|
self.netmask = 24
|
|
self._addr: ipaddress.ip_address = ipaddress.ip_address('10.0.0.0') + random.randint(0, 16777216)
|
|
self._network_iterator = ipaddress.ip_network('{}/{}'.format(self._addr, self.netmask), False).hosts()
|
|
|
|
def get_interfaces(self) -> List[Interface]:
|
|
return self._interfaces
|
|
|
|
def set_name(self, name: str):
|
|
self._name = name
|
|
|
|
def get_name(self) -> str:
|
|
return self._name
|
|
|
|
def set_netmask(self, mask: int):
|
|
self.netmask = mask
|
|
self._network_iterator = ipaddress.ip_network('{}/{}'.format(self._addr, self.netmask), False).hosts()
|
|
|
|
def get_ip_address(self) -> ipaddress.ip_address:
|
|
return next(self._network_iterator)
|
|
|
|
def get_network(self) -> str:
|
|
return str(ipaddress.ip_network('{}/{}'.format(self._addr, self.netmask), False))
|
|
|
|
|
|
class Node:
|
|
def __init__(self, interfaces: List[Interface], setup_params: Dict = None):
|
|
self._id: Union[int, None] = None
|
|
self._interfaces: List[Interface] = interfaces
|
|
self._interfaces.append(Interface(IpMethod.Management))
|
|
|
|
for interface in self._interfaces:
|
|
interface.set_node(self)
|
|
|
|
self.setup_params = {} if setup_params is None else setup_params
|
|
|
|
def get_interfaces(self):
|
|
return self._interfaces
|
|
|
|
def set_id(self, new_id):
|
|
self._id = new_id
|
|
|
|
def get_id(self):
|
|
return self._id
|
|
|
|
def get_core_count(self) -> int:
|
|
return 2
|
|
|
|
def get_memory_mb(self) -> int:
|
|
return 2048
|
|
|
|
def get_internet_setup(self) -> Optional[str]:
|
|
return None
|
|
|
|
def get_setup(self) -> Optional[str]:
|
|
return None
|
|
|
|
def ssh(self, *args, **kwargs):
|
|
raise RuntimeError('ssh not implemented')
|
|
|
|
|
|
class SpeedTestServer(Node):
|
|
def client(self, server: Interface):
|
|
pass
|
|
|
|
# Entry method for running the serve with `with speedtest:`
|
|
def __enter__(self):
|
|
pass
|
|
|
|
def __exit__(self, exc_type, exc_val, exc_tb):
|
|
pass
|
|
|
|
|
|
class RemotePortal(Node):
|
|
def __init__(self, interfaces, **kwargs):
|
|
super(RemotePortal, self).__init__(interfaces, **kwargs)
|
|
|
|
self.local_portal = None
|
|
|
|
def set_local_portal(self, local_portal):
|
|
self.local_portal = local_portal
|
|
|
|
def get_internet_setup(self) -> Optional[str]:
|
|
return textwrap.dedent('''
|
|
set -e
|
|
|
|
wget -q http://10.20.0.11/minio-client
|
|
chmod +x minio-client
|
|
|
|
./minio-client alias set s3 http://10.20.0.25:3900 {access_key} {secret_key} || \
|
|
./minio-client alias set s3 s3.us-west-001.backblazeb2.com {access_key} {secret_key}
|
|
./minio-client cp s3/dissertation/binaries/debian/{branch} mpbl3p
|
|
|
|
chmod +x mpbl3p
|
|
|
|
cloud-init status --wait || cloud-init status --long
|
|
sudo apt-get install -y iperf3
|
|
''').format(**self.setup_params)
|
|
|
|
def get_setup(self) -> Optional[str]:
|
|
return textwrap.dedent('''
|
|
set -e
|
|
|
|
sudo sysctl -w net.ipv4.conf.all.arp_announce=1
|
|
sudo sysctl -w net.ipv4.conf.all.arp_ignore=2
|
|
|
|
cat << EOF > config.ini
|
|
[Host]
|
|
PrivateKey = INVALID
|
|
|
|
[Peer]
|
|
PublicKey = INVALID
|
|
Method = TCP
|
|
|
|
LocalHost = {local_host}
|
|
LocalPort = 1234
|
|
EOF
|
|
|
|
(nohup sudo ./mpbl3p > mpbl3p.log 2>&1 & echo $! > mpbl3p.pid)
|
|
|
|
sleep 1
|
|
sudo ip link set up nc0
|
|
sudo ip addr add 172.19.152.2/31 dev nc0
|
|
|
|
ps $(cat mpbl3p.pid)
|
|
''').format(
|
|
local_host=self.get_interfaces()[0].get_address(),
|
|
**self.setup_params,
|
|
)
|
|
|
|
def speedtest_server(self):
|
|
self.ssh('iperf3 -s -1 -D', error_stdout=True, error_stderr=True)
|
|
|
|
def speedtest_client(self, target, time=30):
|
|
command = 'iperf3 -c {target} -t {time} -O 5 -J'.format(target=target, time=time)
|
|
out = self.ssh(command, error_stdout=True, error_stderr=True, return_stdout=True)
|
|
return json.loads(out)
|
|
|
|
|
|
class LocalPortal(Node):
|
|
def __init__(self, wan_interfaces: List[Interface], child: Optional[Node], **kwargs):
|
|
if child is not None:
|
|
lan_interface = Interface(IpMethod.Manual)
|
|
Bridge(lan_interface, child.get_interfaces()[0])
|
|
super().__init__([*wan_interfaces, lan_interface], **kwargs)
|
|
else:
|
|
super().__init__(wan_interfaces, **kwargs)
|
|
|
|
self.remote_portal = None
|
|
|
|
def set_remote_portal(self, remote_portal):
|
|
self.remote_portal = remote_portal
|
|
|
|
def get_internet_setup(self) -> Optional[str]:
|
|
return textwrap.dedent('''
|
|
set -e
|
|
|
|
wget -q http://10.20.0.11/minio-client
|
|
chmod +x minio-client
|
|
|
|
./minio-client alias set s3 http://10.20.0.25:3900 {access_key} {secret_key} || \
|
|
./minio-client alias set s3 s3.us-west-001.backblazeb2.com {access_key} {secret_key}
|
|
./minio-client cp s3/dissertation/binaries/debian/{branch} mpbl3p
|
|
|
|
chmod +x mpbl3p
|
|
|
|
cloud-init status --wait || cloud-init status --long
|
|
sudo apt-get install -y iperf3
|
|
''').format(**self.setup_params)
|
|
|
|
def get_setup(self) -> str:
|
|
peer_string = textwrap.dedent('''
|
|
[Peer]
|
|
PublicKey = INVALID
|
|
Method = TCP
|
|
|
|
LocalHost = {local_host}
|
|
|
|
RemoteHost = {remote_host}
|
|
RemotePort = 1234
|
|
''')
|
|
|
|
peers = '\n\n'.join([peer_string.format(
|
|
local_host=x.get_address(),
|
|
remote_host=self.remote_portal.get_interfaces()[0].get_address(),
|
|
) for x in self.get_interfaces()[:-1]])
|
|
|
|
policy_routing_string = textwrap.dedent('''
|
|
sudo ip route flush {table_number}
|
|
sudo ip route add table {table_number} to {network} dev {device}
|
|
sudo ip rule add from {local_address} table {table_number} priority {table_number}
|
|
''')
|
|
|
|
policy_routing = '\n\n'.join([policy_routing_string.format(
|
|
table_number=i+10,
|
|
device='eth{}'.format(i),
|
|
network=iface.get_bridge().get_network(),
|
|
local_address=iface.get_address(),
|
|
) for i, iface in enumerate(self.get_interfaces()[:-1])])
|
|
|
|
return textwrap.dedent('''
|
|
set -e
|
|
|
|
sudo sysctl -w net.ipv4.conf.all.arp_announce=1
|
|
sudo sysctl -w net.ipv4.conf.all.arp_ignore=2
|
|
|
|
{policy_routing}
|
|
|
|
cat << EOF > config.ini
|
|
[Host]
|
|
PrivateKey = INVALID
|
|
|
|
{peers}
|
|
EOF
|
|
|
|
(nohup sudo ./mpbl3p > mpbl3p.log 2>&1 & echo $! > mpbl3p.pid)
|
|
|
|
sleep 1
|
|
sudo ip link set up nc0
|
|
sudo ip addr add 172.19.152.3/31 dev nc0
|
|
|
|
ps $(cat mpbl3p.pid)
|
|
''').format(**self.setup_params, peers=peers, policy_routing=policy_routing)
|
|
|
|
def speedtest_server(self):
|
|
self.ssh('iperf3 -s -1 -D', error_stdout=True, error_stderr=True)
|
|
|
|
def speedtest_client(self, target, time=30):
|
|
command = 'iperf3 -c {target} -t {time} -O 5 -J'.format(target=target, time=time)
|
|
out = self.ssh(command, error_stdout=True, error_stderr=True, return_stdout=True)
|
|
return json.loads(out)
|