Changes between Version 1 and Version 2 of Tutorial/HowToAppPrototype

Timestamp:

Dec 5, 2007, 4:43:08 AM (17 years ago)

Author:

thierry

Comment:

—

Tutorial/HowToAppPrototype

@@ -34 +34 @@
 === Step 1: Application Definition ===
 
+In this step, we define an application definition (i.e. a "wrapper") for our original application. In this example, we take "ping" as our original application.
+
+The following code should be saved into a file "pingWrapper.rb" in the same directory as the experiment scripts that would use it:
+{{{
+# Define a new application
+# The following declaration defines a new application which as a URI 'pingWrapper'
+# and the name 'pingApp'
+
+defApplication('pingWrapper', 'pingApp') {|app|
+
+  app.shortDescription = "This is a simple wrapper application around tcpdump"
+  app.path="/bin/ping"
+
+  # Here we define the "properties" of this application, i.e. the parameters that
+  # it supports and which we would like to access 
+  # Ping has many parameters, however in this example, we are only interested in 
+  # the following four ones.
+
+  # defProperty has the following signature:
+  # defProperty ( name, description, mnemonic, options )
+  # - 'name' is interpreted as the long parameter for the command (e.g. "--help")
+  # - 'mnemonic' is the short parameter call (e.g. ?h will result in "-h")
+  # - 'options' is a Hash of options for this parameter:
+  #        :type => <type> 
+  #                 is the parameter types, any of ':string' or ':integer' 
+  #                 or ':boolean' or 'nil'
+  #        :dynamic => true | false 
+  #                    true property can be changed at run-time
+  #        :use_name => true | false
+  #                     if false then print only the parameter value and do 
+  #                     not print either 'name' or 'mnemonic' when calling the command
+  #        :order => integer
+  #                  Order the property according to integer when calling the command
+  
+  # This is the ping destination. It is a string and its value is not prefixed by any
+  # "--options" or "-X", thus we set ':use_name' to false
+  #
+  app.defProperty("dst", "Destination Address or Name", nil,
+                  {:dynamic => false, :type => :string, :use_name => false})
+  
+  # This is the number of ping packet to send. It is an integer, and on the command line
+  # it should be prefixed by "-c", hence the use of '?c'
+  #
+  app.defProperty("count", "Number of probe packet to send", ?c,
+                  {:dynamic => false, :type => :integer})
+  
+  # similar as previous comment...
+  app.defProperty("flood", "Flood packets", ?f,
+                  {:dynamic => false, :type => :boolean})
+  app.defProperty("interval", "Time interval between packets in a flood", ?i,
+                  {:dynamic => false, :type => :integer})
+} 
+}}}
+
 === Step 2: Prototype Definition ===
+
+In this step, we define a prototype that would use and specialize the above "pingWrapper" application. For the purpose of this example, we will define two independent different prototype. 
+
+The first one is "agressivePing". It specializes the "pingWrapper" application into one that sends by default a fixed high amount of probes with minimal interval between them, thus effectively flooding the destination. This application could be used to get a coarse quick estimation of the packet drop rate on a link.
+
+The second one is "gentlePing". It specializes the "pingWrapper" application into one that sends by default 5 probes with 1s interval (default ping interval). This application could be used to test reachability between two nodes with minimal link disruption.
+
+The following two code blocks should be saved into two separate files "agressivePing.rb" and "gentlePing.rb" in the same directory as the previous application definition:
+{{{
+# Define a new prototype
+# This prototype is an instance/specialization of the above 'pingWrapper' application
+# 
+
+defPrototype("aggressivePing") { |proto|
+
+  proto.name = "aggressivePing"
+  proto.description = "A node that flood packets to a destination to quiclky determine packet drop rates"
+
+  # Here we specify which property of the base application we would like to use 
+  # AND what are the default value we would like to give them.
+  
+  # 'destination' is a mandatory parameter of ping, thus we do not set any default value
+  proto.defProperty('destination', 'Name or IP address of the destination')
+
+  # This is a agressive ping, so we set the default probe number to 1000, we also set the 
+  # flooding behavior as 'true' by default, along with an interval of 0
+  #
+  proto.defProperty('numPacket', 'Number of probe packets to flood', 1000)
+  proto.defProperty('enableFlood', 'Enable packet flooding', true)
+  proto.defProperty('pktInterval', 'Time interval between packets in a flood', 0)
+
+  # Here we bind this prototype with the "pingWrapper" application definition
+  # And we also bind the properties that we decided to use and gave default values to 
+  #
+  proto.addApplication("pingApp", "pingWrapper") { |listener|
+    listener.bindProperty('dst', 'destination')
+    listener.bindProperty('count', 'numPacket')
+    listener.bindProperty('flood', 'enableFlood')
+    listener.bindProperty('interval', 'pktInterval')
+  }
+}
+}}}
+
+and
+
+{{{
+# Define another prototype
+# This prototype is another instance/specialization of the above 'pingWrapper' application
+# 
+
+defPrototype("gentlePing") { |proto|
+
+  proto.name = "gentlePing"
+  proto.description = "A node that pings a destination to quiclky assess its reachability"
+
+  # This is a gentle ping, so we set the default probe number to 5, we also set the 
+  # flooding behavior as 'false' by default, and we ignore the 'interval' parameter
+  #
+  proto.defProperty('destination', 'Name or IP address of the destination')
+  proto.defProperty('numPacket', 'Number of probe packets to flood', 5)
+  proto.defProperty('enableFlood', 'Enable packet flooding', false)
+
+  proto.addApplication("pingApp", "pingWrapper") { |listener|
+    listener.bindProperty('dst', 'destination')
+    listener.bindProperty('count', 'numPacket')
+    listener.bindProperty('flood', 'enableFlood')
+  }
+}
+}}}
 
 === Step 3: The Experiment Script ===