This commit is intended to makes the license status of Emulab and
ProtoGENI source files more clear.  It replaces license symbols like
"EMULAB-COPYRIGHT" and "GENIPUBLIC-COPYRIGHT" with {{{ }}}-delimited
blocks that contain actual license statements.

This change was driven by the fact that today, most people acquire and
track Emulab and ProtoGENI sources via git.

Before the Emulab source code was kept in git, the Flux Research Group
at the University of Utah would roll distributions by making tar
files.  As part of that process, the Flux Group would replace the
license symbols in the source files with actual license statements.

When the Flux Group moved to git, people outside of the group started
to see the source files with the "unexpanded" symbols.  This meant
that people acquired source files without actual license statements in
them.  All the relevant files had Utah *copyright* statements in them,
but without the expanded *license* statements, the licensing status of
the source files was unclear.

This commit is intended to clear up that confusion.

Most Utah-copyrighted files in the Emulab source tree are distributed
under the terms of the Affero GNU General Public License, version 3
(AGPLv3).

Most Utah-copyrighted files related to ProtoGENI are distributed under
the terms of the GENI Public License, which is a BSD-like open-source
license.

Some Utah-copyrighted files in the Emulab source tree are distributed
under the terms of the GNU Lesser General Public License, version 2.1
(LGPL).

killed when the STOP event is received.

Also fix a couple of minor nits.

SanityCheck.py is the script for checking cross-correlation of Flexlab
runs. It works for both TCP and UDP transfers. I also changed
auto-pelab.ns and added a "-t" option to start-experiment
and stop-experiment to enable these sanity checks.

Note: I haven't figured out how to kill sudo tcpdump sessions
on PlanetLab with program agents - so, for now they have to be
killed manually after a stop-experiment. Will change this after
talking to Mike.

The cross-correlation code works correctly - I may need to tweak it
a bit in the near future for averaging times.
Also, it puts too much load on Ops and (i think) takes too much time.
I will change it so that all the correlation calculations are done on
the experimental nodes.

 * allow for no server program to be run
 * allow for a program to be run on all nodes (including planet-*)
 * mods for the new improved dbmonitor

Also allow setting of use_magent=2 to indicate that it should start an
iperfd to listen for traffic on plab nodes rather than the stub.

template world:
	set no_plab to 1
	set use_dbmonitor to 1
	put enough nodes in the plabnodes list
	use start-run and stop-run to do it

Create event sequences to do the equiv. of start- and stop-experiment.
Rather than using those scripts, you now can use start-run and stop-run
which are just wrappers around tevc to trigger the sequences.

This checking is backward compatible in the sense that you can continue to
use start- and stop-experiment and should never notice a thing.

The new event model doesn't support a couple of things that the old script
based execution did, most notably, you cannot change command line arguments.
It does support real vs. fake runs.

run simultaneously on the same planetlab node.

Confine tcpdump on the planetlab nodes to just the stub's traffic, so
we don't have to worry about nameserver traffic, ssh traffic, etc.

Make use_magent the defauly.

conditions) plab nodes without actually allocating them.

Changed init-elabnodes to support this.  Elab to plab mapping is set in the
NS file via the $opt array, which init-elabnodes extracts via the XMLRPC
interface.

So to run the "really simple model":

 1. set "no_plab" to 1 in the NS file
 2. make sure you have enough nodes listed in "plabnodes" in the NS file
    to cover "num_pcs".
 3. swapin the experiment
 4. after swapin, run init-elabnodes.pl.

Also, cleaned up the NS file some: got rid of hokey tcpdump setup as it
was redundant, made tracing optional (though on by default), expect proper
return values from program agents.

elab nodes for the simple model - when no real plab nodes are being
used.

which, oddly enough, ensures that update does not return immediately.

the queues for fake planetlab (so it's easier to experience loss).

an issue with the program agent and signals (monitor is not getting killed
during stop-experiment).

and just updates link characteristics based on the pelab DB values.

Getting to say:
tb-set-lan-protocol $realinternet ipv4
... feels very powerful. Maybe I should set it to ipv6 and move the
whole world forward into the future.

node sits in the stub or monitor barrier sync for more than the SYNCTIMO
timeout value in common-env.sh, it will send a HUP to syncd which will
knock all the other nodes out of their barrier sync.  If that happens,
all nodes will print a warning message and continue.

All nodes wait for both a stub sync and a monitor sync, so if one plab node
is down, they will timeout on both barrier syncs.  Race conditions?  Sure.
If for example everyone times out on the stub barrier due to a slow node,
and then that node reaches the barrier, it will hang there while everyone
else waits on the monitor barrier.  When the latter times out, it will
kick the slow node out of the stub sync and it will then proceed to hang
in the monitor sync until the experiment is stopped.  Got that?

As an aside, it would be nice if the initializer of a barrier could specify
a timeout value, and return a special error code to everyone if it timed out,
but that would require an incompatible change to the sync protocol.

Off by default for now. Not well tested (syntax checks).

on everyone by default.  Change it back to CHANGEME.tar.gz.

now and the -FUTURE kernel delay-agent has too many problems.

Set the magic variable in auto-pelab.ns and swapin your experiment.
Logs will wind up in /proj/blahblah/exp/blahblah/logs/<node>/<name>.tcpdump
after you run stop-experiment.

I did this with the program agent and duct tape.  If it turns out that
you can already do this with the link tracing framework, then someone in
Oregon is going to whomp me upside the head with a clue-stick and he'll
never let me forget...at least til he forgets in a day or two.

 * auto-pelab.ns: add an event-group that runs 'update -t' on the nodes
   to update the tarballs/RPMs.  NOTE that you will need to modify your
   experiment and update your version of the NS file for this to work.

 * install-tarball: simple script to run tevc and trigger the tarball
   updates

 * start-experiment: '-p' option to monitor the real planetlab nodes
   instead of the emulated ones, -M/-S to set the arguments passed to
   the monitors/stubs, -m/-s to append to the current arguments passed
   to the monitors/stubs.

 * monitor/auto-monitor.sh: pass through the command line arguments

to be worked out, and I need to finish the documentation, but most of
what's needed is here.

CONTENTS:

auto-pelab.ns - NS script for creating a pelab experiment. Supports
both real and fake Plab nodes.

start-experiment - perl script to start up monitors and stubs, and to
start link tracing.

stop-experiment - perl script to stop monitors and stubs, and collect
all of the files from this experiment.

TODO:
Write documentation for it - how to run it, where the logfiles go, etc.

Add hooks for the user to run their own program under test (ie iperf)

Reset condidtions on the Emulab-side LAN before an experiment starts

Get link tracing on plab (probably by starting pcapper with the
program agent)