table by hand anymore! Update the group_policies table and then run
the script to update the permissions table (sbin/update_permissions).

Details:

My original thought when I started this was that I would be able to
replace the existing nodetypeXpid_permissions table with this new
stuff. Well, it turns out that this was not a good thing to do, for a
couple of reasons:

  * Engineering: We access the nodetypeXpid_permissions table from three
    different languages, and no way I wanted to rewrite this library in
    in python and php!

  * Performance: We access the nodetypeXpid_permissions from the web
    interface, on every single page load. In fact, we access it twice if
    if you count the FreePCs() count that we put at the top of the menu.
    Going through this library on each page load would be a serious drag.

So, rather then actually get rid of the nodetypeXpid_permissions table, I
decided to keep it as a "cache" of permissions stored in the group
policies table. Each time you update the policy tables, we need to run
the update_permissions script which will call into this library (see the
TBUpdateNodeTypeXpidPermissions() routine) to reconstruct the permissions
table. I have whacked the grantnodetype script to do exactly that.

Note that we could proably do the same thing for users by creating an
equivalent nodetypeXuid_permissions table, mapping users to types they
are allowed to use. That would be a lot rows, but the amount of data in
the table is small. That would give us very fine grained control of what
we show people in the web interface. Not sure it is worth it though.

I also added some instructions to previous commit in database-migrate.txt
on populating the new group_policies table from the existing
permissions table.

working completely.

More robot stuff, start in on path planning and cleanup rmcd a bit.

	* robots/emc/emcd.c: Update for obstacle-related changes in mtp.

	* robots/mtp/mtp.x, robots/mtp/mtp.h, robots/mtp/mtp.c,
	robots/mtp/mtp_send.c: Add messages for requesting/reporting robot
	sensor contacts, plus some cosmetic changes to the obstacle_config
	structure.

	* robots/primotion/garcia-pilot.cc,
	robots/primotion/pilotClient.hh, robots/primotion/pilotClient.cc:
	Add support for sending "contact" reports, which contain points
	where the sensors have detected an object.

	* robots/rmcd/GNUmakefile.in, robots/rmcd/obstacles.h,
	robots/rmcd/obstacles.c, robots/rmcd/pilotConnection.h,
	robots/rmcd/pilotConnection.c, robots/rmcd/rclip.h,
	robots/rmcd/rclip.c, robots/rmcd/rmcd.c: Cleanup and add in some
	obstacle avoidance.

emcd.config file

just wanted to get something checked in, in case someone wanted to
read/edit it now.

link changes were stripped out, and it was updated to only generate
points within the camera viewable portion of the robot area (which is
obtained from the rpc server).

Add tbsetdest utility for generating random "setdest" events for the
robots, it's just based on the original NS version.

	* configure, configure.in: Add tbsetdest stuff to the list of
	template files.  Fix from my last checkin, change error for
	missing rsync to a warning.

	* robots/GNUmakefile.in: Add tbsetdest subdir.

	* robots/tbsetdest/GNUmakefile.in, robots/tbsetdest/tbsetdest.h,
	robots/tbsetdest.cc: Original version of the NS "setdest"
	utility.

wiggle 'lost' robots (those for whom a wiggle, or subsequent wiggles, were
not detectable).

otherwise it's pointless.

Hopefully this will fix the experiment.waitforactive problem, since
it's the only thing I can think of that fits the symptoms...

It looks like this:
set-type-limit <type> <count>

This can be placed anywhere in the ptop file.  It limits the number of
physical nodes of a given type that an experimenter is allowed to use.

For example, we may limit a user to 10 PCs, or 5 pc850s. In the latter
case, if the experimenter had simply asked for 10 generic PCs, then we
will try to find them some mapping of nodes that uses types of PCs
other than pc850s.

Added a precheck to tell the user up-front if they asked for more
nodes than they are allowed to use of a given type.

Just restart it.

all of the nodes to boot up normally before I can turn them into an
inner elab (latter, after os_setup). That cannot happen with the
firewall rules in place. So, when an experiment is firewalled, reorder
the boot/wait list and wait for the firewall node first. Once that
hits ISUP, tell the elabinelab code (-f) option so that it can do what
it needs, which right now means an ssh over to the firewall node to
temporarily disable all the rules.

We still need to deal with teardown though.

sense at all. Use ceil ...

is apparently what triggers libevent.a to be built in the ../lib
directory.

The last part is the stuff to hook it in from assign_wrapper, and some
additional support in assign that Rob is adding for me. This comment is
from the top of new file db/libadminctrl.pm.in and describes everything in
detail.

# Admission control policies. These are the ones I could think of, although
# not all of these are implemented.
#
#  * Number of experiments per type/class (only one expt using robots).
#
#  * Number of experiments per project
#  * Number of experiments per subgroup
#  * Number of experiments per user
#
#  * Number of nodes per project      (nodes really means pc testnodes)
#  * Number of nodes per subgroup
#  * Number of nodes per user
#
#  * Number of nodes of a class per project
#  * Number of nodes of a class per group
#  * Number of nodes of a class per user
#
#  * Number of nodes of a type per project
#  * Number of nodes of a type per group
#  * Number of nodes of a type per user
#
#  * Number of nodes with attribute(s) per project
#  * Number of nodes with attribute(s) per group
#  * Number of nodes with attribute(s) per user
#
# So we have group (pid/gid) policies and user policies. These are stored
# into two different tables, group_policies and user_policies, indexed in
# the obvious manner. Each row of the table defines a count (experiments,
# nodes, etc) and a type of thing being counted (experiments, nodes, types,
# classes, etc). When we test for admission, we look for each matching row
# and test each condition. All conditions must pass. No conditions means a
# pass. There is also some "auxdata" which holds extra information needed
# for the policy (say, the type of node being restricted).
#
#      uid:     a uid
#   policy:     'experiments', 'nodes', 'type', 'class', 'attribute'
#    count:     a number
#  auxdata:     a string (optional)
#
# Example: A user policy of ('mike', 'nodes', 10) says that poor mike is
# not allowed to have more 10 nodes at a time, while ('mike', 'type',
# '10', 'pc850') says that mike cannot allocate more than 10 pc850s.
#
# The group_policies table:
#
#      pid:     a pid
#      gid:     a gid
#   policy:     'experiments', 'nodes', 'type', 'class', 'attribute'
#    count:     a number
#  auxdata:     a string (optional)
#
# Example: A project policy of ('testbed', 'testbed', 'experiments', 10)
# says that the testbed project may not have more then 10 experiments
# swapped in at a time, while ('testbed', 'TG1', 'nodes', 10) says that the
# TG1 subgroup of the testbed project may not use more than 10 nodes at
# time.
#
# In addition to group and user policies (which are policies that apply to
# specific users/projects/subgroups), we also need policies that apply to
# all users/projects/subgroups (ie: do not want to specify a particular
# restriction for every user!). To indicate such a policy, we use a special
# tag in the tables (for the user or pid/gid):
#
#      '+'  -  The policy applies to all users (or project/groups).
#
# Example: ('+','experiments',10) says that no user may have more then 10
# experiments swapped in at a time. The rule overrides anything more
# specific (say a particular user is restricted to 20 experiments; the above
# rule overrides that and the user (all users) is restricted to 10.
#
# Sometimes, you want one of these special rules to apply to everyone, but
# *allow* it to be overridden by a more specific rule. For that we use:
#
#      '-'  -  The policy applies to all users (or project/groups),
#              but can be overridden by a more specific rule.
#
# Example: The rules:
#
#	('-','type',0, 'garcia')
#       ('testbed', 'testbed', 'type', 10, 'garcia')
#
# says that no one is allowed to allocate garcias, unless there is specific
# rule that allows it; in this case the testbed project can allocate them.
#
# There are other global policies we would like to enforce. For example,
# "only one experiment can be using the robot testbed." Encoding this kind
# of policy is harder, and leads down a path that can get arbitrarily
# complex. Tha path leads to ruination, and so we want to avoid it at
# all costs.
#
# Instead we define a simple global policies table that applies to all
# experiments currently active on the testbed:
#
#   policy:     'nodes', 'type', 'class', 'attribute'
#     test:     'max', others I cannot think of right now ...
#    count:     a number
#  auxdata:     a string
#
# Example: A global policy of ('nodes', 'max', 10, '') say that the maximum
# number of nodes that may be allocated across the testbed is 10. Thats not
# a very realistic policy of course, but ('type', 'max', 1, 'garcia') says
# that a max of one garcia can be allocated across the testbed, which
# effectively means only one experiment will be able to use them at once.
# This is of course very weak, but I want to step back and give it some
# more thought before I redo this part.
#
# Is that clear? Hope so, cause it gets more complicated. Some admission
# control tests can be done early in the swap phase, before we really do
# anything (before assign_wrapper). Others (type and class) tests cannot
# be done here; only assign can figure out how an experiment is going to map
# to physical nodes (remember virtual types too), and in that case we need
# to tell assign what the "constraints" are and let it figure out what is
# possible.
#
# So, in addition to the simple checks we can do, we also generate an array
# to return to assign_wrapper with the maximum counts of each node type and
# class that is limited by the policies. assign_wrapper will dump those
# values into the ptop file so that assign can enforce those maximum values
# regardless of what hardware is actually available to use. As per discussion
# with Rob, that will look like:
#
#	set-type-limit <type> <limit>
#
# and assign will spit out a new type of violation that assign_wrapper will
# parse.
#
# NOTES:
#
#  1) Admission control is skipped in admin mode; returns okay.
#  2) Admission control is skipped when the pid is emulab-ops; returns okay.
#  3) When calculating current usage, nodes reserved to emulab-ops are
#     ignored.
#  4) The sitevar "swap/use_admission_control" controls the use of admission
#     control; defaults to 1 (on).
#  5) The current policies can be viewed in the web interface. See
#     https://www.emulab.net/showpolicies.php3
#  6) The global policy stuff is weak. I plan to step back and think about it
#     some more before redoing it, but it will tide us over for now.
#

More robot tweaks:

	* event/sched/event-sched.c: Start rmcd, then vmcd.

	* event/sched/rpc.cc: Add camera dimensions to the config file.

	* robots/emc/emcd.c: Add camera dimensions to the config file and
	destroy vmc's position_list when it disconnects.

	* robots/mtp/mtp.x, robots/mtp/mtp.c: Add dimensions to the camera
	config and add a command_id field to the update_position packet.

	* robots/primotion/garcia-pilot.cc: Move the decl of the acpGarcia
	object below daemon(3) since it doesn't seem to like it when the
	parent process dies and fix the log file creation.

	* robots/primotion/pilotClient.cc: Pass the command_id back in any
	update_position packets.

	* robots/rmcd/rmcd.c: Use the command-id to distinguish between
	STOPs for the sake of a GOTO and a wiggle.

	* robots/vmcd/visionTrack.h, robots/vmcd/visionTrack.c: Only
	coalesce packets from different cameras (duh) and mess with the
	tolerances a little more.

	* xmlrpc/emulabserver.py.in: Add some rough camera dimensions.

Some cleanup to the vision system and make wiggle work, although it is still
a bit glitchy.  This checkin is enough to identify the robots in their
pens and move them to their initial positions.

	* robots/emc/emcd.h, robots/emc/emcd.c: When rmc connects, send
	GOTOs with the initial positions given in the config file.  If rmc
	requests a vision update and one isn't available, queue the
	request and send a reply when an update does come in.

	* robots/mtp/GNUmakefile.in, robots/mtp/listNode.h,
	robots/mtp/listNode.c: Add amiga-style linked list node functions,
	tim always needs these.

	* robots/mtp/mtp.h, robots/mtp/mtp.c: Add mtp_theta function that
	produces a sane theta value between -M_PI and M_PI.

	* robots/mtp/mtp.x: Add MTP_WIGGLE_START type which causes the
	robots to stop in their tracks waiting for a real wiggle type
	(e.g. 180 deg turn).

	* robots/rmcd/rmcd.c: Tweaks, add support for MTP_WIGGLE_START.

	* robots/vmcd/GNUmakefile.in, robots/vmcd/robotObject.h,
	robots/vmcd/robotObject.c, robots/vmcd/visionTrack.h,
	robots/vmcd/visionTrack.c, robots/vmcd.c: Cleanup and make wiggle
	work.

	* robots/vmcd/vmc-client.c: If there are no objects detected in a
	camera send an error packet instead of nothing, so vmcd can keep
	in sync with the frames.

More robot integration and some event system updates.

	* configure, configure.in: Detect rsync for loghole and add
	utils/loghole to the list of template files.

	* db/libdb.pm.in, db/xmlconvert.in: Add virt_node_startloc to the
	list of virtual tables.

	* event/lib/event.h, event/lib/event.c, event/lib/tbevent.py.tail:
	Add event_stop_main function to break out of the event_main()
	loop.  Add timeline to the address tuple.

	* event/sched/GNUmakefile.in, event/sched/error-record.h,
	event/sched/error-record.c, event/sched/event-sched.8,
	event/sched/event-sched.h, event/sched/event-sched.c,
	event/sched/group-agent.h, event/sched/group-agent.c,
	event/sched/listNode.h, event/sched/listNode.c,
	event/sched/local-agent.h, event/sched/local-agent.c,
	event/sched/node-agent.h, event/sched/node-agent.cc,
	event/sched/queue.c, event/sched/rpc.h, event/sched/rpc.cc,
	event/sched/simulator-agent.h, event/sched/simulator-agent.c,
	event/sched/timeline-agent.h, event/sched/timeline-agent.c:
	Updated event scheduler, not completely finished, but well enough
	along for the robots.

	* lib/libtb/GNUmakefile.in, lib/libtb/popenf.h,
	lib/libtb/popenf.c, lib/libtb/systemf.h, lib/libtb/systemf.c: Add
	some handy versions of system/popen that take format arguments.

	* lib/libtb/tbdefs.h, lib/libtb/tbdefs.c: Add some more event and
	object types.

	* tbsetup/assign_wrapper.in: Add the virt_node_startloc building
	to desires string for a node.

	* tbsetup/ptopgen.in: Add a node's location to the feature list.

	* tbsetup/tbreport.in: Display the timeline/sequence an event is a
	part of.

	* tbsetup/ns2ir/GNUmakefile.in: Add timeline, sequence, and
	topography files.

	* tbsetup/ns2ir/node.tcl: Add initial position for nodes and allow
	them to be attached to "topographys".

	* tbsetup/ns2ir/parse-ns.in: Make a hwtype_class array with a
	node_type's class.  Make an 'areas' array that holds the
	buildings where nodes are located.  Make an 'obstacles' table
	with any obstacles in the building.

	* tbsetup/ns2ir/parse.tcl.in: Move named-args function from
	tb_compat.tcl to here.  Add reltime-to-secs function that converts
	time given in a format like "10h2m1s" to a seconds value, used in
	"$ns at" so its easier to write time values.  Add "K", "Kb", and
	"Kbps" as possible units for bandwidth (only the lowercase
	versions were available before).

	* tbsetup/ns2ir/program.tcl: Add "dir" and "timeout" attributes,
	although they don't go anywhere at the moment.

	* tbsetup/ns2ir/sequence.tcl, tbsetup/ns2ir/timeline.tcl,
	tbsetup/ns2ir/topography.tcl: Initial versions.

	* tbsetup/ns2ir/sim.tcl.in: Add support for timelines and
	sequences.  Add 'node-config' method to change the default
	configuration for nodes produced by the Simulator object.  Send an
	initial MODIFY event to any trafgen objects so their configuration
	gets through, even when there are no start/stop events.  Move
	event parsing to the 'make_event' method.

	* utils/loghole.1, utils/loghole.in: Loghole utility, used for
	retrieving logs from experimental nodes and creating archives of
	the logs.

	* xmlrpc/emulabclient.py.in: Escape any strange characters in the
	output field.

	* xmlrpc/emulabserver.py.in: Add virt_node_startloc to the list of
	virtual_tables.  Add emulab.vision_config and
	emulab.obstacle_config methods for getting information pertaining
	to the robots.  Change the OSID listing to include more fields.
	Add a "physical" aspect to experiment.info to get information
	about the physical nodes.  Add parent field to the events in the
	array returned by eventlist.  Add sshdescription to get extra
	information needed to log into a vnode.  Add node.statewait so you
	can wait for nodes to come up.

more testing.