GitLab

work fine when the nodes are behaving themselves.

1) geni_update_users: Takes a slice credential and a keys argument. Can
  only be invoked when the sliver is in the started/geni_ready state.
  Moves the slice to the geni_updating_users state until all of the
  nodes have completed the update, at which time the sliver moves back
  to started/geni_ready.

2) geni_updating_users_cancel: We can assume that some nodes will be whacky
  and will not perform the update when told to. This cancels the
  update and moves the sliver back to started/geni_ready.

A couple of notes:

* The current emulab node update time is about three minutes; the
  sliver is in this new state for that time and cannot be restarted or
  stopped. It can of course be deleted.

* Should we allow restart while in the updating phase? We could, but
  then I need more bookkeeping.

* Some nodes might not be running the watch dog, or might not even be
  an emulab image, so the operation will never end, not until
  canceled. I could add a timeout, but that will require a monitor or
  adding DB state to store the start time.

CM V2 (and thus the AM) now accept a type=speaksfor credential along
with regular credentials. When supplied, the speaksfor caller must be
equal to the owner of the speaksfor credential and the target must be
equal to the owner of the regular credential(s). All operations take
place in the context of the spokenfor user.

Added speaksfor slots to geni_slices,geni_aggregates and geni_tickets.
Also to the history table. But these are just the most recent data.
Each transaction is logged as normal, and the metadata now includes
the speaksfor data and the log always includes all of the credentials.

For testing, there is a new script in the scripts directory to
generate a speaksfor credential. Not installed since it is really
a hack. But to create one:

  perl genspeaksfor urn:publicid:IDN+emulab.net+user+leebee \
	urn:publicid:IDN+emulab.net+user+stoller

which generates a speaksfor credential that says stoller is speaking
for leebee.

Given a slice credential issued to leebee, the test scripts can be
invoked as follows (by stoller):

  createsliver.py -S speaksfor.cred -s slice.cred -c leebee.cred

A copy of leebee's self credential is needed simply cause of the test
script's desire to talk to the SA (which does not support speaksfor).
Not otherwise needed.

Oh, not tested on the AM interface yet.

find the interfaces inside containers.

and if it really is running, we have to kill it with vnode_setup -k.

boot. Need a better way to figure out wait times based on
the host OS.

level aggregate. Probably don't need that either.

We were getting ssl certificate errors with really long hrns, and
since we never use these certs, lets stop creating them.

adding the peerid, but now I want the local id too, for gentopofile.

fork and return to client; when I tested this it was on the Utah
network so it was really fast, but more generally it is really slow
and we do not want the RPC to time out.

This is very similar to what Emulab does on the swapin path for
normal experiments; wait and watch the nodes to see which ones
fail or otherwise timeout. Up till now, we did not do this on the
PG path, and so failed nodes were never signaled, and the slice
was left in a changing state forever. This also allows us to capture
the node bootlogs and convert them to logfiles that we can associate
with the slice on the showslice web page.

Details: start/restart forks a child (WrapperFork()) and allows
the parent to return to the client. The slice is unlocked so that
the client can call SliverStatus(), etc. But the client cannot
do anything that actually changes the sliver (update, stop, etc)
until the monitor finishes (or times out on its own). The lone
exception is Deleteslice(), which will asynchronously kill the
monitor and then terminate the slice. Ditto the command line
script "cleanupslice".

We will probably need to add another way to allow the client to
terminate the monitor early, but have not decided where yet.

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* state...

look for VMs that need a reload setup.

a little bit to avoid a race at the very end of time, when trying to
unregister a sliver from the SA.

push to stable. These changes properly record URNs in the aggregate
and manifest history tables.