GitLab

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.

   This sometimes results in wonky, skewed viewing transforms.
   - Add hvkill function instead of depending on HyperViewer clean-out code.
   - Improve string handling, remove all fixed-size buffers.
   - Keep label truncation from segmentation violation with a wonky transform.

 . OpenDialog initialization: focus and load text from command-line args.

 . Fix a platform-dependent bug in LabelsMode, resulting from changing it from
   a dropdown to a choice type widget in wxGlade.  Failed to work on Windows.

zero, probably for debugging) so that silly ssh warnings do not appear
on console.

Add -T option to ssh to avoid tty allocation on server side; no need
for that.

Add a couple of destructors to make sure that ssh is torn down when
destroying a proxy wrapper.

Added three helper programs. These are utilities to make it easier to directly interface the output of ipassign to the input of distributed-dijkstra. Using these utilities, they can be tested as a unit without having to go through the rest of the infrastructure of emulab.

Make various combinations of picking nodes, typing their names, and clicking "Go to top" play together nicely.

interface (which will have its own frontend to emulate the original
script interface!)

* Refactor the experiment permission checks into a subroutine.

* Cleanup some parameter names that did not make sense.

* Add portstats, readycount, node_admin, eventsys_control, savelogs,

* A couple of little fixes.

 . Allow typing in a node name, go to it when Enter is pressed.
 . Get node name after the GoToTop button is pressed.

 . Improve control panel layout by removing spacers and using Border spacing instead.
 . Start to make resizing work by setting Expand options in the GUI.
 . Change the LabelsMode widget from a wxComboBox to a wxChoice.
 . Disallow non-numeric chars and handle Enter in the "Node/Link depth" spinboxes.
 . Handle Enter in the Open dialog text fields; complain politely about empty text.
 . Disable show/hide buttons when there are no links in or out, respectively.

partitioning scheme. They seem to perform about the same, which is not what was expected. Further tests and tweaks may uncover the cause.

* Change use of TBGetSiteVar to the non-fatal variant to prevent the
  batch daemon from exiting when mysql goes whacky.

store the result in. When called this new way, the value goes into
$rptr, and exit status is returned to caller instead. In addition,
when called this way, all errors are non-fatal; it is up to the caller
to decide what to do.

* The first involves swapmod. When a swapmod on an active experiment fails,
  tbswap will reswap the experiment back to the original configuration. The
  problem is that it is reswapping it with the *new* virtual state of the
  experiment in the DB. It is not until later when control returns to
  swapexp that the virtual state is restored. This is plainly wrong, and in
  fact was causing the event scheduler grief cause it was starting up,
  reading the the virtual topo, which was different, wrong, and about to be
  blown away.

  I reorganized the modify section of swapexp so that virtual state is
  restored only when its a swapmod on a swapped experiment. On an active
  experiment, I moved that code down into tbswap, which will now does all
  of the virtual and physical state retore before it does the reswap back
  to the original experiment. Just for kicks, its also done if tbswap
  decides to swap the experiment cause of a fatal error.

  Cleanups: I changed $NoRecover to $CanRecover. My feeble brain cannot
  deal with !$NoRecover. I know, two knots make a wright for most people.

  Renderer: I was annoyed by the fact that we rerun the renderer on a
  failed swapmod. The original reason is that the renderer runs in the
  background and so vis_nodes cannot be saved with the rest of the virtual
  state tables cause the renderer might still be running when the user
  fires off the swapmod. Well, the hell with that. We lock the vis_nodes
  table anyway in the renderer during update, so we are certain to get a
  consistent snapshot. We store the renderer pid in the experiments table,
  so if the renderer was running, just fire off another one; mostly this is
  not going to happen. In addition, tbprerun no longer starts a new
  renderer when doing the swapmod; I start the new renderer later after
  swapmod succeeds. I might end up tweaking this a bit depending on what
  people notice as being different.

* Termination changes to batchexp and swapexp: I've rearranged the
  termination code using an END block so that any uncontrolled exit from
  either batchexp or swapexp will go through the cleanup code, and
  hopefully insert a stats record, as well as not leave the experiment in
  some inbetween state. I've set the max DB retry count to zero in both
  cases, which means infinite retry. I've also added SIGTERM handlers to
  both so that again, we can kill a hung batch/swap and have it clean up
  things more or less. Note that END blocks are not caught when a signal
  causes the program to die; you have to catch it and then die() so that
  the END block is executed.

  Eventually, we need to clean up the various libraries so that we do not
  use DBQueryFatal(), but rather use DBQueryWarn(), and look for failure.
  Ditto for event system interface.

That will show the devil who means business. Right on.

of affairs.

This is apparently a no-no and was happening at DETER.

It isn't needed on clients and it requires the linuxthreads package
which is not otherwise needed.

I took it off when debugging popen streams on Windows; it shouldn't have been checked in.