def example(options):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create emane network node
emane_network = session.create_emane_network(model=EmaneIeee80211abgModel,
geo_reference=(47.57917,
-122.13232,
2.00000))
emane_network.setposition(x=80, y=50)
# create nodes
for i in range(options.nodes):
node = session.create_wireless_node()
node.setposition(x=150 * (i + 1), y=150)
interface = prefixes.create_interface(node)
session.add_link(node.id, emane_network.id, interface_one=interface)
# instantiate session
session.instantiate()
# start a shell on the first node
node = session.get_node(2)
node.client.term("bash")
# shutdown session
input("press enter to exit...")
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create emane network node
emane_network = session.create_emane_network(
model=EmaneIeee80211abgModel,
geo_reference=(47.57917, -122.13232, 2.00000)
)
emane_network.setposition(x=80, y=50)
# create nodes
for i in xrange(options.nodes):
node = session.create_wireless_node()
node.setposition(x=150 * (i + 1), y=150)
interface = prefixes.create_interface(node)
session.add_link(node.objid, emane_network.objid, interface_one=interface)
# instantiate session
session.instantiate()
# start a shell on the first node
node = session.get_object(2)
node.client.term("bash")
# shutdown session
raw_input("press enter to exit...")
coreemu.shutdown()
def main(args):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu({"distributed_address": args.address})
session = coreemu.create_session()
# initialize distributed
server_name = "core2"
session.distributed.add_server(server_name, args.server)
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create local node, switch, and remote nodes
options = NodeOptions()
node_one = session.add_node(options=options)
options.server = server_name
node_two = session.add_node(options=options)
# create node interfaces and link
interface_one = prefixes.create_interface(node_one)
interface_two = prefixes.create_interface(node_two)
session.add_link(node_one.id, node_two.id, interface_one, interface_two)
# instantiate session
session.instantiate()
# pause script for verification
input("press enter for shutdown")
# shutdown session
coreemu.shutdown()
def example(args):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create emane network node
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions()
options.set_position(80, 50)
emane_network = session.add_node(_type=NodeTypes.EMANE, options=options)
session.emane.set_model(emane_network, EmaneIeee80211abgModel)
# create nodes
options = NodeOptions(model="mdr")
for i in range(args.nodes):
node = session.add_node(options=options)
node.setposition(x=150 * (i + 1), y=150)
interface = prefixes.create_interface(node)
session.add_link(node.id, emane_network.id, interface_one=interface)
# instantiate session
session.instantiate()
# shutdown session
input("press enter to exit...")
coreemu.shutdown()
def example(args):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create switch network node
switch = session.add_node(_type=NodeTypes.SWITCH)
# create nodes
for _ in range(args.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.id, switch.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes to run example
first_node = session.get_node(2)
last_node = session.get_node(args.nodes + 1)
first_node_address = prefixes.ip4_address(first_node)
logging.info("node %s pinging %s", last_node.name, first_node_address)
output = last_node.cmd(f"ping -c {args.count} {first_node_address}")
logging.info(output)
# shutdown session
coreemu.shutdown()
def grpc_server():
coremu = CoreEmu()
grpc_server = CoreGrpcServer(coremu)
thread = threading.Thread(target=grpc_server.listen, args=("localhost:50051",))
thread.daemon = True
thread.start()
time.sleep(0.1)
yield grpc_server
coremu.shutdown()
grpc_server.server.stop(None)
def session():
# use coreemu and create a session
coreemu = CoreEmu()
session_fixture = coreemu.create_session()
session_fixture.set_state(EventTypes.CONFIGURATION_STATE)
assert os.path.exists(session_fixture.session_dir)
# return created session
yield session_fixture
# shutdown coreemu
coreemu.shutdown()
def example(nodes):
# ip generator for example
prefixes = IpPrefixes("192.168.10.0/24")
node_list = []
# create emulator instance for creating sessions and utility methods
coreemu = globals().get("coreemu", CoreEmu())
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create nodes
node_options = NodeOptions()
x = 0
for i in range(nodes):
node_options.set_position(x, 100)
x = x+70
session.add_node(node_options=node_options)
node_list.append(node)
# create switch network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.mobility.set_model(wlan, BasicRangeModel)
for node in node_list:
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
# instantiate session
session.instantiate()
def __init__(self, yml_nodes=None, yml_links=None, netmask="10.0.0.0/24"):
"""
Constructor for the Topology class - Creates a topology and starts the emulation, if no parameters were provided then an empty topolgy is created.
:param yml_nodes: a list containing the nodes parsed from the topology configuration file, defaults to None
:type yml_nodes: list(YML_node), optional
:param yml_links: a list containing the links parsed from the topology configuration file, defaults to None
:type yml_links: list(parser.YML_link), optional
:param netmask: the netmask tells the emulator what sort of IP addresses the virtual nodes should be assigned, defaults to 10.0.0.0/24
:type netmask: str
"""
Topology.prefixes = IpPrefixes(
ip4_prefix=netmask) #prefixes # CORE prefixes
self.coreemu = globals().get("coreemu",
CoreEmu()) # CORE container for sessions
self.session = self.coreemu.create_session() # CORE session
self.flag_physical_node = False
self.netmask = netmask
self.interfaceDict = {}
self.inter_nodes = [] # Nodes from coreNode types
self.physical_links = {}
self.list_physical_links = []
self.session.set_state(EventTypes.CONFIGURATION_STATE)
self.interNodeObjects = []
self.interLinkObjects = []
if (yml_nodes and yml_links):
self._init_topology(yml_nodes, yml_links)
else:
self.session.instantiate()
def main():
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create emane network node, emane determines connectivity based on
# location, so the session and nodes must be configured to provide one
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions()
options.set_position(80, 50)
emane_network = session.add_node(_type=NodeTypes.EMANE,
options=options,
_id=100)
session.emane.set_model(emane_network, EmaneIeee80211abgModel)
# create nodes
options = NodeOptions(model="mdr")
for i in range(NODES):
node = session.add_node(options=options)
node.setposition(x=150 * (i + 1), y=150)
interface = prefixes.create_interface(node)
session.add_link(node.id, emane_network.id, interface_one=interface)
# instantiate session
session.instantiate()
# OSPF MDR requires some time for routes to be created
logging.info("waiting %s seconds for OSPF MDR to create routes",
EMANE_DELAY)
time.sleep(EMANE_DELAY)
# get nodes to run example
first_node = session.get_node(1)
last_node = session.get_node(NODES)
address = prefixes.ip4_address(first_node)
logging.info("node %s pinging %s", last_node.name, address)
output = last_node.cmd(f"ping -c 3 {address}")
logging.info(output)
# shutdown session
coreemu.shutdown()
def create_session(topo_path, _id, dtn_software):
coreemu = CoreEmu()
session = coreemu.create_session(_id=_id)
session.set_state(EventTypes.CONFIGURATION_STATE)
ServiceManager.add_services('/root/.core/myservices')
session.open_xml(topo_path)
for obj in session.objects.itervalues():
if type(obj) is CoreNode:
session.services.add_services(obj, obj.type,
['pidstat', 'bwm-ng', dtn_software])
session.instantiate()
return session
def __init__(self, env_config, silent=True):
if not silent:
load_logging_config()
self.envParser = EnvParser(env_config)
if self.envParser.ip4_prefix:
self.prefix = IpPrefixes(ip4_prefix=self.envParser.ip4_prefix)
else:
self.prefix = IpPrefixes(ip6_prefix=self.envParser.ip6_prefix)
self.nodes = {} # pc nodes
self.networks = [] # switches nodes
# create emulator instance for creating sessions and utility methods
self.coreemu = CoreEmu()
self.session = self.coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
self.session.set_state(EventTypes.CONFIGURATION_STATE)
# create nodes
for node in self.envParser.nodes:
self.nodes[int(node["id"])] = {"obj": self.session.add_node(_type=NodeTypes.DEFAULT), "nets": [],
"ip": None, "curr_net": None}
# create networks
for net in self.envParser.networks:
self.networks.append(self.session.add_node(_type=NodeTypes.SWITCH))
for node in net["nodes"]:
interface = self.prefix.create_interface(self.nodes[node["id"]]["obj"],
name=self.envParser.dev_prefix + str(net["id"]))
self.nodes[node["id"]]["ip"] = self.prefix.ip4_address(self.nodes[node["id"]]["obj"])
self.session.add_link(self.nodes[node["id"]]["obj"].id, self.networks[-1].id, interface_one=interface)
self.nodes[node["id"]]["nets"].append({
"net": net["id"]
})
# certs
shutil.rmtree('certs', True)
self.__create_root_ca()
for node in self.nodes:
self.__create_node_cert(node)
# instantiate session
self.start()
def main(args):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu({
"controlnet":
"core1:172.16.1.0/24 core2:172.16.2.0/24 core3:172.16.3.0/24 "
"core4:172.16.4.0/24 core5:172.16.5.0/24",
"distributed_address":
args.address,
})
session = coreemu.create_session()
# initialize distributed
server_name = "core2"
session.distributed.add_server(server_name, args.server)
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create local node, switch, and remote nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node1 = session.add_node(CoreNode, options=options)
emane_net = session.add_node(EmaneNet)
session.emane.set_model(emane_net, EmaneIeee80211abgModel)
options.server = server_name
node2 = session.add_node(CoreNode, options=options)
# create node interfaces and link
interface1_data = prefixes.create_iface(node1)
interface2_data = prefixes.create_iface(node2)
session.add_link(node1.id, emane_net.id, iface1_data=interface1_data)
session.add_link(node2.id, emane_net.id, iface1_data=interface2_data)
# instantiate session
session.instantiate()
# pause script for verification
input("press enter for shutdown")
# shutdown session
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.mobility.set_model(wlan, BasicRangeModel)
# create nodes
wireless_nodes = []
for _ in xrange(options.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.objid, wlan.objid, interface_one=interface)
wireless_nodes.append(node)
# link all created nodes with the wireless network
session.wireless_link_all(wlan, wireless_nodes)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_object(2)
last_node = session.get_object(options.nodes + 1)
print "starting iperf server on node: %s" % first_node.name
first_node.cmd(["iperf", "-s", "-D"])
address = prefixes.ip4_address(first_node)
print "node %s connecting to %s" % (last_node.name, address)
last_node.client.icmd(["iperf", "-t", str(options.time), "-c", address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.set_wireless_model(wlan, BasicRangeModel)
# create nodes
wireless_nodes = []
for _ in xrange(options.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.objid, wlan.objid, interface_one=interface)
wireless_nodes.append(node)
# link all created nodes with the wireless network
session.wireless_link_all(wlan, wireless_nodes)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_object(2)
last_node = session.get_object(options.nodes + 1)
print "starting iperf server on node: %s" % first_node.name
first_node.cmd(["iperf", "-s", "-D"])
address = prefixes.ip4_address(first_node)
print "node %s connecting to %s" % (last_node.name, address)
last_node.client.icmd(["iperf", "-t", str(options.time), "-c", address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
def session():
# use coreemu and create a session
coreemu = CoreEmu(config={"emane_prefix": "/usr"})
session_fixture = coreemu.create_session()
session_fixture.set_state(EventTypes.CONFIGURATION_STATE)
assert os.path.exists(session_fixture.session_dir)
# return created session
yield session_fixture
# clear session configurations
session_fixture.location.reset()
session_fixture.services.reset()
session_fixture.mobility.config_reset()
session_fixture.emane.config_reset()
# shutdown coreemu
coreemu.shutdown()
# clear services, since they will be reloaded
ServiceManager.services.clear()
def session():
# use coreemu and create a session
coreemu = CoreEmu()
session_fixture = coreemu.create_session()
session_fixture.set_state(EventTypes.CONFIGURATION_STATE)
assert os.path.exists(session_fixture.session_dir)
# return created session
yield session_fixture
# clear session configurations
session_fixture.location.reset()
session_fixture.services.reset()
session_fixture.mobility.config_reset()
session_fixture.emane.config_reset()
# shutdown coreemu
coreemu.shutdown()
# clear services, since they will be reloaded
ServiceManager.services.clear()
def __init__(self, server_address, handler_class, config=None):
"""
Server class initialization takes configuration data and calls
the socketserver constructor.
:param tuple[str, int] server_address: server host and port to use
:param class handler_class: request handler
:param dict config: configuration setting
"""
self.coreemu = CoreEmu(config)
self.config = config
socketserver.TCPServer.__init__(self, server_address, handler_class)
def example(args):
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.mobility.set_model(wlan, BasicRangeModel)
# create nodes, must set a position for wlan basic range model
options = NodeOptions(model="mdr")
options.set_position(0, 0)
for _ in range(args.nodes):
node = session.add_node(options=options)
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_node(2)
last_node = session.get_node(args.nodes + 1)
logging.info("starting iperf server on node: %s", first_node.name)
first_node.cmd("iperf -s -D")
address = prefixes.ip4_address(first_node)
logging.info("node %s connecting to %s", last_node.name, address)
output = last_node.cmd(f"iperf -t {args.time} -c {address}")
logging.info(output)
first_node.cmd("killall -9 iperf")
# shutdown session
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.mobility.set_model(wlan, BasicRangeModel)
# create nodes, must set a position for wlan basic range model
node_options = NodeOptions()
node_options.set_position(0, 0)
for _ in range(options.nodes):
node = session.add_node(node_options=node_options)
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_node(2)
last_node = session.get_node(options.nodes + 1)
print("starting iperf server on node: %s" % first_node.name)
first_node.cmd(["iperf", "-s", "-D"])
address = prefixes.ip4_address(first_node)
print("node %s connecting to %s" % (last_node.name, address))
last_node.client.icmd(["iperf", "-t", str(options.time), "-c", address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create switch network node
switch = session.add_node(_type=NodeTypes.SWITCH)
# create nodes
for _ in range(options.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.id, switch.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes to run example
first_node = session.get_node(2)
last_node = session.get_node(options.nodes + 1)
print("starting iperf server on node: %s" % first_node.name)
first_node.cmd(["iperf", "-s", "-D"])
first_node_address = prefixes.ip4_address(first_node)
print("node %s connecting to %s" % (last_node.name, first_node_address))
last_node.client.icmd(
["iperf", "-t",
str(options.time), "-c", first_node_address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
def main(args):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu(
{"controlnet": "172.16.0.0/24", "distributed_address": args.address}
)
session = coreemu.create_session()
# initialize distributed
server_name = "core2"
session.distributed.add_server(server_name, args.server)
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create local node, switch, and remote nodes
node1 = session.add_node(CoreNode)
switch = session.add_node(SwitchNode)
options = NodeOptions()
options.server = server_name
node2 = session.add_node(CoreNode, options=options)
# create node interfaces and link
interface1_data = prefixes.create_iface(node1)
interface2_data = prefixes.create_iface(node2)
session.add_link(node1.id, switch.id, iface1_data=interface1_data)
session.add_link(node2.id, switch.id, iface1_data=interface2_data)
# instantiate session
session.instantiate()
# pause script for verification
input("press enter for shutdown")
# shutdown session
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create switch network node
switch = session.add_node(_type=NodeTypes.SWITCH)
# create nodes
for _ in xrange(options.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.objid, switch.objid, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes to run example
first_node = session.get_object(2)
last_node = session.get_object(options.nodes + 1)
print "starting iperf server on node: %s" % first_node.name
first_node.cmd(["iperf", "-s", "-D"])
first_node_address = prefixes.ip4_address(first_node)
print "node %s connecting to %s" % (last_node.name, first_node_address)
last_node.client.icmd(["iperf", "-t", str(options.time), "-c", first_node_address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
def main():
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(WlanNode, _id=100)
session.mobility.set_model(wlan, BasicRangeModel)
# create nodes, must set a position for wlan basic range model
options = NodeOptions(model="mdr")
options.set_position(0, 0)
for _ in range(NODES):
node = session.add_node(CoreNode, options=options)
interface = prefixes.create_iface(node)
session.add_link(node.id, wlan.id, iface1_data=interface)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_node(1, CoreNode)
last_node = session.get_node(NODES, CoreNode)
address = prefixes.ip4_address(first_node.id)
logging.info("node %s pinging %s", last_node.name, address)
output = last_node.cmd(f"ping -c 3 {address}")
logging.info(output)
# shutdown session
coreemu.shutdown()
def example(nodes):
# ip generator for example
prefixes = IpPrefixes("192.168.10.0/24")
node_list = []
# create emulator instance for creating sessions and utility methods
core_emu = globals().get("coreemu", CoreEmu())
session = core_emu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create nodes
node_options = NodeOptions()
x = 0
for i in range(nodes):
y = 200
x = x + 100
if (i - 1) % 2 == 0: #node id starts at 1
y = 400
node_options.set_position(x, y)
node = session.add_node(node_options=node_options)
node_list.append(node)
# create switch network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.mobility.set_model(wlan, BasicRangeModel)
for node in node_list:
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
# instantiate session
session.instantiate()
for node_num in range(2, 2 + nodes - 1):
n = session.get_node(node_num)
print("starting swarmdag on node: %s" % n.name)
n.cmd([swarmdag_path, ">", "swarmdag.txt"])
destination.cmd(["iperf", "-s", "-D"])
source.client.icmd(["iperf", "-t", "10", "-c", dst_address])
destination.cmd(["killall", "-9", "iperf"])
if __name__ == '__main__':
framework.start()
print "Starting Experiment"
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create switch network node
switch = session.add_node(_type=NodeTypes.SWITCH)
print "Everything is set up now."
# create nodes
for _ in xrange(2):
node = session.add_node()
interface = prefixes.create_interface(node)
link_opts = LinkOptions()
# required imports import netaddr, dataclasses, fabric, lxml, pyproj from core.emulator.coreemu import CoreEmu from core.emulator.data import IpPrefixes, NodeOptions from core.emulator.enumerations import EventTypes from core.nodes.base import CoreNode from core.nodes.network import SwitchNode # ip nerator for example ip_prefixes = IpPrefixes(ip4_prefix="10.0.0.0/24") # create emulator instance for creating sessions and utility methods coreemu = CoreEmu() session = coreemu.create_session() print(session) # must be in configuration state for nodes to start, when using "node_add" below session.set_state(EventTypes.CONFIGURATION_STATE) # create switch options = NodeOptions(x=200, y=200) switch = session.add_node(SwitchNode, options=options) # create nodes options = NodeOptions(x=100, y=100) n1 = session.add_node(CoreNode, options=options) options = NodeOptions(x=300, y=100) n2 = session.add_node(CoreNode, options=options)
def global_coreemu(patcher):
coreemu = CoreEmu(config={"emane_prefix": "/usr"})
yield coreemu
coreemu.shutdown()
class Env():
def __init__(self, env_config, silent=True):
if not silent:
load_logging_config()
self.envParser = EnvParser(env_config)
if self.envParser.ip4_prefix:
self.prefix = IpPrefixes(ip4_prefix=self.envParser.ip4_prefix)
else:
self.prefix = IpPrefixes(ip6_prefix=self.envParser.ip6_prefix)
self.nodes = {} # pc nodes
self.networks = [] # switches nodes
# create emulator instance for creating sessions and utility methods
self.coreemu = CoreEmu()
self.session = self.coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
self.session.set_state(EventTypes.CONFIGURATION_STATE)
# create nodes
for node in self.envParser.nodes:
self.nodes[int(node["id"])] = {"obj": self.session.add_node(_type=NodeTypes.DEFAULT), "nets": [],
"ip": None, "curr_net": None}
# create networks
for net in self.envParser.networks:
self.networks.append(self.session.add_node(_type=NodeTypes.SWITCH))
for node in net["nodes"]:
interface = self.prefix.create_interface(self.nodes[node["id"]]["obj"],
name=self.envParser.dev_prefix + str(net["id"]))
self.nodes[node["id"]]["ip"] = self.prefix.ip4_address(self.nodes[node["id"]]["obj"])
self.session.add_link(self.nodes[node["id"]]["obj"].id, self.networks[-1].id, interface_one=interface)
self.nodes[node["id"]]["nets"].append({
"net": net["id"]
})
# certs
shutil.rmtree('certs', True)
self.__create_root_ca()
for node in self.nodes:
self.__create_node_cert(node)
# instantiate session
self.start()
def get_node_ip(self, node):
return self.nodes[node]["ip"]
def run_command(self, node, command, wait=True):
print(*command)
self.nodes[node]["obj"].client.cmd(command, wait)
def run_icommand(self, node, command):
self.nodes[node]["obj"].client.icmd(command)
def run_terminal(self, node):
self.nodes[node]["obj"].client.term()
def change_net(self, node, net):
self.nodes[node]["obj"].cmd(
["ip", 'l', 'set', self.envParser.dev_prefix + str(self.nodes[node]['curr_net']), 'down'])
self.nodes[node]["obj"].cmd(["ip", 'l', 'set', self.envParser.dev_prefix + str(net), 'up'])
self.nodes[node]["curr_net"] = net
'''options:
delay TIME [ JITTER [CORRELATION]] [distribution {uniform|normal|pareto|paretonormal} ]
corrupt PERCENT [CORRELATION]
duplicate PERCENT [CORRELATION]
loss random PERCENT [CORRELATION]
loss state P13 [P31 [P32 [P23 P14]]
loss gemodel PERCENT [R [1-H [1-K]]
reorder PRECENT [CORRELATION] [ gap DISTANCE ]
'''
def add_net_params(self, nodes, net, params):
for node in nodes:
for param in params:
self.nodes[node]["obj"].client.cmd(
["tc", 'qdisc', 'add', 'dev', self.envParser.dev_prefix + str(net), 'root', 'netem', param] +
params[param])
return
'''
Use add on first setting a params, later use set
'''
def set_net_params(self, nodes, net, params):
for node in nodes:
for param in params:
self.nodes[node]["obj"].cmd(
["tc", 'qdisc', 'change', 'dev', self.envParser.dev_prefix + str(net), 'root', 'netem', param] +
params[param])
return
def start(self):
self.session.instantiate()
for node in self.nodes.values():
for net in node['nets']:
node["obj"].cmd(["ip", 'l', 'set', self.envParser.dev_prefix + str(net['net']), 'down'])
node["obj"].cmd(["ip", 'l', 'set', self.envParser.dev_prefix + str(node['nets'][0]['net']), 'up'])
node['curr_net'] = node['nets'][0]['net']
def finish(self):
# remove certs
shutil.rmtree('certs')
# shutdown session
self.coreemu.shutdown()
# XXX: every cert's related things are store in "certs" directory just for now
def __create_root_ca(self):
try:
os.mkdir('certs')
except FileExistsError:
pass
os.system("openssl genrsa -out certs/rootCA.key 4096")
os.system(
"openssl req -x509 -new -nodes -key certs/rootCA.key -sha256 -days 1024 -subj \"/C=PL/ST=CA/O=DTN_TEST_ENV, Inc./CN=ROOT_CA\" -out certs/rootCA.crt")
def __create_node_cert(self, nodeId):
os.system("openssl genrsa -out certs/node" + str(nodeId) + ".key 2048")
os.system("openssl req -new -sha256 -key certs/node" + str(
nodeId) + ".key -subj \"/C=PL/ST=CA/O=DTN_TEST_ENV, Inc./CN=node" + str(
nodeId) + "\" -out certs/node" + str(nodeId) + ".csr")
os.system("openssl x509 -req -in certs/node" + str(
nodeId) + ".csr -CA certs/rootCA.crt -CAkey certs/rootCA.key -CAcreateserial -out certs/node" + str(
nodeId) + ".crt -days 500 -sha256")
from core.nodes.base import CoreNode
from core.nodes.network import WlanNode
import time
import logging
from pyroute2 import IPRoute
import signal
import os
import net_events
log = logging.getLogger()
log.setLevel(logging.INFO)
SWARMDAG_PATH = '/home/jasonatran/go/src/github.com/ANRGUSC/swarmdag/build'
NUM_NODES = 8
prefixes = IpPrefixes("192.168.10.0/24")
session = CoreEmu().create_session()
ip = IPRoute() # for IP routes on host
def cleanup_session(signum, frame):
print("shutting down Core nodes...")
session.shutdown()
if len(ip.link_lookup(ifname='veth0')) == 1:
# `sudo ip link del veth0 type veth peer name veth1`
ip.link("delete",
ifname="veth0",
kind="veth",
peer={"ifname": "veth1"})
exit()
def main():
# ip generator
prefixes = IpPrefixes(ip4_prefix="10.42.0.0/16")
# create emulator instance for creating sessions and utility methods
cli = False
coreemu = globals().get("coreemu")
if not coreemu:
config = {"custom_services_dir": "/home/whoward3/coreScripts/myServices"}
coreemu = CoreEmu(config=config)
cli = True
session = coreemu.create_session()
# create client node options
nodeOptions = NodeOptions()
nodeOptions.services = ["Node"]
# create attacker node options
attackerOptions = NodeOptions()
attackerOptions.services = ["Attacker"]
# must be in configuration state for nodes to start, when using "add_node" below
session.set_state(EventTypes.CONFIGURATION_STATE)
switches = 5 #random.randint(2,10)
node = []
switch = []
i = 0
# create switches
for _ in range(switches):
y = random.randint(200,700)
x = random.randint(200,700)
switch.append(session.add_node(_type=NodeTypes.SWITCH))
switch[i].setposition(x=x,y=y)
i=i+1
i = 0
# create client nodes
for _ in range(switches*5):
y = random.randint(150,750)
x = random.randint(150,750)
if(i % 3 == 0 and i < (switches*5)):
node.append(session.add_node(node_options=nodeOptions))
else:
node.append(session.add_node(node_options=nodeOptions))
node[i].setposition(x=x,y=y)
nodeInterface = prefixes.create_interface(node[i])
# create interfaces to connect client nodes to switches
if(i%switches==0):
routerInterface = prefixes.create_interface(switch[0])
session.add_link(node[i].id, switch[0].id, nodeInterface, routerInterface)
elif(i%switches==1):
routerInterface = prefixes.create_interface(switch[1])
session.add_link(node[i].id, switch[1].id, nodeInterface, routerInterface)
elif(i%switches==2):
routerInterface = prefixes.create_interface(switch[2])
session.add_link(node[i].id, switch[2].id, nodeInterface, routerInterface)
elif(i%switches==3):
routerInterface = prefixes.create_interface(switch[3])
session.add_link(node[i].id, switch[3].id, nodeInterface, routerInterface)
elif(i%switches==4):
routerInterface = prefixes.create_interface(switch[4])
session.add_link(node[i].id, switch[4].id, nodeInterface, routerInterface)
elif(i%switches==5):
routerInterface = prefixes.create_interface(switch[5])
session.add_link(node[i].id, switch[5].id, nodeInterface, routerInterface)
elif(i%switches==6):
routerInterface = prefixes.create_interface(switch[6])
session.add_link(node[i].id, switch[6].id, nodeInterface, routerInterface)
elif(i%switches==7):
routerInterface = prefixes.create_interface(switch[7])
session.add_link(node[i].id, switch[7].id, nodeInterface, routerInterface)
elif(i%switches==8):
routerInterface = prefixes.create_interface(switch[8])
session.add_link(node[i].id, switch[8].id, nodeInterface, routerInterface)
elif(i%switches==9):
routerInterface = prefixes.create_interface(switch[9])
session.add_link(node[i].id, switch[9].id, nodeInterface, routerInterface)
i=i+1
# create interfaces to connect switches
if(switches >= 2):
switchA = prefixes.create_interface(switch[0])
switchB = prefixes.create_interface(switch[1])
session.add_link(switch[0].id,switch[1].id,switchA,switchB)
if(switches >= 3):
switchA = prefixes.create_interface(switch[1])
switchB = prefixes.create_interface(switch[2])
session.add_link(switch[1].id,switch[2].id,switchA,switchB)
if(switches >= 4):
switchA = prefixes.create_interface(switch[2])
switchB = prefixes.create_interface(switch[3])
session.add_link(switch[2].id,switch[3].id,switchA,switchB)
if(switches >= 5):
switchA = prefixes.create_interface(switch[3])
switchB = prefixes.create_interface(switch[4])
session.add_link(switch[3].id,switch[4].id,switchA,switchB)
if(switches >= 6):
switchA = prefixes.create_interface(switch[4])
switchB = prefixes.create_interface(switch[5])
session.add_link(switch[4].id,switch[5].id,switchA,switchB)
if(switches >= 7):
switchA = prefixes.create_interface(switch[5])
switchB = prefixes.create_interface(switch[6])
session.add_link(switch[5].id,switch[6].id,switchA,switchB)
if(switches >= 8):
switchA = prefixes.create_interface(switch[6])
switchB = prefixes.create_interface(switch[7])
session.add_link(switch[6].id,switch[7].id,switchA,switchB)
if(switches >= 9):
switchA = prefixes.create_interface(switch[7])
switchB = prefixes.create_interface(switch[8])
session.add_link(switch[7].id,switch[8].id,switchA,switchB)
if(switches >= 10):
switchA = prefixes.create_interface(switch[8])
switchB = prefixes.create_interface(switch[9])
session.add_link(switch[8].id,switch[9].id,switchA,switchB)
# instantiate session
session.instantiate()
print("Session Instantiated, CLI = "+str(cli))
# if the cli is being used terminate the session after 360 (canaries terminate after 340 + 20 seccond initalization delay) secconds
if(cli):
stop_time = datetime.datetime.now() + datetime.timedelta(0,360)
while datetime.datetime.now() < stop_time:
pass
coreemu.delete_session(session.id)
print("Session Terminated by Timer")
def network_initializer(self, switches, composition, attackers):
# check that switches is 2 <= s <= 10
if (2 <= switches and switches <= 10):
return "Error: Can only initalize a network of 2 to 10 switches in size"
# ip generator
prefixes = IpPrefixes(ip4_prefix="10.42.0.0/16")
# create emulator instance for creating sessions and utility methods
cli = False
coreemu = globals().get("coreemu")
# if not using the GUI provide path to the custom services directory
if not coreemu:
config = {"custom_services_dir": "../canaryServices"}
coreemu = CoreEmu(config=config)
cli = True
session = coreemu.create_session()
# create client node options
node_options = NodeOptions()
node_options.services = ["Node"]
# create attacker node options
attacker_options = NodeOptions()
attacker_options.services = ["Attacker"]
# must be in configuration state for nodes to start, when using
# "add_node" below
session.set_state(EventTypes.CONFIGURATION_STATE)
node = []
switch = []
i = 0
# create switches
for _ in range(switches):
y = random.randint(200, 700)
x = random.randint(200, 700)
switch.append(session.add_node(_type=NodeTypes.SWITCH))
switch[i].setposition(x=x, y=y)
i = i + 1
# create list of randomly selected nodes for attacker deployment
nodes = []
if (attackers == "-1"):
print("Generating attacker list...")
for _ in range(switches * 5):
while (True):
rnd = random.randint(0, switches * 5)
if (rnd not in nodes):
nodes.append(rnd)
break
slc = (len(nodes) * composition)
attackers = nodes[:int(slc)]
else:
nodes = [i for i in range(switches * 5)]
if (attackers):
attackers = attackers.split(',')
attackers = [int(i) for i in attackers]
else:
attackers = []
print("Nodes: " + str(nodes))
print("Attackers: " + str(attackers))
i = 0
# create client nodes
for _ in range(switches * 5):
y = random.randint(150, 750)
x = random.randint(150, 750)
if (i in attackers):
node.append(session.add_node(node_options=attacker_options))
else:
node.append(session.add_node(node_options=node_options))
node[i].setposition(x=x, y=y)
node_interface = prefixes.create_interface(node[i])
# create interfaces to connect client nodes to switches
if (i % switches == 0):
switch_interface = prefixes.create_interface(switch[0])
session.add_link(node[i].id, switch[0].id, node_interface,
switch_interface)
elif (i % switches == 1):
switch_interface = prefixes.create_interface(switch[1])
session.add_link(node[i].id, switch[1].id, node_interface,
switch_interface)
elif (i % switches == 2):
switch_interface = prefixes.create_interface(switch[2])
session.add_link(node[i].id, switch[2].id, node_interface,
switch_interface)
elif (i % switches == 3):
switch_interface = prefixes.create_interface(switch[3])
session.add_link(node[i].id, switch[3].id, node_interface,
switch_interface)
elif (i % switches == 4):
switch_interface = prefixes.create_interface(switch[4])
session.add_link(node[i].id, switch[4].id, node_interface,
switch_interface)
elif (i % switches == 5):
switch_interface = prefixes.create_interface(switch[5])
session.add_link(node[i].id, switch[5].id, node_interface,
switch_interface)
elif (i % switches == 6):
switch_interface = prefixes.create_interface(switch[6])
session.add_link(node[i].id, switch[6].id, node_interface,
switch_interface)
elif (i % switches == 7):
switch_interface = prefixes.create_interface(switch[7])
session.add_link(node[i].id, switch[7].id, node_interface,
switch_interface)
elif (i % switches == 8):
switch_interface = prefixes.create_interface(switch[8])
session.add_link(node[i].id, switch[8].id, node_interface,
switch_interface)
elif (i % switches == 9):
switch_interface = prefixes.create_interface(switch[9])
session.add_link(node[i].id, switch[9].id, node_interface,
switch_interface)
i = i + 1
# create interfaces to connect switches
if (switches >= 2):
switch_a = prefixes.create_interface(switch[0])
switch_b = prefixes.create_interface(switch[1])
session.add_link(switch[0].id, switch[1].id, switch_a, switch_b)
if (switches >= 3):
switch_a = prefixes.create_interface(switch[1])
switch_b = prefixes.create_interface(switch[2])
session.add_link(switch[1].id, switch[2].id, switch_a, switch_b)
if (switches >= 4):
switch_a = prefixes.create_interface(switch[2])
switch_b = prefixes.create_interface(switch[3])
session.add_link(switch[2].id, switch[3].id, switch_a, switch_b)
if (switches >= 5):
switch_a = prefixes.create_interface(switch[3])
switch_b = prefixes.create_interface(switch[4])
session.add_link(switch[3].id, switch[4].id, switch_a, switch_b)
if (switches >= 6):
switch_a = prefixes.create_interface(switch[4])
switch_b = prefixes.create_interface(switch[5])
session.add_link(switch[4].id, switch[5].id, switch_a, switch_b)
if (switches >= 7):
switch_a = prefixes.create_interface(switch[5])
switch_b = prefixes.create_interface(switch[6])
session.add_link(switch[5].id, switch[6].id, switch_a, switch_b)
if (switches >= 8):
switch_a = prefixes.create_interface(switch[6])
switch_b = prefixes.create_interface(switch[7])
session.add_link(switch[6].id, switch[7].id, switch_a, switch_b)
if (switches >= 9):
switch_a = prefixes.create_interface(switch[7])
switch_b = prefixes.create_interface(switch[8])
session.add_link(switch[7].id, switch[8].id, switch_a, switch_b)
if (switches >= 10):
switch_a = prefixes.create_interface(switch[8])
switch_b = prefixes.create_interface(switch[9])
session.add_link(switch[8].id, switch[9].id, switch_a, switch_b)
# instantiate session
session.instantiate()
print("Session Instantiated, CLI = " + str(cli))
# if the cli is being used terminate the session after 360 (canaries
# terminate after 340 + 20 seccond initalization delay) seconds
if (cli):
stop_time = datetime.datetime.now() + datetime.timedelta(0, 360)
while datetime.datetime.now() < stop_time:
pass
coreemu.delete_session(session.id)
print("Session Terminated by Timer")
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--is_virtual',
dest='is_virtual',
help='with Kronos',
default="False")
args = parser.parse_args()
if args.is_virtual == "True":
is_virtual = True
else:
is_virtual = False
# Kronos specific parameters
total_num_dilated_executables = 6 # (2 plcs + 2 communication modules + 2 hmis )
run_time_secs = 5
rel_cpu_speed = 1.0
num_insns_per_round = 1000000
plc_spec_directory = os.path.dirname(os.path.realpath(__file__))
plc1_spec_file = f"{plc_spec_directory}/plc1_system_specification.prototxt"
plc2_spec_file = f"{plc_spec_directory}/plc2_system_specification.prototxt"
NUM_PLCS = 2
NUM_HMIS = 2
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create switch network node
switch = session.add_node(SwitchNode, _id=100)
# create nodes
for _ in range(NUM_PLCS + NUM_HMIS):
node = session.add_node(CoreNode)
interface = prefixes.create_iface(node)
session.add_link(node.id,
switch.id,
iface1_data=interface,
options=LinkOptions(delay=1000)) # delay in us
# instantiate session
session.instantiate()
node_ifaces = []
# get nodes to run example
plc1_node = session.get_node(1, CoreNode)
node_ifaces.extend(
[x.localname for x in plc1_node.get_ifaces(control=False)])
plc2_node = session.get_node(2, CoreNode)
node_ifaces.extend(
[x.localname for x in plc2_node.get_ifaces(control=False)])
hmi1_node = session.get_node(3, CoreNode)
node_ifaces.extend(
[x.localname for x in hmi1_node.get_ifaces(control=False)])
hmi2_node = session.get_node(4, CoreNode)
node_ifaces.extend(
[x.localname for x in hmi2_node.get_ifaces(control=False)])
print("node-ifaces ", node_ifaces)
plc1_ip_address = prefixes.ip4_address(plc1_node.id)
plc2_ip_address = prefixes.ip4_address(plc2_node.id)
print(f"PLC-1 IP: {plc1_ip_address}, PLC-2 IP: {plc2_ip_address}")
# Clear any existing log files
if os.path.exists("/tmp/pc_grpc_server_log.txt"):
os.remove("/tmp/pc_grpc_server_log.txt")
if os.path.exists("/tmp/plc1_log.txt"):
os.remove("/tmp/plc1_log.txt")
if os.path.exists("/tmp/plc2_log.txt"):
os.remove("/tmp/plc2_log.txt")
if os.path.exists("/tmp/comm_module1_log.txt"):
os.remove("/tmp/comm_module1_log.txt")
if os.path.exists("/tmp/comm_module2_log.txt"):
os.remove("/tmp/comm_module2_log.txt")
if os.path.exists("/tmp/hmi1.txt"):
os.remove("/tmp/hmi1.txt")
if os.path.exists("/tmp/hmi2.txt"):
os.remove("/tmp/hmi2.txt")
fd1 = os.open("/tmp/pc_grpc_server_log.txt", os.O_RDWR | os.O_CREAT)
pendulum_sim = PendulumSystemSimulator()
if args.is_virtual == "True":
is_virtual = True
else:
is_virtual = False
# Create an emulation driver. Register pendulum system simulator with it.
emulation = EmulationDriver(
number_dilated_nodes=total_num_dilated_executables,
is_virtual=is_virtual,
n_insns_per_round=num_insns_per_round,
rel_cpu_speed=rel_cpu_speed,
physical_system_sim_driver=pendulum_sim)
# Start pc_grpc_server, all PLCs and all communication modules here
emulation.start_grpc_server(plc_spec_directory, fd1)
if is_virtual:
emulation.add_interfaces_to_vt_control(node_ifaces)
# Retrieve command strings to run PLCs/HMIs/Communication Modules
plc1_cmd = emulation.get_plc_exec_command(
path_to_plc_specification_file=plc1_spec_file,
log_file_path="/tmp/plc1_log.txt")
plc2_cmd = emulation.get_plc_exec_command(
path_to_plc_specification_file=plc2_spec_file,
log_file_path="/tmp/plc2_log.txt")
comm_module1_cmd = emulation.wrap_command(
get_comm_module_start_command(plc1_spec_file, plc1_ip_address,
"/tmp/comm_module1_log.txt"))
comm_module2_cmd = emulation.wrap_command(
get_comm_module_start_command(plc2_spec_file, plc2_ip_address,
"/tmp/comm_module2_log.txt"))
hmi1_cmd = emulation.wrap_command(
get_example_hmi_start_command(plc1_ip_address, "/tmp/hmi1.txt"))
hmi2_cmd = emulation.wrap_command(
get_example_hmi_start_command(plc2_ip_address, "/tmp/hmi2.txt"))
print("Starting PLCs ...")
plc1_node.cmd(plc1_cmd, wait=False)
plc2_node.cmd(plc2_cmd, wait=False)
print("Starting PLC Modbus Comm modules ...")
plc1_node.cmd(comm_module1_cmd, wait=False)
plc2_node.cmd(comm_module2_cmd, wait=False)
print("Starting HMI ...")
hmi1_node.cmd(hmi1_cmd, wait=False)
hmi2_node.cmd(hmi2_cmd, wait=False)
# Wait until all processes have started and registered themselves
emulation.wait_for_initialization()
# Register an interrupt signal handler.
signal.signal(signal.SIGINT, handler)
total_time_elapsed = 0.0
while total_time_elapsed <= run_time_secs:
emulation.run_for(0.01)
total_time_elapsed += 0.01
if is_virtual:
print("Time Elapsed: ", total_time_elapsed)
if stop == True:
break
print("Stopping Emulation ...")
sys.stdout.flush()
emulation.stop_exp()
os.close(fd1)
# shutdown session
coreemu.shutdown()
print("Emulation finished ! ")
