1.269: Add new table to generate a per virt_lan index for use with
       veth vlan tags. This would be so much easier if the virt_lans
       table had been split into virt_lans and virt_lan_members.
       Anyway, this table might someday become the per-lan table, with a
       table of member settings. This would reduce the incredible amount of
       duplicate info in virt_lans!

	CREATE TABLE virt_lan_lans (
	  pid varchar(12) NOT NULL default '',
	  eid varchar(32) NOT NULL default '',
	  idx int(11) NOT NULL auto_increment,
	  vname varchar(32) NOT NULL default '',
	  PRIMARY KEY  (pid,eid,idx),
	  UNIQUE KEY vname (pid,eid,vname)
	) TYPE=MyISAM;

       This arrangement will provide a unique index per virt_lan, within
       each pid,eid. That is, it starts from 1 for each pid,eid. That is
       necessary since the limit is 16 bits, so a global index would
       quickly overflow. The above table is populated with:

	insert into virt_lan_lans (pid, eid, vname)
            select distinct pid,eid,vname from virt_lans;

       . Add an EMULAB_PROJECT environment variable to set the default project.
       . Expose the EMULAB_USER login name for SSH on the Open/Experiment dialog.

giving stated enough time to react to RELOADDONE event, and so the
node is still in frisbee mode when it asks for bootinfo again.
So, put in a small delay and hope that works. Might have to be more
clever about this.

Pass that argument from rc.cdboot since after a successful disk load,
there is no need to reboot before asking bootinfo what to do next.
This will avoid a full reboot cycle.

Add waitforactive() to avoid waiting for state='active' on the client.

Also be sure to remove temp file.

* Be more selective about what lists are regenerated; we were generating
  way too many lists each time called. When calling from tbswap, use new
  -t option to generate just the active lists. When called from setgroups,
  use -p option to generate lists just for the project. Add update option
  for when user changes email address (and all lists really do need to be
  regenerated).

* Add "diff" processing. Instead of blindly firing each new list over to
  ops with ssh, store a copy of all of the lists in
  /usr/testbed/lists. After we generate the new list, diff it against the
  stored copy. If the same, skip it. Otherwise stash new copy and fire it
  over. This should reduce the wait times by quite a bit since the lists
  rarely change (except for the activity lists of course).

* Add -n (impotent) option for debugging; skips the ssh over to ops.

* Reorg a lot of stuff; it was getting hard to follow.

Add more description of "non-tree links" and the "show"/"hide" controls.
Add some more cross-linking and improve readability.

* Remove DirectoryIndex from the .htaccess file. This file set the
  index for every directory to start.php3, which was wrong.

* Change index.html to redirect to index.php3.

* Change start.php3 to redirect to index.php3. I left the start.php3
  script in place (one line script) so that existing bookmarks work.

* Move the code that used to be in start.php3 to the top of
  index.php3; this is the code that would zap to the My Emulab page
  when the user was logged in (and in https mode). Much simpler now.

supporting both a shell script driven interface, plus the newer XMLRPC
interface. This change removes the script driven interface from boss,
replacing it with just the XMLRPC interface. Since we like to maintain
backwards compatability with interfaces we have advertised to users (and
which we know are being used), I have implemented a script wrapper that
exports the same interface, but which converts the operations into XMLRPC
requests to the server. This wrapper is written in python and uses our
locally grown xmlrpc-over-ssh library. Like the current "demonstation"
client, you can take this wrapper to your machine that has python and ssh
installed, and use it there; you do not need to use these services from
just users.emulab.net. Other things to note:

* The wrapper is a single python script that has a "class" for each wrapped
  script. Running the wrapper without any arguments will list all of the
  operations it supports. You can invoke the wrapper with the operation as
  its argument:

    {987} stoller$ script_wrapper.py swapexp --help
    swapexp -e pid,eid in|out
    swapexp pid eid in|out
    where:
         -w   - Wait for experiment to finish swapping
         -e   - Project and Experiment ID
         in   - Swap experiment in  (must currently be swapped out)
        out   - Swap experiment out (must currently be swapped in)

    Wrapper Options:
        --help      Display this help message
        --server    Set the server hostname
        --login     Set the login id (defaults to $USER)
        --debug     Turn on semi-useful debugging

   But more convenient is to create a set of symlinks so that you can just
   invoke the operation by its familiar scriptname. This is what I have
   done on users.emulab.net.

    {987} stoller$ /usr/tesbed/bin/swapexp --help
    swapexp -e pid,eid in|out
    swapexp pid eid in|out


* For those of you talking directly to the RPC server from python, I have
  added a wrapper class so that you can issue requests to any of the
  modules from a single connection. Instead using /xmlrpc/modulename, you
  can use just /xmlrpc, and use method names of the form experiment.swapexp,
  node.reboot, etc.

  Tim this should be useful for the netlab client which I think opens up
  multiple ssh connections?

* I have replaced the paperbag shell with a stripped down xmlrpcbag shell
  that is quite a bit simpler since we no longer allow access to anything
  but the RPC server. No interactive mode, no argument processing, no
  directory changing, etc. My main reason for reworking the bag is to make
  it easier to understand, maintain, and verify that it is secure. The new
  bag also logs all connections to syslog (something we should have done in
  the orginal). I also added some setrlimit calls (core, maxcpu). I also
  thought about niceing the server down, but that would put RPC users at a
  disadvantage relative to web interface users. When we switch the web
  interface to use the XMLRPC backend, we can add this (reniceing from the
  web server would be a pain cause of its scattered implementation).

Remove all symlinks of plasticwrap; this has been replaced by the XMLRPC
server.

writable by adding a umask(0002) call.

Resizing the window, and moving the splitter between the HyperViewer canvas and
controls panel, now work.

 . Resizing of GLCanvas for HyperViewer.  EVT_SIZE(self.hypView, self.OnResizeCanvas)

 . Control the size of the controls panel.
		 EVT_SIZE(self.window_1, self.OnResizeWindow)
		 EVT_SPLITTER_SASH_POS_CHANGED(self.window_1, -1, self.OnSashChanged)

 . Keep dragging of the window divider outside the window from blanking the
   HyperViewer canvas or controls panel.         self.window_1.SetMinimumPaneSize(21)

Minor hypview stuff:

   . Cleanup: Don't need to call SwapBuffers in the Python code anymore.

   . Since we're walking a tree, we want the Show/Hide buttons to be
     on if Descend is checked.

   . Go to the top node after read-in, so the node info is displayed.

  . Make the AnimationFrames GUI control work on Windows and FreeBSD.

  . Make animated moves work in HyperViewer on FreeBSD.

    - Add setFrameEndCB to HypView{,er}.{h,cpp}, frameEndCB to hvmain.cpp .

    - Pass the wxGLCanvas pointer from the Python app all the way down to
      frameEndCB to call wxGLCanvas->SwapBuffers().
      The pointer comes through "encrypted" from Python, hack around that.

    - hvMain now needs to be compiled and linked against the
      wx_gtk2-2.4 includes and libs so it can call SwapBuffers.

UPDATING.

Add explicit -w option to wait for node to reboot.

interface. This stuff is going to dissappear pretty soon, once we
shift from the paperbag to the xmlrpcbag.

* Added a wrapper class so that you can invoke methods as
  experiment.swapexp or node.reboot. So instead of invoking as
  /XMLRPC/experiment can calling swapexp, you can call the server as
  /XMLRPC and call experiment.swapexp. This allows you to use a single
  connection to talk to different parts of the API. Note this is standard
  (or is it defacto) syntax in XMLRPC.

* Changed the demonstration client to talk the server this way.

* Changed paperbag to allow this as well; the xmlrpc server is invoked with
  no args, which tells it to export the wrapper interface instead of a
  specific module interface.

* A few more cleanups in the server, more permission checks, etc.