prereserve.in

#!/usr/bin/perl -w
#
# Copyright (c) 2003-2018 University of Utah and the Flux Group.
# 
# {{{EMULAB-LICENSE
# 
# This file is part of the Emulab network testbed software.
# 
# This file is free software: you can redistribute it and/or modify it
# under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or (at
# your option) any later version.
# 
# This file is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public
# License for more details.
# 
# You should have received a copy of the GNU Affero General Public License
# along with this file.  If not, see <http://www.gnu.org/licenses/>.
# 
# }}}
#
use strict;
use English;
use Getopt::Std;
use Date::Parse;

#
# Set up and clear node pre-reservations.
#
sub usage()
{
    print STDERR "Usage: prereserve [-f] [-t typelist] [-p priority] ".
	"[-s start] [-e end [-r]] [-n resname] pid [count | node_id ...\n";
    print STDERR "       prereserve -r -n resname pid\n";
    print STDERR "       prereserve -i -n resname pid\n";
    print STDERR "       prereserve -a -n resname pid\n";
    print STDERR "       prereserve -l\n";
    print STDERR "   -h   This message\n";
    print STDERR "   -f   Force pre-reservation, even if admission control is violated\n";
    print STDERR "   -t   Comma separated list of node types\n";
    print STDERR "   -p   Priority. Defaults to zero (least priority)\n";
    print STDERR "   -n   Reservation name; defaults to 'default'\n";
    print STDERR "   -r   Clear/Revoke prereserve for project\n";
    print STDERR "   -i   Show pending prereserve for project\n";
    print STDERR "   -l   List all pending prereserves\n";
    print STDERR "   -s   Optional start time to begin pre reservation\n";
    print STDERR "   -e   Optional end time for pre reservation.\n";
    print STDERR "        Implies -r options at termination time.\n";
    print STDERR "   -a   Activate a pending reservation (internal option)\n";
    exit(-1);
}
my $optlist  = "hdt:n:ilre:s:map:f";
my $priority = 0;
my $debug    = 0;
my $info     = 0;
my $list     = 0;
my $revoke   = 0;
my $sendmail = 0;
my $activate = 0;
my $force    = 0;
my @nodelist = ();
my $resname;
my $starttime;
my $endtime;
my $typelist;
my $pid;
my $count;
my $project;

# Protos
sub fatal($);
sub StartReservation($$);

#
# Configure variables
#
my $TB		 = "@prefix@";
my $TBOPS        = "@TBOPSEMAIL@";

#
# Testbed Support libraries
#
use lib "@prefix@/lib";
use emdb;
use NodeType;
use Node;
use libtestbed;
use Experiment;
use Project;
use User;
use Reservation;

#
# Turn off line buffering on output
#
$| = 1;

#
# Untaint the path
# 
$ENV{'PATH'} = "/bin:/sbin:/usr/bin:";

#
# Parse command arguments. Once we return from getopts, all that should be
# left are the required arguments.
#
my %options = ();
if (! getopts($optlist, \%options)) {
    usage();
}
if (defined($options{h})) {
    usage();
}
if (defined($options{p})) {
    $priority = $options{p};
}
if (defined($options{n})) {
    $resname = $options{n};
}
if (defined($options{r})) {
    $revoke = 1;
}
if (defined($options{d})) {
    $debug = 1;
}
if (defined($options{"m"})) {
    $sendmail = 1;
}
if (defined($options{"a"})) {
    $activate = 1;
}
if (defined($options{t})) {
    $typelist = $options{t};
}
if (defined($options{i})) {
    $info = 1;
}
if (defined($options{l})) {
    $list = 1;
}
if (defined($options{f})) {
    $force = 1;
}
if (defined($options{"e"})) {
    $endtime = $options{"e"};
    if (!defined(str2time($endtime))) {
	fatal("Could not parse -e option.");
    }
}
if (defined($options{"s"})) {
    $starttime = $options{"s"};
    
    if (!defined(str2time($starttime))) {
	fatal("Could not parse -s option.");
    }
}

if ($info || $revoke) {
    usage()
	if (@ARGV != 1);
    usage()
	if (!defined($resname));
    
    $pid = $ARGV[0];
}
elsif ($list) {
    usage()
	if (@ARGV);
}
elsif ($activate) {
    usage()
	if (@ARGV != 1 || !defined($resname));

    exit(StartReservation($ARGV[0], $resname));
}
else {
    usage()
	if (@ARGV < 2);
    
    $pid     = shift(@ARGV);
    $count   = shift(@ARGV);
    $resname = "default" if (!defined($resname));

    if ($count !~ /^\d+$/) {
	if (defined($typelist)) {
	    fatal("Not allowed to specify types and a node list together");
	}
	@nodelist = ($count, @ARGV);
	$count    = scalar(@nodelist);

	foreach my $nodeid (@nodelist) {
	    my $node = Node->Lookup($nodeid);
	    if (!defined($node)) {
		fatal("No such node $nodeid");
	    }
	}
    }

    if ($priority && ! ($priority =~ /^\d*$/)) {
	usage();
    }
}

#
# List all pending prereserves.
#
if ($list) {
    my $query_result = 
	DBQueryFatal("select *,(count>0) as needed from project_reservations ".
		     "order by needed desc, priority desc, created asc");

    if ($query_result->numrows) {
	printf("%-18s %-12s %-4s  %-3s  %-10s %-18s %-3s %s\n",
	       "Project", "ResName", "Need", "Got", "Creator", "Created", "Pri", "Types");
	print "---------------------------------------------------------------------\n";
    }
    
    while (my $row = $query_result->fetchrow_hashref()) {
	my $pid     = $row->{'pid'};
	my $name    = $row->{'name'};
	my $count   = $row->{'count'};
	my $created = $row->{'created'};
	my $creator = $row->{'creator'};
	my $types   = $row->{'types'} || "";
	my $priority= $row->{'priority'};
	my $starttime = $row->{'start'};
	my $endtime   = $row->{'end'};
	my $active    = $row->{'active'};
	my $current = 0;

	my $current_result =
	    DBQueryFatal("select count(*) from nodes ".
			 "where reserved_pid='$pid' and ".
			 "      reservation_name='$name'");

	($current) = $current_result->fetchrow_array()
	    if ($current_result && $current_result->numrows);

	printf("%-20s %-12s %-4d %-3d %-10s %-18s %-3d %s\n",
	       $pid, $name, $count, $current, $creator, $created,
	       $priority, $types);

	if (defined($starttime)) {
	    print "  *** Starts: $starttime";
	    if (! $active) {
		print " (pending)";
	    }
	    if (defined($endtime)) {
		print " Ends: $endtime";
	    }
	    print "\n";
	}
    }
    exit(0);
}

if ($pid =~ /^(.*):(.*)$/) {
    require GeniHRN;

    my $urn = GeniHRN::Generate($pid, "authority", "sa");

    $project = Project->LookupNonLocal($urn);
    if (!defined($project)) {
	fatal("No such nonlocal project $pid\n");
    }
    $pid = $project->pid();
}
else {
    $project = Project->Lookup($pid);

    if (!defined($project)) {
	fatal("No such project $pid\n");
    }
}
my $pid_idx = $project->pid_idx();

#
# Show and exit.
#
if ($info) {
    my $current = 0;
    my $pending = 0;
    
    my $nodes_result =
	DBQueryFatal("select node_id from nodes ".
		     "where reserved_pid='$pid' and ".
		     "      reservation_name='$resname'");

    ($current) = $nodes_result->numrows
	if ($nodes_result && $nodes_result->numrows);
    
    my $query_result =
	DBQueryFatal("select * from project_reservations ".
		     "where pid_idx='$pid_idx' and name='$resname'");

    if ($query_result->numrows) {
	my $row = $query_result->fetchrow_hashref();
	my $pid     = $row->{'pid'};
	my $count   = $row->{'count'};
	my $created = $row->{'created'};
	my $creator = $row->{'creator'};
	my $types   = $row->{'types'} || "*";
	my $priority= $row->{'priority'};
	my $starttime = $row->{'start'};
	my $endtime   = $row->{'end'};
	my $active    = $row->{'active'};

	printf("%-4s  %-3s %-10s %-18s %-3s %s\n",
	       "Need", "Got", "Creator", "When", "Pri", "Types");
	print "-------------------------------------------------------------\n";
	printf("%-4s  %-3s %-10s %-18s %-3d %s\n",
	       $count, $current, $creator, $created, $priority, $types);

	if (defined($starttime)) {
	    print "*** Starts: $starttime";
	    if (! $active) {
		print " (pending)";
	    }
	    if (defined($endtime)) {
		print " Ends: $endtime";
	    }
	    print "\n";
	}
    }
    if ($current) {
	print "-------------------------------------------------------------\n";
	printf("%-15s %-10s %-32s\n",
	       "NodeID", "Type", "Pid/Eid");
	print "-------------------------------------------------------------\n";

	while (my ($node_id) = $nodes_result->fetchrow_array()) {
	    my $node   = Node->Lookup($node_id);
	    my $type   = $node->type();
	    my $pideid = "--";

	    if ($node->IsReserved()) {
		$pideid = $node->pid() . "/" . $node->eid();
	    }
	    printf("%-15s %-10s %-32s\n", $node_id, $type, $pideid);
	}
    }
    my $noderes_result =
	DBQueryFatal("select node_id from node_reservations ".
		     "where pid_idx='$pid_idx' and ".
		     "      reservation_name='$resname'");
    if ($noderes_result->numrows) {
	print "-------------------------------------------------------------\n";
	print "Still waiting for these nodes\n";
	printf("%-15s %-10s %-32s\n",
	       "NodeID", "Type", "Pid/Eid");
	print "-------------------------------------------------------------\n";

	while (my ($node_id) = $noderes_result->fetchrow_array()) {
	    my $node   = Node->Lookup($node_id);
	    my $type   = $node->type();
	    my $pideid = "--";

	    if ($node->IsReserved()) {
		$pideid = $node->pid() . "/" . $node->eid();
	    }
	    printf("%-15s %-10s %-32s\n", $node_id, $type, $pideid);
	}
    }
    exit(0);
}

#
# Verify user, must be admin or root.
#
my $this_user;
if ($UID) {
    $this_user = User->ThisUser();
    if (! defined($this_user)) {
	fatal("You ($UID) do not exist!");
    }
    if (!$this_user->IsAdmin()) {
	fatal("You are not a testbed administrator!");
    }
}

#
# Revoke/Clear and exit.
#
if ($revoke) {
    my $query_result =
	DBQueryFatal("select name from project_reservations ".
		     "where pid_idx='$pid_idx' and name='$resname'");
    if (!$query_result->numrows) {
	fatal("No such prereserve $pid,$resname");
    }

    #
    # Mark reservation as terminal to prevent it from being used.
    # Turning off active is no good, it will just get turned on.
    #
    DBQueryFatal("update project_reservations set terminal=1 ".
		 "where pid_idx='$pid_idx' and name='$resname'");

    #
    # When revoking the reservation, lets see if any nodes can be
    # moved to a another prereserve instead of going into the free pool.
    #
    $query_result =
	DBQueryFatal("select node_id from nodes ".
		     "where reserved_pid='$pid' and ".
		     "      reservation_name='$resname'");
    while (my ($node_id) = $query_result->fetchrow_array()) {
	my $node = Node->Lookup($node_id);
	$node->CheckPreReserve(0, 0);
    }
    DBQueryFatal("update nodes set reserved_pid=null, ".
		 "   reservation_name=null ".
		 "where reserved_pid='$pid' and ".
		 "      reservation_name='$resname'");

    DBQueryFatal("delete from node_reservations ".
		 "where pid_idx='$pid_idx' and reservation_name='$resname'");
    DBQueryFatal("delete from project_reservations ".
		 "where pid_idx='$pid_idx' and name='$resname'");
    
    exit(0);
}

#
# Do not allow this as root; we want proper history.
#
if ($UID == 0) {
    fatal("Please do not run this as root!");
}
my $uid = $this_user->uid();
my $uid_idx = $this_user->uid_idx();

my %nodetypes = ();

# Sanity check the type list.
if (defined($typelist)) {
    my @types = split(",", $typelist);

    if( @types > 1 && !$force ) {
	fatal( "Sorry, can't handle admission control check with multiple " .
	       "node types.\nEither make multiple pre-reservations with a " .
	       "dedicated node count per\nnode type, or retry with -f if " .
	       "you want a single count covering multiple\ntypes, bypassing " .
	       "admission control." );
    }

    $nodetypes{ $types[ 0 ] } = $count;
    
    foreach my $typename (@types) {
	my $type = NodeType->Lookup($typename);
	if (!defined($type)) {
	    fatal("No such node type $typename");
	}
    }
} else {
    foreach my $nodeid (@nodelist) {
	my $node = Node->Lookup( $nodeid );
	if( exists( $nodetypes{ $node->type() } ) ) {
	    $nodetypes{ $node->type() }++;
	} else {
	    $nodetypes{ $node->type() } = 1;
	}
    }
}

# Run admission control now -- unfortunately there's a nasty race condition
# here.  Unfortunately it's messy to make the admission control check and
# the reservation table updates atomic, because of MySQL's stupid locking
# semantics (both components want to independently lock different tables
# and MySQL forbids acquiring more locks if any are held, which precludes
# nesting either section inside the other).
#
# Let's just ignore all that for now, because the intention is that
# future reservations will eventually be used everywhere and
# prereservations will be deprecated.

if( !$force ) {
    my $start = defined( $starttime ) ? str2time( $starttime ) : 0;
    my $end = defined( $endtime ) ? str2time( $endtime ) : 0x7FFFFFFF;
    foreach my $type ( keys( %nodetypes ) ) {
	my $reservations = Reservation->LookupAll( $type );
	my $res = Reservation->Create( $pid, undef, $start, $end, $type,
				       $nodetypes{ $type } );
	push( @$reservations, $res );
	my $error;
	if( !Reservation->IsFeasible( $reservations, \$error ) ) {
	    print STDERR "prereserve: $error\n";
	    exit( 1 );
	}
    }
}

# Ideally, we would now call Reservation->BeginTransaction, but that won't
# work because we will later want to acquire table locks, so don't bother.

# 
# Lets say that a current request is an error. delete and recreate.
#
DBQueryFatal("lock tables project_reservations write, ".
	     "            node_reservations write");
my $query_result =
    DBQueryFatal("select * from project_reservations ".
		 "where pid_idx='$pid_idx' and name='$resname'");
if ($query_result->numrows) {
    fatal("Already have a reservation request $pid,$resname; ".
	  "please clear it first");
}

#
# It would be odd to allow the same node to be in more then one
# reservation in the same project. Well, I can imagine a scenario; we
# have a bunch of pcXXXs in a pre-reserve, some already allocated.  We
# want to revoke that pre-reserve, but keep some subset of the pcXXXs
# in that project. If there was another pre-reserve in the same
# project, we would never allow that subset to get back into the
# wild. It might be useful to support this at some point, I think it
# can be done. Lets see if its needed.
#
if (@nodelist) {
    foreach my $node_id (@nodelist) {
	my $query_result =
	    DBQueryFatal("select node_id from node_reservations ".
			 "where node_id='$node_id' and pid_idx='$pid_idx'");
	if ($query_result->numrows) {
	    fatal("There is already a pre-reservation for $node_id in\n".
		  "this project; this is not allowed");
	}
    }
}

#
# Enter the table info, but mark as not active until later.
#
my $typearg  = (defined($typelist)  ? ",types='$typelist'" : "");
my $startarg = "";
my $endarg   = "";

if ($starttime) {
    my $tmp = str2time($starttime);
    $startarg = ",start=FROM_UNIXTIME($tmp)";
}
if ($endtime) {
    my $tmp = str2time($endtime);
    $endarg = ",end=FROM_UNIXTIME($tmp)";
}
DBQueryFatal("insert into project_reservations set ".
	     "  pid='$pid', pid_idx='$pid_idx', name='$resname',".
	     "  count='$count', creator='$uid', creator_idx='$uid_idx', ".
	     "  created=now(),active=0 $typearg $startarg $endarg");
if (@nodelist) {
    foreach my $node_id (@nodelist) {
	if (!DBQueryWarn("insert into node_reservations set ".
			 "  pid='$pid', pid_idx='$pid_idx', ".
			 "  reservation_name='$resname', ".
			 "  node_id='$node_id'")) {
	    DBQueryWarn("delete from node_reservations ".
			"where pid_idx='$pid_idx' and ".
			"      reservation_name='$resname'");
	    DBQueryWarn("delete from project_reservations ".
			"where pid_idx='$pid_idx' and name='$resname'");
	    exit(-1);
	}
    }
}
DBQueryFatal("unlock tables");
print "Node reservation request for $count nodes has been created.\n";

#
# Activate, although note that the cron job (prereserve_check) might
# have beat us to it already. We check the active bit below.
#
if (!defined($starttime) || str2time($starttime) <= time()) {
    exit(StartReservation($pid, $resname));
}
exit(0);

#
# Activate a reservation request; find as many nodes as possible,
# and then mark it as active. 
#
sub StartReservation($$)
{
    my ($pid, $resname) = @_;

    DBQueryFatal("lock tables nodes write, node_types read, ".
		 " project_reservations write, ".
		 " node_reservations write, reserved write");

    my $noderes_result =
	DBQueryFatal("select node_id from node_reservations ".
		     "where pid='$pid' and reservation_name='$resname'");

    my $query_result =
	DBQueryFatal("select * from project_reservations ".
		     "where pid='$pid' and name='$resname'");
    if (!$query_result->numrows) {
	fatal("No reservation $resname defined for project");
    }
    my $row = $query_result->fetchrow_hashref();
    my $active = $row->{'active'};
    my $count  = $row->{'count'};
    my $types  = $row->{'types'};
    my @types  = (defined($types) ? split(",", $types) : ("*"));

    # Someone beat us to it. 
    if ($active) {
	DBQueryFatal("unlock tables");
	return 0;
    }
    
    #
    # First see if we can find enough (or any) nodes to satisfy the
    # prereserve, from nodes already prereserved.
    #
    $query_result =
	DBQueryFatal("select node_id from nodes ".
		     "where reserved_pid='$pid' and ".
		     "      reservation_name='$resname'");

    my $current = $query_result->numrows;

    if ($current) {
	print "There are currently $current nodes with a pre-reservation ".
	    "for project $pid.\n";
	if ($current >= $count) {
	    goto done;
	}
    }

    #
    # If we have a node list, then we do not do any type stuff, we
    # operate on specific nodes only.
    #
    if ($noderes_result->numrows) {
	@types = ();

	while (my ($node_id) = $noderes_result->fetchrow_array()) {
	    my $query_result =
		DBQueryFatal("select pid,reserved_pid from nodes ".
			     "left join reserved on ".
			     "   reserved.node_id=nodes.node_id ".
			     "where nodes.node_id='$node_id'");

	    next
		if (!$query_result->numrows);

	    my ($curpid,$rpid) = $query_result->fetchrow_array();

	    if ((defined($curpid) && $curpid ne $pid) ||
		(defined($rpid) && $rpid ne $pid)) {
		#
		# Someone else still has it, skip.
		#
		print "$node_id is still reserved to project $curpid, ".
		    "will be done later.\n"
		    if (defined($curpid));
		print "$node_id is still pre-reserved to project $rpid, ".
		    "will be done later.\n"
		    if (defined($rpid));
		next;
	    }
	    # Free or we already have it. Note that we do not allow a
	    # specific node to be in more then one reservation in the
	    # same project. See note above.
	    $current++;
	    DBQueryFatal("delete from node_reservations ".
			 "where node_id='$node_id'");
	    DBQueryFatal("update nodes set reserved_pid='$pid', ".
			 "   reservation_name='$resname' ".
			 "where node_id='$node_id'");
	}
    }

    #
    # Then check free/allocated nodes of each type.
    #
    foreach my $type (@types) {
	last
	    if ($current >= $count);

	my $tcount  = 0;
	my $tclause = "";
	if ($type ne "*") {
	    $tclause = "and node_types.type='$type'";
	}

	#
	# check for nodes already reserved to the project; they count
	# against the prereserve request. If the reserved_pid is not
	# set, we set it to indicate that they are attached to this
	# pre-reserve.
	#
	$query_result =
	    DBQueryFatal("select reserved.node_id,nodes.reserved_pid, ".
			 "       nodes.reservation_name ".
			 "  from reserved ".
			 "left join nodes on nodes.node_id=reserved.node_id ".
			 "left join node_types on node_types.type=nodes.type ".
			 "where nodes.role='testnode' and ".
			 "      node_types.class='pc' and ".
			 "      reserved.pid='$pid' $tclause");
	
	while (my ($node_id,$reserved_pid,
		   $reservation_name) = $query_result->fetchrow_array()) {
	    if (!defined($reserved_pid)) {
		DBQueryFatal("update nodes set reserved_pid='$pid', ".
			     "   reservation_name='$resname' ".
			     "where node_id='$node_id'");
		$tcount++;
		$current++;
	    }
	    #
	    # It is unlikely this will happen, unless someone mucks with
	    # the database directly. 
	    #
	    elsif ($reserved_pid eq $pid && $reservation_name eq $resname) {
		$current++;
	    }
	    last
		if ($current >= $count);
	}
	if ($tcount) {
	    print "Set reserved_pid for $tcount (allocated)" .
		($type eq "*" ? "" : " $type") . " nodes.\n";

	    last
		if ($current >= $count);
	}

	$query_result =
	    DBQueryFatal("select nodes.node_id from nodes ".
			 "left join reserved on ".
			 "     reserved.node_id=nodes.node_id ".
			 "left join node_types on node_types.type=nodes.type ".
			 "where reserved.node_id is null and ".
			 "      nodes.role='testnode' and ".
			 "      node_types.class='pc' and ".
			 "      nodes.reserved_pid is null $tclause");

	$tcount = 0;
	while (my ($node_id) = $query_result->fetchrow_array()) {
	    DBQueryFatal("update nodes set reserved_pid='$pid', ".
			 "   reservation_name='$resname' ".
			 "where node_id='$node_id'");
	    $current++;
	    $tcount++;
	    last
		if ($current >= $count);
	}
	if ($tcount) {
	    print "Set reserved_pid for $tcount (free)" .
		($type eq "*" ? "" : " $type") . " nodes.\n";
	}
    }
    if ($current >= $count) {
	print "Got as many nodes as you wanted. Yippie!\n";
    }
    #
    # Update the reservation entry, and mark as active.
    #
  done:
    $count -= $current;
    $count = 0 if ($count < 0);

    DBQueryFatal("update project_reservations set ".
		 "       count='$count',active=1 ".
		 "where pid='$pid' and name='$resname'");
    DBQueryFatal("unlock tables");

    if ($count == 0 && $sendmail) {
	SENDMAIL($TBOPS, "Pre Reservation for $pid,$resname has completed",
		 "The pre reservation request for $pid,$resname ".
		 "has been fullfilled\n", $TBOPS);
    }
    return 0
}

sub fatal($)
{
    my ($mesg) = $_[0];

    die("*** $0:\n".
	"    $mesg\n");
}