GitLab

metric until Mike adds uncompressed data size to the images table.

This is a more appropriate place for applying/inheriting taint states,
and makes it easy to propagate TaintStates from vnodes to their
corresponding physical hosts (which is now done as well).

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

We force the reload of all images even if the boot image is already on
disk. Otherwise we violate assumptions in libosload about it being
responsible for setting def_boot_osid.

The right fix is to get rid of those assumptions, but no time right now...

This stub was previously using libossetup_subnode as its base class,
but the constructor was calling the base class constructor with a
"type" parameter, where the base class did not have a corresponding
argument.  This commit changes the stub class for blockstores to
refer directly to libossetup_handler instead.  We can sort out
whether going through some sort of "libossetup_subnode" base class
makes sense a bit later.
(cherry picked from commit 89fb668999deb76913957a8abd8950f8b60eccaf)

swap in yet:

set client [$ns node]
tb-set-node-os $client FEDORA15-STD

set d1 [$ns blockstore]
$d1 set-class "SAN"
$d1 set-protocol "iSCSI"
$d1 set-size 2GB

set san [$ns duplex-link $client $d1 10Kbps 0ms DropTail]

To turn this option on, define SPEWFROMOPS=1 in your defs file. This
will result in a redirect message from boss which will send the wget
client over to ops. 

A perl setuid root cgi script is run from the webserver on ops when a
/spewrpmtar request is made. This script sends the key,nodeid,file
over to boss via XMLRPC (as elabman). The return is simple yes or no,
the caller is allowed (not allowed) to have that file. Since the
ops script runs as root, it can spew the file back to the caller.

Note that the elabinelab checks for the elabinelab source code are
gone; we are now open source. Also, we spew that file from /share now,
to be consistent.

Previously tb-set-node-failure-mode of "nonfatal" only applied to failures
when rebooting a node. If there was an error during the disk reload phase,
the experiment would still fail.

This makes sense, as it is pretty dicey to let a node boot with an unloaded
or partially-loaded disk. But there are situations, such as 500+ node
experiments on PRObE, where it makes sense to not fail the experiment.

What we do if a node fails reload, is to clear the OSIDs and partition info
for the node and then force it to reboot (by setting the state to TBFAILED,
for which there is a REBOOT trigger in stated). This causes the node to come
up and park in pxeboot in the PXEWAIT state. It should remain in this state
across reboots. The user can manually os_load the machine, or do a swap
modify which will force the node to try to reload the original OS.

Since this may not be for everyone, this new allow non-fatal osload failures
requires that the "OsloadFailNonfatal" feature be enabled. This allows the
new behavior to be global, per-group, per-experiment or per-user. The default
is disabled.

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).

determining the jailosid for "static" images like OPENVZ-STD. For
example:

	tb-set-hardware $n1 d710-vm
	tb-set-node-os $n1 OPENVZ-STD FEDORA15-64-OVZ-STD

The main point is that OPENVZ-STD is a placeholder with no associated
image. It exists to tell the mapper and osload what to do. This is
accomplished with nextosid. The new approach makes things consistent
with subos stuff.

firewall before the regular nodes.

you can do this in your NS file:

tb-set-node-loadlist $myboss FBSD73-S2,FBSDXX-FOO

Note that this does not replace tb-set-node-os(), cause that is a
little too special. So in practice, you would do:

tb-set-node-os $myboss FBSD73-STD
tb-set-node-loadlist $myboss FBSD73-S2,FBSDXX-FOO

although the default is currently to do cooked mode in "basic" mode,
rather then "full" mode.

We now protect switch reloads via the SwitchFlash feature.  We
don't really give people a lot of advance warning about this,
and we wait long enough that it will irritatingly fail your
experiment swapin.  Ideally we should check before anything
starts happening, but we don't know if we *have* to reload
until we see what's on the nswitch node that gets allocated
to us... and by the time nodes are allocated, I think they
end up having to go through reloading if *any* of them fails.
Not sure though.

Also fixup handling of multiple libossetup_switch ops; if one
fails, abort the list instead of continuing on.

libosload_new contains the new libosload.  It provides the same
API as the original libosload, but the functionality has been
split out into well-defined methods that can be overridden by
per-node type subclasses in small chunks.  This is all protected
by the NewOsload feature.

libosload_switch.pm.in and libossetup_switch.pm.in contain the HP
switch support, which requires the new libosload and new
libossetup.  libossetup_switch doesn't do anything too radical, but
it does support running a node it is "lighting up" through multiple
operations -- i.e., first a RELOAD, then a RECONFIG.  This was
necessary because switches require a config to be pushed to them
(well, they do in the way I elected to support them), and they
cannot fetch configuration in the normal Emulab way via tmcd.

Eventually, that multi-op support will be factored out into
libossetup more generically so that other node types which require
push-based configuration can leverage it.

libosload_switch contains the HP switch loading code.  It's built
around expect-like interaction on the serial console.  It supports
xmodem and tftp uploads, but tries to only flash the switch lazily.
Thus, if the switch is already loaded with an image and a user
(or the reload daemon, or anybody) reloads it with the same image,
it won't actually get reloaded.  You can now force this reload
with os_load.

libosload_switch also contains reconfig code (i.e., to wipe
switch configs and recreate based on which experiment it is in).
libossetup_switch directly invokes this instead of going through
libosload, since configuring is not really part of loading.  It
is just convenient since configuration also happens over the
serial console, and all the osload code for the switch can be
reused.

Also, of course, there are miscellaneous changes to support the
new libosload in os_load itself.