"python /home/server.py h3 --get_state",
)
info("*** Send SEGTERM signal to the service running on the h2.\n"
"Let it transfer its state through the internal network.\n")
pid_old_service = (check_output(
shlex.split("pgrep -f '^python /home/server.py h2$'")).decode(
"utf-8").strip())
for _ in range(3):
check_output(shlex.split("kill {}".format(pid_old_service)))
# Wait a little bit to let the signal work.
time.sleep(1)
service_log = counter_server_h3.getLogs()
print("\n*** Current log of the service on h3: \n{}".format(service_log))
mgr.removeContainer("counter_server_h2")
info(
"*** Mod the added flow to forward traffic from h1 to h3 to switch s1.\n"
)
check_output(
shlex.split(
'ovs-ofctl mod-flows s1 "in_port={}, actions=output:{}"'.format(
s1_h1_port_num, s1_h3_port_num)))
time.sleep(10)
client_log = client_app.getLogs()
print("\n*** Setup2: Current log of the client: \n{}".format(client_log))
info("*** Migrate (Re-deploy) the couter service back to h2.\n")
counter_server_h2 = mgr.addContainer(
net.addLink(switch1, switch2, bw=10, delay="10ms")
net.addLink(switch2, h2, bw=10, delay="10ms")
info("\n*** Starting network\n")
net.start()
info("*** Run ping and UDP latency measurement with single flow.\n")
srv1_1 = mgr.addContainer(
"srv1_1", "h1", "network_measurement", "sockperf server", docker_args={}
)
ret = h2.cmd("ping -c 10 -i 0.01 10.0.0.1")
print(f"- Result of ping: \n{ret}")
ret = h2.cmd("sockperf under-load -i 10.0.0.1 -t 3 --reply-every 1")
print(f"- Result of Sockperf: \n{ret}")
mgr.removeContainer("srv1_1")
# Run netserver not in daemon mode, avoid container termination.
srv1_1 = mgr.addContainer(
"srv1_1", "h1", "network_measurement", "netserver -D", docker_args={}
)
# Wait netserver to start.
time.sleep(1)
print("** Run flent RRUL and ping tests (each 15 seconds.)")
h2.cmd("flent rrul -p all_scaled -l 15 -H 10.0.0.1 -o /flent_data/rrul.png")
h2.cmd("flent rrul -p ping_cdf -l 15 -H 10.0.0.1 -o /flent_data/ping.png")
print("Generated plot and data are located in ./examples/.")
if not AUTOTEST_MODE:
CLI(net)
def start() -> None:
net = Containernet(build=False, link=TCLink, xterms=False)
mgr = VNFManager(net)
rx_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
rx_socket.bind(("127.0.0.1", 8016))
cnt: int = 0
active_container: bool = False
full_tree: bool = False
info("\n*** Adding Controller\n")
controller1: RemoteController = net.addController(
"controller1", controller=RemoteController, ip="127.0.0.1", port=6633)
controller1.start()
info("\n*** Adding Hosts\n")
client1: DockerHost = net.addDockerHost(
"client1",
dimage="mec_test",
ip="10.0.0.10",
mac="00:00:00:00:00:01",
docker_args={"volumes": {
"/tmp": {
"bind": "/tmp",
"mode": "rw"
}
}},
)
probe1: DockerHost = net.addDockerHost(
"probe1",
dimage="mec_test",
docker_args={},
ip="10.0.0.40",
mac="00:00:00:00:01:ff",
)
server1: DockerHost = net.addDockerHost(
"server1",
dimage="mec_test",
ip="10.0.0.21",
mac="00:00:00:00:01:01",
docker_args={
"cpuset_cpus": "0",
"cpu_quota": 25000
},
)
server2: DockerHost = net.addDockerHost(
"server2",
dimage="mec_test",
ip="10.0.0.22",
mac="00:00:00:00:01:02",
docker_args={
"cpuset_cpus": "0",
"cpu_quota": 25000
},
)
server3: DockerHost = net.addDockerHost(
"server3",
dimage="mec_test",
ip="10.0.0.23",
mac="00:00:00:00:01:03",
docker_args={
"cpuset_cpus": "0",
"cpu_quota": 25000
},
)
server4: DockerHost = net.addDockerHost(
"server4",
dimage="mec_test",
ip="10.0.0.24",
mac="00:00:00:00:01:04",
docker_args={
"cpuset_cpus": "0",
"cpu_quota": 25000
},
)
if full_tree:
server5: DockerHost = net.addDockerHost(
"server5",
dimage="mec_test",
ip="10.0.0.25",
mac="00:00:00:00:01:05",
docker_args={
"cpuset_cpus": "0",
"cpu_quota": 25000
},
)
server6: DockerHost = net.addDockerHost(
"server6",
dimage="mec_test",
ip="10.0.0.26",
mac="00:00:00:00:01:06",
docker_args={
"cpuset_cpus": "0",
"cpu_quota": 25000
},
)
server7: DockerHost = net.addDockerHost(
"server7",
dimage="mec_test",
ip="10.0.0.27",
mac="00:00:00:00:01:07",
docker_args={
"cpuset_cpus": "0",
"cpu_quota": 25000
},
)
server8: DockerHost = net.addDockerHost(
"server8",
dimage="mec_test",
ip="10.0.0.28",
mac="00:00:00:00:01:08",
docker_args={
"cpuset_cpus": "0",
"cpu_quota": 25000
},
)
info("\n*** Adding Switches\n")
switch1: OVSSwitch = net.addSwitch("switch1")
switch11: OVSSwitch = net.addSwitch("switch11")
switch12: OVSSwitch = net.addSwitch("switch12")
switch111: OVSSwitch = net.addSwitch("switch111")
switch112: OVSSwitch = net.addSwitch("switch112")
switch121: OVSSwitch = net.addSwitch("switch121")
switch122: OVSSwitch = net.addSwitch("switch122")
switch1.start([controller1])
switch1.cmdPrint("ovs-vsctl show")
switch11.start([controller1])
switch11.cmdPrint("ovs-vsctl show")
switch12.start([controller1])
switch12.cmdPrint("ovs-vsctl show")
switch111.start([controller1])
switch111.cmdPrint("ovs-vsctl show")
switch112.start([controller1])
switch112.cmdPrint("ovs-vsctl show")
switch121.start([controller1])
switch121.cmdPrint("ovs-vsctl show")
switch122.start([controller1])
switch122.cmdPrint("ovs-vsctl show")
info("\n*** Adding Links\n")
net.addLink(node1=switch1, node2=client1, delay="200ms", use_htb=True)
net.addLink(node1=switch1, node2=probe1, delay="50ms", use_htb=True)
net.addLink(node1=switch1, node2=switch11, delay="10ms", use_htb=True)
if full_tree:
net.addLink(node1=switch1, node2=switch12, delay="10ms", use_htb=True)
net.addLink(node1=switch11, node2=switch111, delay="10ms", use_htb=True)
net.addLink(node1=switch11, node2=switch112, delay="10ms", use_htb=True)
if full_tree:
net.addLink(node1=switch12,
node2=switch121,
delay="10ms",
use_htb=True)
net.addLink(node1=switch12,
node2=switch122,
delay="10ms",
use_htb=True)
net.addLink(node1=switch111, node2=server1, delay="100ms", use_htb=True)
net.addLink(node1=switch111, node2=server2, delay="150ms", use_htb=True)
net.addLink(node1=switch112, node2=server3, delay="200ms", use_htb=True)
net.addLink(node1=switch112, node2=server4, delay="250ms", use_htb=True)
if full_tree:
net.addLink(node1=switch121,
node2=server5,
delay="300ms",
use_htb=True)
net.addLink(node1=switch121,
node2=server6,
delay="350ms",
use_htb=True)
net.addLink(node1=switch122,
node2=server7,
delay="400ms",
use_htb=True)
net.addLink(node1=switch122,
node2=server8,
delay="450ms",
use_htb=True)
info("\n*** Starting Network\n")
net.build()
net.start()
net.pingAll() # optional
info("\n*** Adding Docker Containers\n")
client1_container: APPContainer = mgr.addContainer(
name="client1_container",
dhost="client1",
dimage="mec_test",
docker_args={},
dcmd="python3.6 /tmp/client.py",
)
probe1_container: APPContainer = mgr.addContainer(
name="probe1_container",
dhost="probe1",
dimage="mec_test",
docker_args={},
dcmd="python3.6 /tmp/probe_agent.py",
)
probing_server1_container: APPContainer = mgr.addContainer(
name="probing_server1_container",
dhost="server1",
dimage="mec_test",
docker_args={},
dcmd="python3.6 /tmp/probe_server.py",
)
probing_server2_container: APPContainer = mgr.addContainer(
name="probing_server2_container",
dhost="server2",
dimage="mec_test",
docker_args={},
dcmd="python3.6 /tmp/probe_server.py",
)
probing_server3_container: APPContainer = mgr.addContainer(
name="probing_server3_container",
dhost="server3",
dimage="mec_test",
docker_args={},
dcmd="python3.6 /tmp/probe_server.py",
)
probing_server4_container: APPContainer = mgr.addContainer(
name="probing_server4_container",
dhost="server4",
dimage="mec_test",
docker_args={},
dcmd="python3.6 /tmp/probe_server.py",
)
if full_tree:
probing_server5_container: APPContainer = mgr.addContainer(
name="probing_server5_container",
dhost="server5",
dimage="mec_test",
docker_args={},
dcmd="python3.6 /tmp/probe_server.py",
)
probing_server6_container: APPContainer = mgr.addContainer(
name="probing_server6_container",
dhost="server6",
dimage="mec_test",
docker_args={},
dcmd="python3.6 /tmp/probe_server.py",
)
probing_server7_container: APPContainer = mgr.addContainer(
name="probing_server7_container",
dhost="server7",
dimage="mec_test",
docker_args={},
dcmd="python3.6 /tmp/probe_server.py",
)
probing_server8_container: APPContainer = mgr.addContainer(
name="probing_server8_container",
dhost="server8",
dimage="mec_test",
docker_args={},
dcmd="python3.6 /tmp/probe_server.py",
)
time.sleep(5)
print(
f"client 1 : \n{client1_container.dins.logs().decode('utf-8')}\n"
f"probe 1 : \n{probe1_container.dins.logs().decode('utf-8')}\n"
f"probing server 1 : \n{probing_server1_container.dins.logs().decode('utf-8')}\n"
f"probing server 2 : \n{probing_server2_container.dins.logs().decode('utf-8')}\n"
f"probing server 3 : \n{probing_server3_container.dins.logs().decode('utf-8')}\n"
f"probing server 4 : \n{probing_server4_container.dins.logs().decode('utf-8')}\n"
)
if full_tree:
print(
f"probing server 5 : \n{probing_server5_container.dins.logs().decode('utf-8')}\n"
f"probing server 6 : \n{probing_server6_container.dins.logs().decode('utf-8')}\n"
f"probing server 7 : \n{probing_server7_container.dins.logs().decode('utf-8')}\n"
f"probing server 8 : \n{probing_server8_container.dins.logs().decode('utf-8')}\n"
)
# time.sleep(2)
# CLI(net)
time.sleep(30)
server_container: APPContainer = None
info("\n*** Await REST instruction from Controller\n"
) # REST -> REpresentational State Transfer
while True:
data, addr = rx_socket.recvfrom(1024)
_: str = data.decode()
print(f"{_} {_[_.__len__()-1]}")
if active_container: # if container set, remove it
mgr.removeContainer(server_container.name)
time.sleep(2) # prevent hang on waitContainerStart()
print("removing container")
server_container: APPContainer = mgr.addContainer(
name="server_container",
# update dhost appropriate to target host
dhost=f"server{_[_.__len__()-1]}",
dimage="mec_test",
docker_args={},
dcmd="python3.6 /tmp/server.py",
)
print(
f"New container : \n{server_container.dins.logs().decode('utf-8')} on server{_[_.__len__()-1]}"
)
cnt += 1
active_container = True
time.sleep(10) # dont allow container change too frequent
if cnt > 10:
break
info("\n*** Removing Docker Containers\n")
mgr.removeContainer(client1_container.name)
mgr.removeContainer(probe1_container.name)
mgr.removeContainer(probing_server1_container.name)
mgr.removeContainer(probing_server2_container.name)
mgr.removeContainer(probing_server3_container.name)
mgr.removeContainer(probing_server4_container.name)
if full_tree:
mgr.removeContainer(probing_server5_container.name)
mgr.removeContainer(probing_server6_container.name)
mgr.removeContainer(probing_server7_container.name)
mgr.removeContainer(probing_server8_container.name)
info("\n*** Stopping Network\n")
net.stop()
mgr.stop()
"D6",
"drone_mqtt_client",
"python3 /home/drone_client_mqtt.py",
docker_args={})
print("*** Adding the MQTT client")
srv8 = mgr.addContainer("WebServer", "WS", "server", "", docker_args={})
print("*** Adding the web server")
srv9 = mgr.addContainer("WebClient",
"WC",
"client",
"bash",
docker_args={})
spawnXtermDocker("WebClient")
CLI(net)
mgr.removeContainer("dr1")
mgr.removeContainer("dr2")
mgr.removeContainer("dr3")
mgr.removeContainer("dr4")
mgr.removeContainer("dr5")
mgr.removeContainer("dr6")
mgr.removeContainer("MQTTBroker")
mgr.removeContainer("WebClient")
mgr.removeContainer("WebServer")
net.stop()
mgr.stop()
def testDockerInDocker(n):
net = Containernet(controller=Controller, link=TCLink)
mgr = VNFManager(net)
info("*** Adding controller\n")
net.addController("c0")
info("*** Adding Docker hosts and switches in a chain topology\n")
last_sw = None
hosts = list()
# Connect hosts
for i in range(n):
# Unlimited access to CPU(s) cycles in CPU_SETS
host = net.addDockerHost(
"h%s" % (i + 1),
dimage="dev_test",
ip="10.0.0.%s" % (i + 1),
docker_args={"cpuset_cpus": "0"},
)
hosts.append(host)
switch = net.addSwitch("s%s" % (i + 1))
net.addLink(switch, host, bw=10, delay="10ms")
if last_sw:
# Connect switches
net.addLink(switch, last_sw, bw=10, delay="10ms")
last_sw = switch
info("*** Starting network\n")
net.start()
info(
"*** Run a simple ping test between two internal containers deployed on h1 and h%s\n"
% n)
head = mgr.addContainer("head",
"h1",
"dev_test",
"/bin/bash",
docker_args={})
tail = mgr.addContainer("tail",
"h%s" % n,
"dev_test",
"ping -c 3 10.0.0.1",
docker_args={})
info("*** Tail start ping head, wait for 5s...")
time.sleep(5)
info("\nThe ping result of tail to head: \n")
print(tail.dins.logs().decode("utf-8"))
mgr.removeContainer(head.name)
mgr.removeContainer(tail.name)
time.sleep(3)
info("*** Run CPU resource limitation test.")
info("Update CPU limitation of all Docker hosts (h1-h%s) to %.2f %% \n" %
(n, 50.0 / n))
info("Update Memory limitation of all Docker hosts (h1-h%s) to 10MB\n" % n)
info(
"Deploy the stress app (100 % CPU and 300M memory) inside all Docker hosts to test the CPU/Memory limitation\n"
)
containers = list()
# Mark: CPU percent = cpu_quota / cpu_period. The default CPU period is
# 100ms = 100000 us
for i, h in enumerate(hosts):
h.dins.update(cpu_quota=int(50000 / n))
h.dins.update(mem_limit=10 * (1024**2)) # in bytes
c = mgr.addContainer(
"stress_app_%s" % (i + 1),
h.name,
"dev_test",
"stress-ng -c 1 -m 1 --vm-bytes 300M",
docker_args={},
)
containers.append(c)
info("Start monitoring resource usage of internal containers"
"with default sample count: 3 and sample period: 1 sec\n")
for c in containers:
usages = mgr.monResourceStats(c.name)
if usages:
print(
" The average CPU and Memory usage of container:{} is {:.2f}%, {:.2f}MB"
.format(
c.name,
(sum(u[0] for u in usages) / len(usages)),
(sum(u[1] for u in usages) / len(usages)),
))
else:
print("[ERROR] Failed to get resource usages from manager")
for c in containers:
mgr.removeContainer(c.name)
info("*** Stopping network\n")
net.stop()
mgr.stop()
def myTopology():
net = Containernet(
switch=OVSKernelSwitch,
build=False,
autoSetMacs=True,
autoStaticArp=True,
link=TCLink,
)
mgr = VNFManager(net)
setLogLevel("info")
info("*** Add Switches\n")
sconfig1 = {"dpid": "%016x" % 1}
sconfig2 = {"dpid": "%016x" % 2}
sconfig3 = {"dpid": "%016x" % 3}
sconfig4 = {"dpid": "%016x" % 4}
sconfig5 = {"dpid": "%016x" % 5}
net.addSwitch("s1", **sconfig1)
net.addSwitch("s2", **sconfig2)
net.addSwitch("s3", **sconfig3)
net.addSwitch("s4", **sconfig4)
net.addSwitch("s5", **sconfig5)
info("*** Add Hosts\n")
host_config = dict(inNamespace=True)
#net.addHost("h1", **host_config, ip="192.0.0.1")
h1 = net.addDockerHost(
"h1",
dimage="dev_test",
ip="192.0.0.1",
docker_args={"hostname": "h1"},
)
h2 = net.addDockerHost(
"h2",
dimage="dev_test",
ip="192.0.0.2",
docker_args={"hostname": "h2"},
)
h3 = net.addDockerHost(
"h3",
dimage="dev_test",
ip="192.0.0.3",
docker_args={"hostname": "h3"},
)
h4 = net.addDockerHost(
"h4",
dimage="dev_test",
ip="192.0.0.4",
docker_args={"hostname": "h4"},
)
h5 = net.addDockerHost(
"h5",
dimage="dev_test",
ip="192.0.0.5",
docker_args={"hostname": "h5"},
)
h6 = net.addDockerHost(
"h6",
dimage="dev_test",
ip="192.0.0.6",
docker_args={"hostname": "h6"},
)
h7 = net.addDockerHost(
"h7",
dimage="dev_test",
ip="192.0.0.7",
docker_args={"hostname": "h7"},
)
h8 = net.addDockerHost(
"h8",
dimage="dev_test",
ip="192.0.0.8",
docker_args={"hostname": "h8"},
)
info("*** Add Links\n")
net.addLink("h1", "s1", bw=B1)
net.addLink("h2", "s1", bw=B1)
net.addLink("h3", "s1", bw=B1)
net.addLink("h4", "s5", bw=B2)
net.addLink("h5", "s5", bw=B2)
net.addLink("s1", "s2", bw=B1)
net.addLink("s2", "s3", bw=B1, delay=DELAY)
net.addLink("s3", "s4", bw=B1, delay=DELAY)
net.addLink("s2", "s4", bw=B2)
net.addLink("s1", "s4", bw=B1)
net.addLink("s1", "s5", bw=B1)
net.addLink("s4", "h6", bw=B1)
net.addLink("s4", "h7", bw=B1)
net.addLink("s4", "h8", bw=B1)
info("*** Add controller\n")
controller = RemoteController("c0", ip="127.0.0.1", port=6633)
net.addController(controller)
net.build()
#controller.start()
#s1.start( [controller] )
#s2.start( [controller] )
#s1.cmd("ovs-vsctl set port s1-eth4 qos=@newqos -- --id=@newqos create QoS type=linux-htb other-config:max-rate=1000000 queues:123=@1q queues:234=@2q -- --id=@1q create queue other-config:min-rate=100000 other-config:max-rate=700000 -- --id=@2q create queue other-config:min-rate=100000 other-config:max-rate=700000")
#s1.cmd("ovs-ofctl add-flow s1 nw_src=192.0.0.2,nw_dst=192.0.0.7,actions=enqueue:4:123")
net.start()
srv1 = mgr.addContainer(
"srv1",
"h1",
"servernew",
"python /home/servernew.py",
docker_args={},
) #autonomus
srv2 = mgr.addContainer(
"srv2",
"h2",
"dev_test",
"bash",
docker_args={},
) #udp
srv3 = mgr.addContainer(
"srv3",
"h3",
"eclipse-mosquitto",
"bash",
docker_args={},
) #brocker
srv4 = mgr.addContainer(
"srv4",
"h4",
"aksakalli/mqtt-client",
"bash /home/clientnew.sh",
docker_args={},
)
srv5 = mgr.addContainer(
"srv5",
"h5",
"aksakalli/mqtt-client",
"bash",
docker_args={},
)
srv6 = mgr.addContainer(
"srv6",
"h6",
"dev_test",
"bash",
docker_args={},
)
srv7 = mgr.addContainer(
"srv7",
"h7",
"dev_test",
"bash",
docker_args={},
)
srv8 = mgr.addContainer(
"srv8",
"h8",
"dev_test",
"bash",
docker_args={},
)
spawnXtermDocker("srv2")
spawnXtermDocker("srv7")
CLI(net)
mgr.removeContainer("srv1")
mgr.removeContainer("srv2")
mgr.removeContainer("srv3")
mgr.removeContainer("srv4")
mgr.removeContainer("srv5")
mgr.removeContainer("srv6")
mgr.removeContainer("srv7")
mgr.removeContainer("srv8")
net.stop()
mgr.stop()
info("\n*** Starting network\n")
net.start()
srv1 = mgr.addContainer("srv1",
"mqttServer",
"eclipse-mosquitto",
"",
docker_args={})
srv2 = mgr.addContainer("srv2",
"webServer",
"webserver",
"",
docker_args={})
srv3 = mgr.addContainer(
"srv3",
"drone",
"drone",
"python /drone/drone.py --ip 10.0.0.1 --port 1883 --debug",
docker_args={})
srv4 = mgr.addContainer("srv4", "client", "client", "bash", docker_args={})
spawnXtermDocker("srv4")
CLI(net)
mgr.removeContainer("srv1")
mgr.removeContainer("srv2")
mgr.removeContainer("srv3")
mgr.removeContainer("srv4")
net.stop()
mgr.stop()
docker_args={
"volumes": FFPP_VOLS,
"working_dir": "/ffpp_app",
"nano_cpus": int(3e8),
},
)
time.sleep(1)
spawnXtermDocker("distributor")
CLI(net)
print("- Add the dummy VNF on the host h2.")
dummy_vnf = mgr.addContainer(
"dummy_vnf",
"h2",
"ffpp",
"bash",
docker_args={
"volumes": FFPP_VOLS,
"working_dir": "/ffpp_app",
"nano_cpus": int(3e8),
},
)
spawnXtermDocker("dummy_vnf")
time.sleep(1)
CLI(net)
mgr.removeContainer("distributor")
mgr.removeContainer("dummy_vnf")
net.stop()
mgr.stop()
def myTopology():
net = Containernet(
switch=OVSKernelSwitch,
build=False,
autoSetMacs=True,
autoStaticArp=True,
link=TCLink,
)
mgr = VNFManager(net)
setLogLevel("info")
info("*** Add Switches\n")
sconfig1 = {"dpid": "%016x" % 1}
sconfig2 = {"dpid": "%016x" % 2}
sconfig3 = {"dpid": "%016x" % 3}
sconfig4 = {"dpid": "%016x" % 4}
net.addSwitch("s1", **sconfig1)
net.addSwitch("s2", **sconfig2)
net.addSwitch("s3", **sconfig3)
net.addSwitch("s4", **sconfig4)
info("*** Add Hosts\n")
host_config = dict(inNamespace=True)
#net.addHost("h1", **host_config, ip="192.0.0.1")
h1 = net.addDockerHost(
"h1",
dimage="dev_test",
ip="192.0.0.1",
docker_args={"hostname": "h1"},
)
h2 = net.addDockerHost(
"h2",
dimage="dev_test",
ip="192.0.0.2",
docker_args={"hostname": "h2"},
)
h3 = net.addDockerHost(
"h3",
dimage="dev_test",
ip="192.0.0.3",
docker_args={"hostname": "h3"},
)
h4 = net.addDockerHost(
"h4",
dimage="dev_test",
ip="192.0.0.4",
docker_args={"hostname": "h4"},
)
h5 = net.addDockerHost(
"h5",
dimage="dev_test",
ip="192.0.0.5",
docker_args={"hostname": "h5"},
)
h6 = net.addDockerHost(
"h6",
dimage="dev_test",
ip="192.0.0.6",
docker_args={"hostname": "h6"},
)
h7 = net.addDockerHost(
"h7",
dimage="dev_test",
ip="192.0.0.7",
docker_args={"hostname": "h7"},
)
info("*** Add Links\n")
net.addLink("h1", "s1", bw=B1)
net.addLink("h2", "s1", bw=B1)
net.addLink("h3", "s1", bw=B1)
net.addLink("h4", "s1", bw=B1)
net.addLink("s1", "s2", bw=B1)
net.addLink("s2", "s3", bw=B1, delay=DELAY)
net.addLink("s3", "s4", bw=B1, delay=DELAY)
net.addLink("s2", "s4", bw=B2)
net.addLink("s1", "s4", bw=B1)
net.addLink("s4", "h5", bw=B1)
net.addLink("s4", "h6", bw=B1)
net.addLink("s4", "h7", bw=B1)
info("*** Add controller\n")
controller = RemoteController("c1", ip="127.0.0.1", port=6633)
net.addController(controller)
net.build()
net.start()
srv1 = mgr.addContainer(
"srv1",
"h1",
"echo_server",
"python /home/server_ad.py",
docker_args={},
)
srv2 = mgr.addContainer(
"srv2",
"h2",
"echo_server",
"python /home/server.py",
docker_args={},
)
srv3 = mgr.addContainer(
"srv3",
"h3",
"echo_server",
"python /home/server.py",
docker_args={},
)
srv4 = mgr.addContainer(
"srv4",
"h4",
"dev_test",
"bash",
docker_args={},
)
srv5 = mgr.addContainer(
"srv5",
"h5",
"dev_test",
"bash",
docker_args={},
)
srv6 = mgr.addContainer(
"srv6",
"h6",
"dev_test",
"bash",
docker_args={},
)
srv7 = mgr.addContainer(
"srv7",
"h7",
"dev_test",
"bash",
docker_args={},
)
spawnXtermDocker("srv5")
spawnXtermDocker("srv1")
CLI(net)
mgr.removeContainer("srv1")
mgr.removeContainer("srv2")
mgr.removeContainer("srv3")
mgr.removeContainer("srv4")
mgr.removeContainer("srv5")
mgr.removeContainer("srv6")
mgr.removeContainer("srv7")
net.stop()
mgr.stop()