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()
node1 = session.add_node(CoreNode, options=options)
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, node2.id, interface1_data, interface2_data)
# instantiate session
session.instantiate()
# pause script for verification
input("press enter for shutdown")
# shutdown session
coreemu.shutdown()
def __init__(self, ip4_prefix: str = None, ip6_prefix: str = None) -> None:
"""
Creates an InterfaceHelper object.
:param ip4_prefix: ip4 prefix to use for generation
:param ip6_prefix: ip6 prefix to use for generation
:raises ValueError: when both ip4 and ip6 prefixes have not been provided
"""
self.prefixes: IpPrefixes = IpPrefixes(ip4_prefix, ip6_prefix)
def test_two_emane_interfaces(self, session: Session):
"""
Test nodes running multiple emane interfaces.
:param core.emulator.coreemu.EmuSession session: session for test
"""
# create emane node for networking the core nodes
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions()
options.set_position(80, 50)
options.emane = EmaneIeee80211abgModel.name
emane_net1 = session.add_node(EmaneNet, options=options)
options.emane = EmaneRfPipeModel.name
emane_net2 = session.add_node(EmaneNet, options=options)
# create nodes
options = NodeOptions(model="mdr")
options.set_position(150, 150)
node1 = session.add_node(CoreNode, options=options)
options.set_position(300, 150)
node2 = session.add_node(CoreNode, options=options)
# create interfaces
ip_prefix1 = IpPrefixes("10.0.0.0/24")
ip_prefix2 = IpPrefixes("10.0.1.0/24")
for i, node in enumerate([node1, node2]):
node.setposition(x=150 * (i + 1), y=150)
iface_data = ip_prefix1.create_iface(node)
session.add_link(node.id, emane_net1.id, iface1_data=iface_data)
iface_data = ip_prefix2.create_iface(node)
session.add_link(node.id, emane_net2.id, iface1_data=iface_data)
# instantiate session
session.instantiate()
# ping node2 from node1 on both interfaces and check success
status = ping(node1, node2, ip_prefix1, count=5)
assert not status
status = ping(node1, node2, ip_prefix2, count=5)
assert not status
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(EmaneNet, 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(CoreNode, options=options)
node.setposition(x=150 * (i + 1), y=150)
interface = prefixes.create_iface(node)
session.add_link(node.id, emane_network.id, iface1_data=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, 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 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 main():
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu: CoreEmu = globals()["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)
# create nodes
for _ in range(NODES):
node = session.add_node(CoreNode)
interface = prefixes.create_iface(node)
session.add_link(node.id, switch.id, iface1_data=interface)
# instantiate session
session.instantiate()
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()
# 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)
import logging
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.lxd import LxcNode
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG)
coreemu = CoreEmu()
session = coreemu.create_session()
session.set_state(EventTypes.CONFIGURATION_STATE)
try:
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
options = NodeOptions(image="ubuntu")
# create node one
node1 = session.add_node(LxcNode, options=options)
interface1_data = prefixes.create_iface(node1)
# create node two
node2 = session.add_node(CoreNode)
interface2_data = prefixes.create_iface(node2)
# add link
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
# instantiate
session.instantiate()
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 ! ")
def ip_prefixes():
return IpPrefixes(ip4_prefix="10.83.0.0/16")
from core.location.mobility import BasicRangeModel
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()
