Changes between Version 12 and Version 13 of GENIEducation/SampleAssignments/OpenFlowAssignment/ExerciseLayout/Execute

Timestamp:

05/22/13 17:24:36 (11 years ago)

Author:

shuang@bbn.com

Comment:

--

GENIEducation/SampleAssignments/OpenFlowAssignment/ExerciseLayout/Execute

@@ -204 +204 @@
   You are free to communicate these network statistics from the traffic shaping nodes to your OpenFlow controller in any fashion you like. You may want to use a web service, or transfer the data via an external daemon and query a statistics file from the controller. Keep in mind that flow creation decisions need to be made rather quickly, to prevent retransmissions on the connecting host. [[BR]]
 
-  '''Hints''' [[BR]]
+  '''Questions'''[[BR]]
+  To help user to fetch the information about the amount of traffic as well as the queue depth (measured in number of packets) on both left and right node, we provide a script that the user can download and run on both left and right node [[BR]]
+  You can download the script from [http://www.gpolab.bbn.com/experiment-support/OpenFlowExampleExperiment/netinfo.py netinfo.py]. Then do the following to start monitoring network usage: [[BR]]
+  - 1. install Twisted Web package for Python on both left and right node: 
+{{{
+sudo yum install python-twisted-web
+}}}
+  - 2. upload netinfo.py onto left and right node, then change the listening IP address in netinfo.py to the public IP address of left and right node respectively. i.e., replacing the following 0.0.0.0 in your netinfo.py file to the public IP address of the left/right node. 
+{{{
+reactor.listenTCP(8000, factory, interface = '0.0.0.0')
+}}}
+  - 3. apply qdisc on interface eth1 of both left and right node by executing (you may further change the parameters by using ''tc qdisc change''): 
+{{{
+sudo /sbin/tc qdisc add dev eth1 root handle 1:0 netem delay 20ms
+sudo /sbin/tc qdisc add dev eth1 parent 1:0 tbf rate 20mbit buffer 20000 limit 16000
+}}}
+  - 4. run the script by: 
+{{{
+python netinfo.py
+}}}
+  - 5. verify it is working by opening a web browser and typing the following URL (replacing 155.98.36.69 with your left or right node's public IP address):
+{{{
+http://155.98.36.69:8000/qinfo/0
+}}}
+  For more information about netinfo.py, please look at the comments in the file. [[BR]]
+
+  To help you get started, the following is the ruby class that helps collecting the monitoring results: 
+{{{
+class DataCollector
+    @@Weight = 0.2
+
+    attr_reader :port
+
+    def initialize(host, port)
+        @host = host
+        @uri = 'http://' + host + ':8000/qinfo/'
+        @last = 0
+        @ewmabytes = 0
+        @ewmapkts = 0
+        @lock = Mutex.new
+        @port = port
+    end
+
+    def run
+        starttime = Time.now.to_f
+        while true
+            data = Net::HTTP.get(URI(@uri + @last.to_s))
+            data.each do |line|
+                ts, bytes, qlen = line.chomp.split(' ').map { |x| x.to_i }
+                @lock.synchronize do
+                    if ts <= @last
+                        next
+                    elsif @last == 0
+                        @ewmabytes = bytes
+                        @ewmapkts = qlen
+                    else
+                        # Just assume we haven't missed too many entries
+                        @ewmabytes = bytes * @@Weight + @ewmabytes * (1 - @@Weight)
+                        @ewmapkts = qlen * @@Weight + @ewmapkts * (1 - @@Weight)
+                    end
+                    @last = ts
+                end
+            end
+            sleep 5
+        end
+    end
+
+    def averages
+        a = nil
+        @lock.synchronize do
+            a = [@ewmabytes, @ewmapkts]
+        end
+        return a
+    end
+end
+}}}
+  In the above code, function ''averages'' will return the weighted average number of bytes seen in the corresponding node, as well as the weighted average queue depth in terms of number of bytes seen in the corresponding node. [[BR]]
+  Here is some example code that makes use of this class: 
+{{{
+        @collectors = [DataCollector.new($leftip, @leftport),
+                       DataCollector.new($rightip, @rightport)]
+        @collectors.each do |collector|
+            Thread.new(collector) do |c|
+                c.run
+            end
+        end
+
+        left_monitor_value = @collectors[0].averages
+        right_monitor_value = @collectors[1].averages
+        #left_monitor_value[0] shows the average number of bytes seen on the left node
+        #left_monitor_value[1] shows the average number of queued packets on the left node
+}}}
+  
+  '''Question: Implement your load-balancer.rb and display the number of bytes and queue length on both left and right node when a decision is made'''[[BR]]
+  '''A sample output should be as follows: [[BR]]'''
+{{{
+left:  261315722.691471 bytes, Q Depth: 874380.631071448 packets
+right: 445408379.683936 bytes, Q Depth: 642438.535302339 packets
+so this new flow goes left. Total number of flows on the left: 1
+}}}
+  
+
+
+  '''Hints: Want to get the complete load-balancer.rb? ask your instructor or visit here (you need a password to get it), or send an email (the solution code may be full of bugs, feel free to tweak it and report bugs/ask questions)''' [[BR]]
   - 
     - Remember that the TCP control loop is rathers low — on the order of several round trip times for the TCP connection. This means your load balancing control loop should be slow.