Changes between Initial Version and Version 1 of Workshops/Sig Comm2022/Mininet Optical

Timestamp:

Aug 16, 2022, 10:38:05 PM (2 years ago)

Author:

rajag

Comment:

—

Workshops/Sig Comm2022/Mininet Optical

@@ +1 @@
+[[Include(WikiToC)]]
+
+== Setting up a Virtual / Simulated Optical Network using the Mininet-Optical Software Emulator ==
+
+This wiki page is intended for participants attending COSMOS workshop in SIGCOMM 2022. This contains a tutorial for setting up a virtual/simulated optical network using Mininet-Optical. [https://mininet-optical.org Mininet-Optical] was developed as part of the COSMOS and COSM-IC projects and 
+adds optical network emulation and simulation capabilities to
+[https://mininet.org Mininet] to support software emulation of optical and packet-optical networks,
+including modeling of optical transmission effects and impairments.
+
+This is a Mininet-Optical version of the tutorial at [wiki:Workshops/SigComm2022/OpticalTutorial] and is intended to show how an experiment designed for COSMOS' optical network testbed (hardware) may be adapted for use in a software emulation environment running on Linux (for example in a VM on a laptop or other hardware server), and how Mininet-Optical may be used to design experiments that will later be run on the COSMOS hardware testbed.
+
+The Mininet-Optical version of this tutorial implements the same network topology and the same experiment as the hardware testbed tutorial, but there are differences between the software and hardware environments.
+
+Please refer to [wiki:Workshops/SigComm2022/OpticalTutorial] for comparison with the hardware environment.
+
+----
+= Description =
+The COSMOS testbed enables creation and use of optical networks of various topologies. Similarly, Mininet-Optical enables creation of virtual optical networks using software emulation. An example of how an optical network could be configured and used is provided. A simple experiment on switching of optical paths is described.
+
+----
+
+= Compute Nodes and ToR switch interfaces used =
+
+* Each compute node has 1 Ethernet interface:
+{{{
+srv1-co1-eth0
+srv1-lg1-eth0
+srv2-lg1-eth0
+}}}
+
+* There are three ToR Ethernet interfaces:
+{{{
+sw-da-co1-eth1
+sw-da-lg1-eth2
+sw-da-lg1-eth3
+}}}
+
+* There are three WDM transceivers, with separate output and input ports:
+{{{
+sw-da-co1-wdm320/321
+sw-da-lg1-wdm290/291
+sw-da-lg1-wdm310/311
+}}}
+
+* and two COMB Sources, with Line-out ports:
+{{{
+comb1-wdm4201
+comb2-wdm4201
+}}}
+
+
+----
+
+= Experiment_1 Context =
+ || [[Image(sigcomm2022tutorial_topology.png, width=500px)]] ||
+Fig.1 Logical Topology of Experiment_1
+
+This experiment demonstrates optical switching between the short (1-hop) path, between {{{srv1-co1}}} and {{{srv1-lg1}}}, and the long (2-hop) path, between {{{srv1-co1}}} and {{{srv2-lg1}}}. It represents changing of the light path in C-RAN when a "Client" wants to dynamically change its base-band processing location between a nearby "Edge Cloud" and a further away "Central Cloud".
+
+To simulate the topology in hardware, the network component names are kept the same. 
+
+Experiment includes 3 servers:
+{{{
+srv1-co1 (192.168.1.1/24)
+srv1-lg1 (192.168.1.2/24)
+srv2-lg1 (192.168.1.3/24)]
+}}}
+
+Experiment includes 4 ROADMs:
+{{{
+rdm1-co1 (localhost:1834)
+rdm1-lg1 (localhost:1832)
+rdm2-lg1 (localhost:1833)
+rdm2-co1 (localhost:1844)
+}}}
+
+
+2 ToR Switches are connected to the 3 servers on the following interfaces:
+
+{{{
+sw-da-co1-eth1 <--> srv1-co1-eth0
+sw-da-lg1-eth2 <--> srv1-lg1-eth0
+sw-da-lg1-eth3 <--> srv2-lg1-eth0
+}}}
+
+
+3 Ethernet interfaces and 3 WDM transceivers will be connected within the ToR switch:
+
+{{{
+sw-da-co1-eth1 ; sw-da-co1-wdm320/321  (output/input)
+sw-da-lg1-eth2 ; sw-da-lg1-wdm290/291  (output/input)
+sw-da-lg1-eth3 ; sw-da-lg1-wdm310/311  (output/input)
+}}}
+
+
+We are assigning the following wavelength to the transceivers:
+
+{{{
+1543.60 nm, 194.35 THz with bandwidth ~[194.30;194.40] THz
+This corresponds to channel 61 in Mininet-Optical's as well as COSMOS' default channel grid.
+}}}
+
+We are assigning the following bands of wavelength to the comb sources to simulate background traffic:
+
+{{{
+Band 1: [1560.50,1564.10] nm ~ [191.80,192.25] THz. This corresponds to channels 10-19 in Mininet-Optical's and COSMOS' default channel grid.
+Band 2: [1548.40,1552.00] nm ~ [193.30,193.75] THz. This corresponds to channels 40-49 in Mininet-Optical's and COSMOS' default channel grid.
+Band 3: [1532.60,1536.10] nm ~ [195.30,195.75] THz. This corresponds to channels 80-89 in Mininet-Optical's and COSMOS' default channel grid.
+}}}
+
+
+----
+= Installing Mininet-Optical disk image on COSMOS' node =
+
+Before starting this tutorial, you will need to install Mininet-Optical in the console. We have already created a disk image with a pre-installed version of Mininet-Optical with necessary codes. If you don't have access to the COSMOS' console already, you can follow the sign-up and installation instructions at [wiki:Workshops/SigComm2022/SignupInstructions]
+
+To install the Mininet-Optical disk image, follow the below steps:
+
+1. Remove any installed disk images on the node
+{{{#!shell-session
+user@console:~$ omf tell -a reset -t <node>
+}}}
+    Here, <node> is the name of the appropriate node (for example, node1-2.sb2.orbit-lab.org)
+2. Install the Mininet-Optical OS image file.
+{{{#!shell-session
+user@console:~$ omf load -i sigcomm22-mnoptical-tutorial.ndz -t <node>
+}}}
+3. Turn the node on
+{{{#!shell-session
+user@console:~$ omf tell -a on -t <node>
+}}}
+3. Ping the node to check if disk image has been installed correctly 
+{{{#!shell-session
+user@console:~$ ping <node>
+}}}
+4. Log in to the node, and fetch the latest version of Mininet-Optical
+{{{#!shell-session
+$ ssh root@<node>
+root@node# cd mininet-optical
+root@node:~/mininet-optical# git fetch
+root@node:~/mininet-optical# git checkout cosmos-tutorial
+root@node:~/mininet-optical# git pull --rebase
+root@node:~/mininet-optical# make install certs
+}}}
+5. Run a sample script to check Mininet-Optical has been installed correctly. 
+{{{#!shell-session
+root@node:~/mininet-optical# sudo PYTHONPATH=. python3 ./examples/simplelink.py
+}}}
+
+The tutorial topology and a sample configuration script should be found in `~/mininet-optical/examples/sigcommtutorial.py` and `~/mininet-optical/examples/config-sigcommtutorial.sh`.
+
+If you want to test out Mininet-Optical on your computer after the tutorial, we have provided necessary resources in the appendix. 
+
+----
+
+= Setting Up the Optical Topology =
+
+In the COSMOS optical testbed, all devices are connected to a Calient S320 space switch. This switch serves as a programmable patch panel that allows any port to be connected to any other port, enabling realization of arbitrary topologies with fast reconnection between experiments.
+
+It is possible to create a virtual space switch/programmable patch panel in Mininet-Optical to emulate the COSMOS optical testbed itself, but for this tutorial we will implement the topology using Mininet-Optical's topology API.
+
+The Mininet-Optical emulated network is created using a Python script, [https://github.com/Mininet-Optical/mininet-optical/blob/cosmos-tutorial/mnoptical/examples/sigcommtutorial.py examples/sigcommtutorial.py]. Take a look at it now to see how the topology is implemented.
+
+The topology itself is created using Mininet's high-level topology template API. Specifically, we create a subclass of class `Topo` and override the `build()` method:
+
+
+{{{#!python
+class TutorialTopo( Topo ):
+...
+    def build( self ):
+}}}
+
+
+ROADMs, Comb Sources and ToR switches are added using `addSwitch()` calls:
+
+{{{#!python
+    # ROADMs
+    NC = NetconfPortBase
+    rdm1co1 = self.addSwitch('rdm1co1', cls=LROADM, netconfPort=NC+4)
+    ...
+    # ToR switches
+    swda_co1 = self.addSwitch('swda-co1', cls=Terminal, transceivers=[('32', -1.5*dBm)])
+    ...
+    #Comb Sources
+    comb1 = self.addSwitch('comb1', cls=CombSource, power=comb1_power)
+    ...
+}}}
+
+Servers are added using `addHost()` calls:
+
+{{{#!python
+    # Servers
+    srv1_co1 = self.addHost('srv1-co1')
+        ...
+}}}
+
+In Mininet, ports are created by specifying port numbers when we add links.
+(This is due to the underlying link emulation which uses Linux virtual Ethernet (`veth`)
+pairs.)
+
+Because of this, we need to specify the correct port numbers when we create the links.
+
+The base port numbers for a Lumentum ROADM20 are specified at the top of the file:
+
+{{{#!python
+# Lumentum Roadm20 Port numbering
+LINEIN, LINEOUT = 5101, 4201
+ADD, DROP = 4100, 5200
+}}}
+
+The server and ToR port numbers are as specified above. These port numbers are exactly the same as hardware experiment. 
+
+Boost and Pre-amp amplifiers associated with ROADMS are added accordingly in the inter-ROADM connections. WDM fiber links are unidirectional and are added using `wdmLink()` calls:
+
+{{{#!python3
+    # Inter-ROADM links
+    # We put 32km of fiber between rdm2lg1 and rdm2co1
+    # Default fiber length is 1m if not specified
+
+    # Sub-millisecond delays won't be accurate (due to scheduler timing
+    # granularity and running in a VM) but this will add observable
+    # propagation delay for the longer links.
+
+    self.wdmLink(rdm1co1, rdm1lg1, LINEOUT, LINEIN, 
+        spans=[0.0*m,
+            ('boost', {'target_gain': 18.0*dB, 'wdg_id': 'wdg1'}), 
+            10.0*km, 
+            ('preamp', {'target_gain': 18.0*dB, 'wdg_id': 'wdg1'})], 
+        delay='33us')
+
+     self.wdmLink(rdm1lg1, rdm1co1, LINEOUT, LINEIN, 
+        spans=[0.0*m,
+            ('boost', {'target_gain': 18.0*dB, 'wdg_id': 'linear'}),
+            10.0*km, 
+            ('preamp', {'target_gain': 18.0*dB, 'wdg_id': 'linear'})], 
+        delay='33us')
+
+    # Configuring Optical links between rdm1-lg1 and rdm2-lg1
+    self.wdmLink(rdm1lg1, rdm2lg1, DROP+11, ADD+11)      # Forward pass-through
+    self.wdmLink(rdm2lg1, rdm1lg1, DROP+11, ADD+11)      # Backward pass-through
+
+    # Configuring Optical Links between rdm2-lg1 and rdm2-co1
+    self.wdmLink(rdm2lg1, rdm2co1, LINEOUT, LINEIN, 
+        spans=[0.0*m,
+           ('boost', {'target_gain': 18.0*dB, 'wdg_id': 'wdg1'}),
+            32.0*km, 
+            ('preamp', {'target_gain': 18.0*dB, 'wdg_id': 'wdg1'})], 
+        delay='106us')                                   # Forward Link
+    self.wdmLink(rdm2co1, rdm2lg1, LINEOUT, LINEIN, 
+       spans=[0.0*m,
+            ('boost', {'target_gain': 18.0*dB, 'wdg_id': 'wdg2'}),
+            32.0*km, 
+            ('preamp', {'target_gain': 18.0*dB, 'wdg_id': 'wdg2'})], 
+        delay='106us')                                   # Backward Link
+
+    # ROADM add/drop 2 <-> ToR transceiver links
+    self.wdmLink(swda_co1, rdm1co1, 320, ADD+2)        #Forward Link
+    self.wdmLink(rdm1co1, swda_co1, DROP+2, 321)       #Backward Link
+    ...
+    # Configuring Optical Links between Comb Source and Tor ROADMS
+    self.wdmLink(comb1, rdm1co1, CombSource.LINEOUT, ADD+1)
+    ...
+    # Configuring Ethernet connections between Servers and Tor switches
+    self.addLink(server1, swda_co1, port1=0, port2=1)
+
+}}}
+
+Lastly, the topology and network objects are instantiated and everything is started up (and shut down) in the `__main__` section of the network setup script:
+
+{{{#!python
+if __name__ == '__main__':
+    ...
+    topo = TutorialTopo()
+    net = Mininet( topo=topo, controller=None )
+    restServer = RestServer( net )
+    net.start()
+    restServer.start()
+    netconfServer = NetconfServer(
+        net, username=username, password=password, sslkeyfile=sslkeyfile )
+    netconfServer.start()
+    ...
+    if 'test' in argv:
+        test(net)
+    else:
+        info(TutorialTopo.__doc__+'\n')
+        CLI(net)
+    netconfServer.stop()
+    restServer.stop()
+    net.stop()
+    info( 'Done.\n')
+}}}
+
+= Creating the Mininet-Optical Network =
+
+All of these commands should be run in a terminal window for the VM or server where Mininet-Optical is installed.
+
+1. We will run Mininet-Optical from the top directory of the source tree:
+
+{{{#!shell-session
+root@node:# cd ~/mininet-optical
+}}}
+
+2. We should check to make sure that the tutorial scripts are present:
+
+{{{#!shell-session
+root@node:~/mininet-optical# ls examples/sigcommtutorial.py
+root@node:~/mininet-optical# ls examples/config-sigcommtutorial.sh
+}}}
+
+3. If they are missing, we can fetch and install the appropriate branch:
+
+{{{#!shell-session
+root@node:~/mininet-optical# git fetch
+root@node:~/mininet-optical# git checkout cosmos-tutorial
+root@node:~/mininet-optical# make install
+}}}
+
+4. Since the NETCONF agents for the ROADMs use SSL, we first have to generate a set of (self-signed) SSL certificates for them to use:
+
+{{{#!shell-session
+root@node:~/mininet-optical# make certs
+}}}
+
+5. Now we should be able to run the tutorial script to create the emulated network:
+
+{{{#!shell-session
+root@node:~/mininet-optical# sudo PYTHONPATH=. examples/cosmostutorial.py
+}}}
+
+6. This should start up Mininet-Optical, create the tutorial network, and start the CLI:
+
+{{{#!shell-session
+SIGCOMM22 mini-tutorial topology
+
+
+comb1 -> rdm1co1 <--10km--> rdm1lg1 || rdm2lg1 <--34km--> rdm2co1 <- comb2
+           |                  |                              |
+        swda_co1           swda_lg1--------------------------|
+           |                  |                              |
+        srv1-co1           srv1-lg1                       srv2-lg1
+
+This is for the SIGCOMM22 mini-tutorial at:
+https://wiki.cosmos-lab.org/wiki/Workshops/SigComm2022/MininetOptical
+
+*** Starting CLI:
+mininet-optical> 
+}}}
+
+Mininet-Optical CLI commands may be entered at the `mininet-optical>` prompt.
+
+= Controller Configuration =
+
+Now that we have the topology setup for the network, we want to configure the lightpaths and pass packets using [https://datatracker.ietf.org/group/netconf/about/ NETCONF], which is network management protocol for software defined networks. We have this configuration in the file [https://github.com/Mininet-Optical/mininet-optical/blob/cosmos-tutorial/mnoptical/examples/config-sigcommtutorial.py examples/config-sigcommtutorial.py], which we require to run from another terminal window. 
+
+(Note: if you want to use the X11 features of Mininet, such as the `xterm` or `plot` commands, you may need to use `sudo HOME=~` rather than just `sudo`.)
+<Should we add instructions to setup x11?>
+
+If you don't have one open already, open up another terminal window with the below instructions: 
+
+=== [WIP] Opening another terminal window in Orbit ===
+
+1. SSH into
+
+{{{
+#!shell-session
+user@console:~$ cd ~/mininet-optical
+}}}
+
+2. Connect to the VM where Mininet-Optical is installed
+
+{{{
+#!shell-session
+user@console:~$ cd ~/mininet-optical
+}}}
+
+3. Enter source directory
+
+{{{#!shell-session
+user@console:~$ cd ~/mininet-optical
+}}}
+
+Unless specified otherwise, all of the configuration commands below should
+be entered in this second window at the shell prompt.
+All of these configurations can be performed by Python scripts developed to work with the COSMOS test-bed. The Python commands send NETCONF commands to the ROADM.
+
+=== Setting “Snake” Connection ===
+
+(This is not currently part of the Mininet-Optical software emulated configuration.)
+
+=== Running the configuration script ===
+
+Run the script with the following command
+{{{#!shell-session
+root@node:~/mininet-optical# bash -x ./examples/config-sigcommtutorial.py
+}}}
+
+This executes the configuration file which establishes the ground connections first and turns on the transceivers. We walk through the scipt below to deep dive into what's happening. 
+
+Mininet-Optical's `Terminal` is the equivalent of the ToR switch
+which contains Ethernet interfaces as well as WDM transceivers.
+
+Instead of using a Cisco-style CLI to configure it, we use its
+default REST API.
+
+As noted above, 194.35 THz corresponds to channel C61 on Mininet-Optical's default 50GHz channel grid. C1's middle frequency is 191350 GHz, so C61 is at 191350 + 60*50 = 194350 GHz.
+
+1. Connect Ethernet interfaces to Transceivers and set channel
+
+{{{#!bash
+curl "$swda_co1/connect?node=swda-co1&ethPort=1&wdmPort=320&wdmInPort=321&channel=61"
+curl "$swda_lg1/connect?node=swda-lg1&ethPort=2&wdmPort=290&wdmInPort=291&channel=61"
+curl "$swda_lg1/connect?node=swda-lg1&ethPort=3&wdmPort=310&wdmInPort=311&channel=61"
+}}}
+
+2. Turn on all transceivers and comb sources
+
+{{{#!bash
+curl "$swda_co1/turn_on?node=swda-co1"
+curl "$swda_lg1/turn_on?node=swda-lg1"
+curl "$comb1/turn_on?node=comb1"
+curl "$comb2/turn_on?node=comb2"
+}}}
+
+3. Configure Ethernet interfaces and assign IP addresses:
+
+{{{#!bash
+...
+m=~/mininet/util/m
+...
+$m srv1-co1 ifconfig srv1-co1-eth0 192.168.1.1/24
+$m srv1-lg1 ifconfig srv1-lg1-eth0 192.168.1.2/24
+$m srv2-lg1 ifconfig srv2-lg1-eth0 192.168.1.3/24
+}}}
+
+Note that `~/mininet/util/m` can be used to 'log in' to any one of the servers much as you would with `ssh` (but it actually spawns a shell in the appropriate `cgroup`/network namespace.)
+
+----
+
+=== Performing base test configuration
+
+Once you execute the script, the script will ask for a prompt to perform a base test. This test pings 'srv-co1' to 'srv-lg1'; and pings 'srv-co1' to 'srv2-lg1' without establishing any lightpath connections between ROADMS. Press `Return` key to perform the base test.
+
+{{{#!shell-session
+*** Base test before configuration
+press return to test base configuration>
+...
+*** srv1-co1 pinging srv1-lg1
+PING 192.168.1.2 (192.168.1.2) 56(84) bytes of data.
+64 bytes from 192.168.1.2: icmp_seq=1 ttl=64 time=0.932 ms
+64 bytes from 192.168.1.2: icmp_seq=2 ttl=64 time=0.145 ms
+64 bytes from 192.168.1.2: icmp_seq=3 ttl=64 time=0.153 ms
+
+--- 192.168.1.2 ping statistics ---
+3 packets transmitted, 3 received, 0% packet loss, time 2089ms
+rtt min/avg/max/mdev = 0.145/0.410/0.932/0.369 ms
+...
+*** srv1-co1 pinging srv2-lg1
+PING 192.168.1.3 (192.168.1.3) 56(84) bytes of data.
+From 192.168.1.1 icmp_seq=1 Destination Host Unreachable
+From 192.168.1.1 icmp_seq=2 Destination Host Unreachable
+From 192.168.1.1 icmp_seq=3 Destination Host Unreachable
+
+--- 192.168.1.3 ping statistics ---
+3 packets transmitted, 0 received, +3 errors, 100% packet loss, time 2192ms
+}}}
+
+As expected, none of the servers are able to ping each other because no lightpath connections have been established as of yet.
+
+== Configuring ROADMs
+
+ROADMs in Mininet-Optical may be configured via several mechanisms. An internal Python API may be used for configuration within the script that creates the network. More realistically, two external SDN/RPC control interfaces are provided: a simple REST interface and a more realistic NETCONF interface which is partially compatible with the NETCONF interface of the hardware Lumentum ROADM20.
+
+For this tutorial, we are using NETCONF interface to configure the ROADMs to closely match the interface used in hardware experiment.
+
+=== [WIP] MUX/DEMUX configuration ===
+
+As a reminder, here are the ROADM port numbers:
+
+* ROADM 4:
+        DEMUX IN/OUT (ADD1/LINEOUT) port: 5101/5201
+        MUX IN/OUT (LINEIN/DROP1)port: 4101/4201
+* ROADM 1:
+        DEMUX IN/OUT (ADD1/LINEOUT) port: 5101/5201
+        MUX IN/OUT (LINEIN/DROP1) port: 4101/4201
+* ROADM 2:
+        DEMUX IN/OUT (ADD1/LINEOUT) port: 5101/5201
+        MUX IN/OUT (LINEIN/DROP1) port: 4101/4201
+* ROADM 3:
+        DEMUX IN/OUT (ADD1/LINEOUT) port: 5101/5201
+        MUX IN/OUT (LINEIN/DROP1) port: 4101/4201
+
+Note that the servers are connected to ADD2/DROP2 while DROP1/ADD1 are used
+as passthrough ports between ROADM 1 and ROADM 2.
+
+''Also note that these port numbers are the same as the hardware
+tutorial page.''
+
+== Network Interfaces Configuration for Experiment_1 (short-hop) ==
+
+In Experiment 1, we are choosing to pass the optical signal through 1 hop (via a pair of 10km fiber spools). This requires us to establish a connection between rdm1-co1 and rdm1-lg1.
+Once you perform the base test as described above, the script will prompt you to press `Return` key to perform the test for configuration 1. Before trying the configuration, let's dive into what connections this script will install:
+
+==== Configuring srv1-co1<=>srv1-lg1 Connection 1 on Mininet-Optical using NETCONF ====
+
+* **rdm1-co1**:
+1. Enable MUX port 4102 “From sw-da-co1” 
+2. Add Connection “Exp1_From_sw-da-co1” with Input/ Output Port 4102/4201 with bandwidth [194.30;194.40]
+3. Enable DEMUX port 5202 “Toward sw-da-co1”
+4. Add Connection “Exp1_Toward_sw-da-co1” with I/O Port 5101/5202
+
+The NETCONF servers for `rdm-co1`[r4] and `rdm-lg1`[r1] are listening on `localhost` at ports 1834 and 1831, respectively.
+We will use the `examples/nc_add_connection.py` script to configure connections using NETCONF.
+
+{{{#!bash
+testdir=$(dirname $0)
+addc=$testdir/nc_add_connection.py
+r4=localhost:1834
+r1=localhost:1831
+}}}
+
+Note that MUX/ADD/LINEOUT is module 1 and DEMUX/DROP/LINEIN is module 2. We are calling all of our connections connection 10. The interfaces are `in-service` and `blocked` is `false`. The 5 is an attenuation setting which may currently be ignored in Mininet-Optical.
+
+{{{#!bash
+$addc $r4 1 10 in-service false 4102 4201 194300 194400 5 Exp1_From_sw-da-co1
+$addc $r4 2 10 in-service false 5101 5202 194300 194400 5 Exp1-Toward_swda_co1
+}}}
+
+* **rdm1-lg1**:
+5. Enable MUX port 4102 “From sw-da-lg1” 
+6. Add Connection “Exp1_From_sw-da-lg1” with I/O Port 4102/4201 with bandwidth [192.95;193.05] 
+7. Enable DEMUX port 5202 “Towards sw-da-lg1”
+8. Add Connection “Exp1_Towards_sw-da-lg1” with I/O Port 5101/5202
+
+{{{#!bash
+$addc $r1 1 10 in-service false 4102 4201 194300 194400 5 Exp1_From_sw-da-lg1
+$addc $r1 2 10 in-service false 5101 5202 194300 194400 5 Exp1_Toward_sw-da-lg1
+}}}
+
+----
+
+==== Performing the experiment and results
+
+Now you can try installing the above lightpaths by yourself. As prompted by the terminal, press `Return` to install the configuration and perform the test. This will establish the connections between ROADMs as described above, which you can also view with the lines printed. 
+
+
+{{{#!shell-session
+...
+*** Test configuration 1
+press return to configure and test configuration 1>
+...
+*** Installing ROADM configuration 1 for srv1-co1<-->srv1-lg1 (NETCONF)
+...
+*** srv1-co1 pinging srv1-lg1
+PING 192.168.1.2 (192.168.1.2) 56(84) bytes of data.
+64 bytes from 192.168.1.2: icmp_seq=1 ttl=64 time=0.724 ms
+64 bytes from 192.168.1.2: icmp_seq=2 ttl=64 time=0.164 ms
+64 bytes from 192.168.1.2: icmp_seq=3 ttl=64 time=0.130 ms
+
+--- 192.168.1.2 ping statistics ---
+3 packets transmitted, 3 received, 0% packet loss, time 2130ms
+rtt min/avg/max/mdev = 0.130/0.339/0.724/0.272 ms
+
+...
+
+*** srv1-co1 pinging srv2-lg1
+PING 192.168.1.3 (192.168.1.3) 56(84) bytes of data.
+From 192.168.1.1 icmp_seq=1 Destination Host Unreachable
+From 192.168.1.1 icmp_seq=2 Destination Host Unreachable
+From 192.168.1.1 icmp_seq=3 Destination Host Unreachable
+
+--- 192.168.1.3 ping statistics ---
+3 packets transmitted, 0 received, +3 errors, 100% packet loss, time 2192ms
+}}}
+
+As expected, srv1-co1 and srv1-lg1 are able to ping each other because we established the ROADM rules for short-hop configuration. Consequently, srv1-co1 and srv2-lg1 are not able to ping each other because no such connection is established yet.
+
+Note that the average ping time for srv1-co1 to srv1-lg1 is 0.339 ms.
+
+''Note that the Mininet-Optical ROADM dataplane is currently modeled using OvS switching in the Linux kernel, so each hop will add some delay that would not be seen on hardware. Process scheduling, OS and VM overhead, etc. can create additional delays in a software emulator.''
+
+== Network Interfaces Configuration for Experiment_2 (long-hop)
+
+In Experiment 2, we are choosing to pass the optical signal through 2 hops (via a pair of 10km fiber spools with the 32km Manhattan dark fiber). This requires us to establish a connection between srv1-co1 and srv2-lg1. Once you perform the experiment 1 as described above, the script will prompt you to press Return key to perform the test for configuration 2. Before trying the configuration, let's dive into what connections this script will install: 
+
+==== [WIP] Configuring srv1-co1<=>srv2-lg1 Connection 2 on Mininet-Optical using NETCONF ====
+
+* rdm1-co1 (Same As For Experiment 1):
+1. Enable MUX port 4102 “From ToR 1” 
+2. Add Connection “From ToR 1” with I/O Port 4102/4201 with bandwidth [192.95;193.05] 
+3. Enable DEMUX port 5202 “Towards ToR 1”
+4. Add Connection “Towards ToR 1” with I/O Port 5101/5202 with bandwidth [192.95;193.05] 
+{{{
+examples/nc_add_connection.py localhost:1834 1 10 in-service false 4102 4201 192950 193050 5 Exp1-FromTor1
+examples/nc_add_connection.py localhost:1834 2 10 in-service false 5101 5202 192950 193050 5 Exp1-TorwardTor1
+}}}
+
+* ROADM 1 <Not Same!>:
+5. Enable MUX port 4101 “Through Port” (enabled for Snake)
+6. Add Connection “Through In” with I/O Port 4101/4201 with bandwidth [192.95;193.05] 
+7. Enable DEMUX port 5201 “Through Port” (enabled for Snake)
+8. Add Connection “Through Out” with I/O Port 5101/5201 with bandwidth [192.95;193.05]
+
+This time we pass channel 34 through ROADM 1:
+{{{
+examples/nc_add_connection.py localhost:1831 1 10 in-service false 4101 4201 192950 193050 5 Exp1-EastR1
+examples/nc_add_connection.py localhost:1831 2 10 in-service false 5101 5201 192950 193050 5 Exp1-WestR1
+}}}
+
+* ROADM 2 (Same As For ROADM1):
+9. Enable MUX port 4101 “Through Port” (enabled for Snake)
+10. Add Connection “Through In” with I/O Port 4101/4201 with bandwidth [192.95;193.05] 
+11. Enable DEMUX port 5201 “Through Port” (enabled for Snake)
+12. Add Connection “Through Out” with I/O Port 5101/5201 with bandwidth [192.95;193.05]
+
+And pass through ROADM2:
+{{{
+examples/nc_add_connection.py localhost:1832 1 10 in-service false 4101 4201 192950 193050 5 Exp1-WestR2
+examples/nc_add_connection.py localhost:1832 2 10 in-service false 5101 5201 192950 193050 5 Exp1-EastR2
+}}}
+
+* ROADM 3 (Same As For ROADM4):
+13. Enable MUX port 4102 “From ToR 3” 
+14. Add Connection “From ToR 3” with I/O Port 4102/4201 with bandwidth [192.95;193.05] 
+15. Enable DEMUX port 5202 “Towards ToR 3”
+16. Add Connection “Towards ToR 3” with I/O Port 5101/5202 with bandwidth [192.95;193.05] 
+
+And we drop at ROADM3:
+{{{
+examples/nc_add_connection.py localhost:1833 1 10 in-service false 4102 4201 192950 193050 5 Exp1-FromTor2
+examples/nc_add_connection.py localhost:1833 2 10 in-service false 5101 5202 192950 193050 5 Exp1-TorwardTor2
+}}}
+
+Note: Observe the slightly longer RTT to `server3`, reflecting the increased propagation time across two 22km fibers to reach the "Central Cloud" data center.
+
+----
+
+= Shutting down Mininet-Optical =
+
+To exit Mininet-Optical, type `exit` or press control-D at the `mininet-optical>` prompt.
+
+= Acknowledgments =
+
+This tutorial is based on the hardware tutorial at [wiki:Workshops/SigComm2022/OpticalTutorial] by T. Chen et al..
+
+<<<credits>>>
+
+= References =
+
+COSMOS Optical Hardware Testbed Tutorial: [wiki:Workshops/SigComm2022/OpticalTutorial]
+
+Mininet-Optical Tutorial network script: 
+https://github.com/Mininet-Optical/mininet-optical/blob/cosmos-tutorial/mnoptical/examples/sigcommtutorial.py
+
+Mininet-Optical Tutorial configuration script:
+https://github.com/Mininet-Optical/mininet-optical/blob/cosmos-tutorial/mnoptical/examples/config-sigcommtutorial.sh
+
+Mininet-Optical documentation: https://mininet-optical.org
+
+Mininet-Optical code: https://github.com/mininet-optical/mininet-optical
+
+(Packet) Mininet web site: https://mininet.org
+
+