jail and delay node OSIDs. When set, will override anything in the
node_types table. Use with caution.

each veth from tmcd cause that is easy. Defaults to 1 for now.
Add tb-set-encapsulate to front end so Mike can play with it.

treated specially by the parser. Changed it to another bogus
hardwired IP!

(or more than one simhost) is unable to keep up with real-time. It includes
changes to assign_wrapper to handle swap modify for simnodes, the simple
algorithm in nseswap that bumps up the nodeweight of simnodes being hosted
on a simhost that reports "can't keep up with real-time" (aka nse violation),
ptopgen and sim.tcl to prefer nodes that already have the FBSD-NSE image.
Also, changes to other files to send out NSESWAP event.

One unrelated change: We now have per-swapin .top files and assign.log
files along with .ptop files. This helps in debugging across multiple
swapins since files remain in the form of
<pid>-<eid>-<process_id>.{top,ptop} and assign-<pid>-<eid>-<process_id>.log
Also useful for archiving.

"upleavel 1 eval $script". The latter is wrong and was detected when a
for loop inside make-simulated did not work.

now mapped to more than one PC if required. The simnode_capacity
column in the node_types table determines how many sim nodes can
be packed on one PC. The packing factor can also be controlled via
tb-set-colocate-factor to be smaller than simnode_capacity.

- No frontend code changes. To summarize:
  $ns make-simulated {
    ...
  }
  is still the easy way to put a whole bunch of Tcl code to be
  in simulation.
  One unrelated fix in the frontend code is to fix the
  xmlencode() function which prior to this would knock off
  newlines from columns in the XML output. This affected
  nseconfigs since it is one of the few columns with embedded
  newlines. Also changed the event type and event object type
  in traffic.tcl from TRAFGEN/MODIFY to NSE/NSEEVENT.

- More Tcl code in a new directory tbsetup/nseparse
  -> Runs on ops similar to the main parser. This is invoked
     from assign_wrapper in the end if there are simnodes
  -> Partitions the Tcl code into multiple Tcl specifications
     and updates the nseconfigs table via xmlconvert
  -> Comes with a lot of caveats. Arbitrary Tcl code such as user
     specified objects or procedures will not be re-generated. For
     example, if a user wanted a procedure to be included in Tcl
     code for all partitions, there is no way for code in nseparse
     to do that. Besides that, it needs to be tested more thoroughly.

- xmlconvert has a new option -s. When invoked with this option,
  the experiments table is not allowed to be modified. Also,
  virtual tables are just updated (as opposed to deleting
  all rows in the first invocation before inserting new rows)

- nse.patch has all the IP address related changes committed in
  iversion 1.11 + 2 other changes. 1) MTU discovery support in
  the ICMP agent 2) "$ns rlink" mechanism for sim node to real
  node links

- nseinput.tcl includes several client side changes to add IP
  routes in NSE and the kernel routing table for packets crossing
  pnodes. Also made the parsing of tmcc command output more robust
  to new changes. Other client side changes in libsetup.pm and other
  scripts to run nse, are also in this commit

- Besides the expected changes in assign_wrapper for simulated nodes,
  the interfaces and veth_interfaces tables are updated with
  routing table identifiers (rtabid). The tmcd changes are already
  committed. This field is used only by sim hosts on the client side.
  Of course, they can be used by jails as well if desired.

the first node in the list. Useful for the linktest stuff, and the
sync server is harmless.

parser:

* Change xmlconvert to use XML::Parser instead of the ad-hoc stuff I
  wrote. This was easier then trying to deal with multiline fields or
  all the special chars. XML::Parser does all that for me. Also make
  sure all fields are either properly quoted (with DBQuoteMeta) or
  regex'ed before we stick them into the DB. For the future, we need
  to add table/slot specific regular expressions.

* Also add Shashi's fixes to the parser; properly escape XML special
  characters, as well as cleanup of my original spitxml code.

* Generate a shared secret key for the event system. This key is
  stored into the DB, and passed to the node via tmcd. It is also
  stashed into a file in the experiment directory (can be accessed
  only by the project/group members). The key is used to attach a
  HMAC (hashed message authentication) to each event, which is checked
  by the receivers to ensure that the event is not bogus. More details
  on this later when I commit the event library/client changes.

* Added "virt_programs" table to store info about each program object
  defined by the user. The intent is to no longer send the command
  string in the event, but to fix it in the DB, and transfer it via
  tmcd. This removes our "remote execution facility" which was always
  a bad idea (we have ssh for that, and that is a lot more secure then
  the event system!).

  Note that for the time being we need to continue send the command in
  the event because of old images, but the new images will now ignore
  that part of the event.

desire for 'hosts-<type>', where <type> is the type of its child node.
This helps assign, because it can now limit the number of places to
try assigning the host, and it means that we can give the hosts this
feature, so that they don't get used for other purposes. For example,
we can give the IXP-hosting nodes the feature 'hosts-ixp-bv' with
weight 1, and they will never get used for anything but IXP hosting.

This means that the node_type_features (or just node_features) table
must now have hosts-<type> entires to work correctly.

link testing stuff, and will eventually be under user control, but for
now we stick this agent into every experiment, although most of the
time no one will be listening for it.

plab experiments.

Must be an integer between 1 and 1000. Okay, just kidding: 1<=x<=5

your NS file:

	tb-set-netmask $lan0  "255.255.240.0"
	tb-set-netmask $link0 "255.255.255.248"
	tb-set-netmask $link1 "255.255.255.240"

Yep, more rope for the user to hang herself with. Notes:

* You are restricted to 255.255.XXX.XXX. I did not see a reason to
  allow the user that much rope.

* get_subnet can handle 10 or 192.168 addresses so that other sites
  can continue to operate without changing to 10 addresses, although
  they will still be able to change the netmask.

* I've changed the handling for widearea networks to use 192.168, but
  I force the netmask to 255.255.255.248 so that we are not restricted
  to just 255 networks (not that it really matters). To avoid possible
  confusion, the user is not allowed to choose their own IPs for
  widearea networks, and I actually set them to 1.1.x.x, and then
  patch it up later. This is to avoid conflict with existing
  experiments where people may have used tb-set-ip in their NS files.

* There are tmcd and staticroutes and image changes that are required
  to make this all work right!

* Parser: Added new tb command to set the name of the sync server:

	tb-set-sync-server <node>

  This initializes the sync_server slot of the experiment entry to the
  *vname* of the node that should run the sync server for that
  experiment. In other words, the sync server is per-experiment, runs
  on a node in the experiment, and the user gets to chose which node
  it runs on.

* tmcd and client side setup. Added new syncserver command which
  returns the name of the syncserver and whether the requesting node
  is the lucky one to run the daemon:

    SYNCSERVER SERVER='nodeG.syncserver.testbed.emulab.net' ISSERVER=1

  The name of the syncserver is written to /var/emulab/boot/syncserver
  on the nodes so that clients can easily figure out where the server
  is.

  Aside: The ready bits are now ignored (no DB accesses are made) for
  virtual nodes; they are forced to use the new sync server.

* New os/syncd directory containing the daemon and the client. The
  daemon is pretty simple. It waits for TCP (and UDP, although that
  path is not complete yet) connections, and reads in a little
  structure that gives the name of the "barrier" to wait for, and an
  optional count of clients in the group (this would be used by the
  "master" who initializes barriers for clients). The socket is saved
  (no reply is made, so the client is blocked) until the count reaches
  zero. Then all clients are released by writting back to the
  sockets, and the sockets are closed. Obviously, the number of
  clients is limited by the numbed of FDs (open sockets), hence the
  need for a UDP variant, but that will take more work.

  The client has a simple command line interface:

    usage: emulab-sync [options]
    -n <name>         Optional barrier name; must be less than 64 bytes long
    -d                Turn on debugging
    -s server         Specify a sync server to connect to
    -p portnum        Specify a port number to connect to
    -i count          Initialize named barrier to count waiters
    -u                Use UDP instead of TCP

    The client figures out the server by looking for the file created
    above by libsetup (/var/emulab/boot/syncserver). If you do not
    specify a barrier "name", it uses an internal default. Yes, the
    server can handle multiple barriers (differently named of course)
    at once (non-overlapping clients obviously).

    Clients can wait before a barrier in "initialized." The count on
    the barrier just goes negative until someone initializes the
    barrier using the -i option, which increments the count by the
    count. Therefore, the master does not have to arrange to get there
    "first." As an example, consider a master and one client:

	nodeA> /usr/local/etc/emulab/emulab-sync -n mybarrier
	nodeB> /usr/local/etc/emulab/emulab-sync -n mybarrier -i 1

    Node A waits until Node B initializes the barrier (gives it a
    count).  The count is the number of *waiters*, not including the
    master. The master is also blocked until all of the waiters have
    checked in.

    I have not made an provision for timeouts or crashed clients. Lets
    see how it goes.

of the exit code to see if the parser had been KILLed by the system.

Since the parser now runs on ops, increase the limit from from 60 to
180 seconds, but also increase the nice level.

do the actual parse. The parser now spits out XML instead of DB
queries, and the wrapper on boss converts that to DB insertions after
verification. There are some makefile changes as well to install the
new parser on ops via NFS, since otherwise the parser could
intolerably out of date on ops!

multiplexing of nodes.

in your NS file:

	$ns at 2000.0 "$ns halt"
or
	$ns at 2000.0 "$ns swapout"

The first causes the experiment to terminate, the later causes it to
swap out. I know some wiseass is going to ask for a swapin event!
You can also send these events from tevc:

	tevc -e testbed/stopme now ns halt
or
	tevc -e testbed/stopme now ns swapout

Does it need to be said that this is insecure? That we could get swap
wars going on as people try to get nodes for their experiments by
swapping out someone else? Well, if that happens we will apply the big
hammer and squash their nuts.

Details: I added an SIMULATOR "agent", and HALT/SWAPOUT event types in
the usual places. In the event scheduler, SIMULATOR events are treated
specially (not actually sent anywhere), but handled internally. Very
convenient, cause the scheduler runs as the person who swapped the
experiment in, and so I just run either swapexp or endexp, right from
the scheduler. At some point we need to give the permission issue some
thought.

string "QOS" when it should be "IPTOS".

that allows the user to get a handle on that queue object so it
can be changed. Add a routine (lanlink) to the sim class that operates
much like link command (gets the hack class, which in turn is used to
get the queue object).

Note, there needs to be some work done in the event parser in sim.tcl
to deal with lan queues (assumed to be link queues). I'll take care of
that later.

nodes. The second argument can now be an NS node instead of the name
of a real testbed node. For example:

	tb-set-hardware $node3  pc600
	tb-set-hardware $nodev1 pcvm600
	tb-fix-node $nodev1 $node3

So, "fix" $nodev1 to $node3. The intent is that once $node3 is
allocated by assign to a real testbed node, we can then allocate a
virtual node on pcXX to $nodev1. I did this primarily to allow for
easy testing of jails via my NS file, without having to hack assign
wrapper to deeply. Note there are still hacks in assign_wrapper to
support this, but they are not extensive.

Also my old usewatunnels stuff I never checked in:

	tb-set-usewatunnels 0/1

  - Fixes the routing problem
  - A new type "sim" has been created but not in the DB. node_types and
    nodes remain unchanged. This will change after we figure out how
    to represent in the DB the local multiple virtnodes in one phynode case
    The frontend tb_compat.tcl adds the sim type and ptopgen associates
    a huge number of sim nodes to all local PCs.
  - All simulated nodes go into one pc untill I finish coding the distributed
    nse case. Also, sim nodes go through assign but with an explicit
    "fix-node" directive in the top file. A random free pc is chosen using
    the avail script in assign_wrapper. If we don't fix node it, assign
    maps sim nodes to multiple phy nodes even when a valid all to one
    mapping is possible.
  - Syntax for nse:

   $ns make-simulated {

       set simnode1 [$ns node]
       set simnode2 [$ns node]

   }
   ...

   The old syntax

   set nsenode [$ns nsenode]
   $nsenode make-simulated {
   }

   is deprecated

  - All 38 frontend tests in the testsuite pass

  - A new table v2pmap has been added to handle multiple virt nodes to
    one phy node mapping. This is used in "tmcc hostnames" currently.

  - The phy node that is picked to run nse is loaded with a custom image
    FBSD45-NSE . This can use the default FBSD kernel if there is a mechanism
    to run at 1000HZ, have options IPFIREWALL_FORWARD and PERFMON turned on.
    The image is in the 'testbed' group. Do not delete this image.

  - Static routes now adds routes for the case dst == nexthop. The routing
    graph would be disconnected otherwise and I need to traverse this in
    assign_wrapper for nse. On the client side, such a route is filtered out in
    libsetup.pm

  - sim nodes are also correctly visualized

	tb-set-wasolver-weights delay bw plr

Where I am told proper defaults are 1, 10, 500. Setting any to zero
effectively drops that metric from consideration when the solver runs.
I've updated the tb_compat files and the documentation.

and a simulated node, things failed

again. No biggie.

running in "impotent" mode; just make them up.

Also add required changes to wanlinkinfo and wanassign.

have a remote node as a member. Since we share remotes nodes and set
up tunnels, we cannot let two experiments have the same subnet
numbers. I use 10.0.0 nets and a DB table to allocate them with a
autoincrement field.

parser runs. The staticroutes script is a wrapper for Chad's route
solver. The network optimization is currently turned off; use -t to
turn it on, until I know if its correct.

Note that Chad gets credit for routecalc.cc; I'm just committing the
file for him, with a couple of trivial changes that I made.

in the NS file in one of two ways:

$ns cost $nodeA $nodeB 2
or
$link0 cost 3
(The latter form can also be used for LANs)

This information is stored in the database in the cost column of the
virt_lans table.  It's important to note that cost data is _not_
divided between the two sides of the link, as things like delay and
rdelay are. Since there are no physical devices (ie.  delay nodes)
node that this configuration needs to be split up between, doing so
would just be unnecessary work.