GitLab

1. You cannot unregister a slice at the SA before it has expired. This
   will be annoying at times, but the alphanumeric namespace for slice
   ames is probably big enough for us.

2. To renew a slice, the easiest approach is to call the Renew method
   at the SA, get a new credential for the slice, and then pass that
   to renew on the CMs where you have slivers.

The changes address the problem of slice expiration.  Before this
change, when registering a slice at the Slice Authority, there was no
way to give it an expiration time. The SA just assigns a default
(currently one hour). Then when asking for a ticket at a CM, you can
specify a "valid_until" field in the rspec, which becomes the sliver
expiration time at that CM. You can later (before it expires) "renew"
the sliver, extending the time. Both the sliver and the slice will
expire from the CM at that time.

Further complicating things is that credentials also have an
expiration time in them so that credentials are not valid forever. A
slice credential picks up the expiration time that the SA assigned to
the slice (mentioned in the first paragraph).

A problem is that this arrangement allows you to extend the expiration
of a sliver past the expiration of the slice that is recorded at the
SA. This makes it impossible to expire slice records at the SA since
if we did, and there were outstanding slivers, you could get into a
situation where you would have no ability to access those slivers. (an
admin person can always kill off the sliver).

Remember, the SA cannot know for sure if there are any slivers out
there, especially if they can exist past the expiration of the slice.

The solution:

* Provide a Renew call at the SA to update the slice expiration time.
  Also allow for an expiration time in the Register() call.

  The SA will need to abide by these three rules:
  1. Never issue slice credentials which expire later than the
     corresponding slice
  2. Never allow the slice expiration time to be moved earlier
  3. Never deregister slices before they expire [*].

* Change the CM to not set the expiration of a sliver past the
  expiration of the slice credential; the credential expiration is an
  upper bound on the valid_until field of the rspec. Instead, one must
  first extend the slice at the SA, get a new slice credential, and
  use that to extend the sliver at the CM.

* For consistency with the SA, the CM API will changed so that
  RenewSliver() becomes RenewSlice(), and it will require the
  slice credential.

I added a sig handler to reopen the log file. See corresponding changes
to doc/UPDATING and to install/boss-install.in

project, or shared ones.

have the same problem; webkit does not allow a parent page to look
inside the docment of a child iframe. Not sue if this is a bug or a
function of new security model, but nonetheless, the trick no longer
works. Need a new trick.

redirect) for virt_nodes.parent_osname by mistake.

some debug stuff too.

Got side-tracked when I noticed that currentusage.php3 dealie in the header
disappears when you have a testbed with no experimental nodes.  Started looking
at the error console in the browser and noticed these...

a node has failed.

* In the main wait loop, I check the eventstate for the node, for
  TBFAILED or PXEFAILED. Neither of these should happen after the
  reboot, so it makes sense to quit waiting if they do.

* I added an event handler to libosload, specifically to watch for
  nodes entering RELOADSETUP or RELOADING, after the reboot. Because
  of the race with reboot, this was best done with a handler instead
  of polling the DB state like case #1 above. The idea is that a node
  should hit one of these two states within a fairly short time (I
  currently have it set to 5 minutes). If not, something is wrong and
  the loop bails on that node. ÊWhat happens after is subject to the
  normal waiting times.

I believe that these two tests will catch a lot of cases where osload
is waiting on something that will never finish.

Fix a problem with the -h flag - I was forgetting to exit()

so that I can add '-p' (show patch) to my public repository.

Also, fixed up an existing config option that had a character
illegal for 'git config' (underscores are not allowed).

Make git-diff-tree generate more context (8 lines).

Also, keep track of the last commit successfully pushed to CVS and start
there when doing a cvspush if the local repo is up to date.  This should
prevent duplicate commits and allow new commits to be pushed before the
central Git repo is updated from CVS.

severely flaky.

Pass '--numstat' to git-show so that we can see separate insert/delete
counts per file instead of just a count for all files in that commit.

reserved yet, and make it reserved into the provided experiment.

move them into hwcheckup.

Make sure nodes are imageable, otherwise straight to hwdown.

Minor fix to Node::MoveReservation().

land in hwdown.

Currently, if a node fails to boot in os_setup and the node is running
a system image, it is moved into hwdown. 99% of the time this is
wasted work; the node did not fail for hardware reasons, but for some
other reason that is transient.

The new approach is to move the node into another holding experiment,
emulab-ops/hwcheckup. The daemon watches that experiment, and nodes
that land in it are freshly reloaded with the default image and
rebooted. If the node reboots okay after reload, it is released back
into the free pool. If it fails any part of the reload/reboot, it is
officially moved into hwdown.

Another possible use; if you have a suspect node, you go wiggle some
hardware, and instead of releasing it into the free pool, you move it
into hwcheckup, to see if it reloads/reboots. If not, it lands in
hwdown again. Then you break out the hammer.

Most of the changes in Node.pm, libdb.pm, and os_setup are
organizational changes to make the code cleaner.

with Eric this afternoon.

- git-cvsexportcommit.mod is the same as the standard
  git-cvsexportcommit script, except it doesn't fail if you try applying
  a patch to the sandbox that has already been applied (i.e., you do a
  cvspush before the upstream git repo has been updated).

- git-cvspush uses the above script to export each commit between the
  upstream branch head and your local branch head to CVS. To use it,
  run the following command inside your git repo:

  git config branch.<branch>.cvsdir <sandbox>

  where '<branch>' is your local git branch name and '<sandbox>' is
  the CVS sandbox where you've checked out that branch.  Set up an
  alias for it with this:

  git config --global alias.cvspush "!git-cvspush"

  and run 'git cvspush <branch>' (where '<branch>' is the branch to push
  or the current one if not specified) when you're ready to push pending
  commits to CVS.

to mailing lists, etc.