[haizea-commit] r616 - in branches/TP2.0: src/haizea/cli src/haizea/common src/haizea/core src/haizea/core/frontends src/haizea/core/scheduler tests
haizea-commit at mailman.cs.uchicago.edu
haizea-commit at mailman.cs.uchicago.edu
Fri Jul 24 12:07:44 CDT 2009
Author: borja
Date: 2009-07-24 12:07:40 -0500 (Fri, 24 Jul 2009)
New Revision: 616
Modified:
branches/TP2.0/src/haizea/cli/rpc_commands.py
branches/TP2.0/src/haizea/common/utils.py
branches/TP2.0/src/haizea/core/frontends/rpc.py
branches/TP2.0/src/haizea/core/leases.py
branches/TP2.0/src/haizea/core/manager.py
branches/TP2.0/src/haizea/core/rpcserver.py
branches/TP2.0/src/haizea/core/scheduler/lease_scheduler.py
branches/TP2.0/src/haizea/core/scheduler/resourcepool.py
branches/TP2.0/tests/common.py
branches/TP2.0/tests/sample_slottables.py
branches/TP2.0/tests/test_xmlrpc.py
Log:
XMLRPC interface is mostly working.
Modified: branches/TP2.0/src/haizea/cli/rpc_commands.py
===================================================================
--- branches/TP2.0/src/haizea/cli/rpc_commands.py 2009-07-24 10:34:56 UTC (rev 615)
+++ branches/TP2.0/src/haizea/cli/rpc_commands.py 2009-07-24 17:07:40 UTC (rev 616)
@@ -16,13 +16,15 @@
# limitations under the License. #
# -------------------------------------------------------------------------- #
import haizea.common.defaults as defaults
-from haizea.core.datastruct import Lease
+import haizea.common.constants as constants
+from haizea.core.leases import Lease, Capacity, Duration, Timestamp, DiskImageSoftwareEnvironment
+from haizea.common.utils import round_datetime
from haizea.cli.optionparser import OptionParser, Option
from haizea.cli import Command
import xmlrpclib
import sys
-from mx.DateTime import TimeDelta
-from mx.DateTime import ISO
+from mx.DateTime import TimeDelta, ISO, now
+import xml.etree.ElementTree as ET
class RPCCommand(Command):
def __init__(self, argv):
@@ -41,10 +43,18 @@
"""
name = "haizea-request-lease"
+
+ START_NOW = "now"
+ START_BESTEFFORT = "best_effort"
+ DURATION_UNLIMITED = "unlimited"
def __init__(self, argv):
RPCCommand.__init__(self, argv)
+ self.optparser.add_option(Option("-f", "--file", action="store", type="string", dest="file",
+ help = """
+ File containing a lease description in XML.
+ """))
self.optparser.add_option(Option("-t", "--start", action="store", type="string", dest="start",
help = """
Starting time. Can be an ISO timestamp, "best_effort", or "now"
@@ -65,9 +75,9 @@
help = """
Specifies a non-preemptible lease.
"""))
- self.optparser.add_option(Option("-c", "--cpu", action="store", type="float", dest="cpu",
+ self.optparser.add_option(Option("-c", "--cpu", action="store", type="int", dest="cpu",
help = """
- Percentage of CPU (must be 0 < c <= 1.0)
+ Percentage of CPU (must be 0 < c <= 100)
"""))
self.optparser.add_option(Option("-m", "--mem", action="store", type="int", dest="mem",
help = """
@@ -85,16 +95,70 @@
def run(self):
self.parse_options()
- if self.opt.preemptible == None:
- preemptible = False
+ if self.opt.file != None:
+ lease_elem = ET.parse(self.opt.file).getroot()
+ # If a relative starting time is used, replace for an
+ # absolute starting time.
+ exact = lease.find("start/exact")
+ if exact != None:
+ exact_time = exact.get("time")
+ exact.set("time", str(self.__absolute_time(exact_time)))
+ lease_xml_str = ET.tostring(lease_elem)
else:
- preemptible = self.opt.preemptible
+ if self.opt.preemptible == None:
+ preemptible = False
+ else:
+ preemptible = self.opt.preemptible
+ capacity = Capacity([constants.RES_CPU, constants.RES_MEM])
+ capacity.set_quantity(constants.RES_CPU, int(self.opt.cpu))
+ capacity.set_quantity(constants.RES_MEM, int(self.opt.mem))
+ requested_resources = dict([(i+1, capacity) for i in range(self.opt.numnodes)])
+ if self.opt.duration == haizea_request_lease.DURATION_UNLIMITED:
+ # This is an interim solution (make it run for a century).
+ # TODO: Integrate concept of unlimited duration in the lease datastruct
+ duration = DateTimeDelta(36500)
+ else:
+ duration = ISO.ParseTimeDelta(self.opt.duration)
+
+ if self.opt.start == haizea_request_lease.START_NOW:
+ lease = Lease.create_new(
+ submit_time = None,
+ requested_resources = requested_resources,
+ start = Timestamp(None),
+ duration = Duration(duration),
+ deadline = None,
+ preemptible=preemptible,
+ software = DiskImageSoftwareEnvironment(self.opt.vmimage, self.opt.vmimagesize)
+ )
+ elif self.opt.start == haizea_request_lease.START_BESTEFFORT:
+ lease = Lease.create_new(
+ submit_time = None,
+ requested_resources = requested_resources,
+ start = Timestamp(None),
+ duration = Duration(duration),
+ deadline = None,
+ preemptible=preemptible,
+ software = DiskImageSoftwareEnvironment(self.opt.vmimage, self.opt.vmimagesize)
+ )
+ else:
+ start = self.__absolute_time(self.opt.start)
+ lease = Lease.create_new(
+ submit_time = None,
+ requested_resources = requested_resources,
+ start = Timestamp(start),
+ duration = Duration(duration),
+ deadline = None,
+ preemptible=preemptible,
+ software = DiskImageSoftwareEnvironment(self.opt.vmimage, self.opt.vmimagesize)
+ )
+
+ lease_xml_str = ET.tostring(lease.to_xml())
+
server = self.create_rpc_proxy(self.opt.server)
try:
- lease_id = server.create_lease(self.opt.start, self.opt.duration, preemptible, self.opt.numnodes,
- self.opt.cpu, self.opt.mem, self.opt.vmimage, self.opt.vmimagesize)
+ lease_id = server.create_lease(lease_xml_str)
print "Lease submitted correctly."
print "Lease ID: %i" % lease_id
except xmlrpclib.Fault, err:
@@ -106,6 +170,14 @@
if self.opt.debug:
raise
+ def __absolute_time(self, time_str):
+ if time_str[0] == "+":
+ # Relative time
+ time = round_datetime(now() + ISO.ParseTime(time_str[1:]))
+ else:
+ time = Parser.ParseDateTime(time_str)
+
+ return time
class haizea_cancel_lease(RPCCommand):
"""
@@ -163,7 +235,8 @@
try:
leases = server.get_leases()
- console_table_printer(fields, leases)
+ print leases
+ #console_table_printer(fields, leases)
except xmlrpclib.Fault, err:
print >> sys.stderr, "XMLRPC fault: %s" % err.faultString
if self.opt.debug:
Modified: branches/TP2.0/src/haizea/common/utils.py
===================================================================
--- branches/TP2.0/src/haizea/common/utils.py 2009-07-24 10:34:56 UTC (rev 615)
+++ branches/TP2.0/src/haizea/common/utils.py 2009-07-24 17:07:40 UTC (rev 616)
@@ -76,6 +76,10 @@
LEASE_ID += 1
return l
+def reset_lease_id_counter():
+ global LEASE_ID
+ LEASE_ID = 1
+
def pretty_nodemap(nodes):
pnodes = list(set(nodes.values()))
normmap = [([y[0] for y in nodes.items() if y[1]==x], x) for x in pnodes]
Modified: branches/TP2.0/src/haizea/core/frontends/rpc.py
===================================================================
--- branches/TP2.0/src/haizea/core/frontends/rpc.py 2009-07-24 10:34:56 UTC (rev 615)
+++ branches/TP2.0/src/haizea/core/frontends/rpc.py 2009-07-24 17:07:40 UTC (rev 616)
@@ -17,16 +17,13 @@
# -------------------------------------------------------------------------- #
import haizea.common.constants as constants
from haizea.core.scheduler.slottable import ResourceTuple
+from haizea.core.leases import Lease
from haizea.core.frontends import RequestFrontend
from haizea.common.utils import round_datetime, get_config, get_clock
from mx.DateTime import DateTimeDelta, TimeDelta, ISO
import logging
class RPCFrontend(RequestFrontend):
- HAIZEA_START_NOW = "now"
- HAIZEA_START_BESTEFFORT = "best_effort"
- HAIZEA_DURATION_UNLIMITED = "unlimited"
-
def __init__(self, manager):
self.manager = manager
self.logger = logging.getLogger("RPCREQ")
@@ -41,38 +38,13 @@
def exists_more_requests(self):
return True
-
- def create_lease(self, start, duration, preemptible, numnodes, cpu, mem, vmimage, vmimagesize):
- tSubmit = round_datetime(get_clock().get_time())
- resreq = ResourceTuple.create_empty()
- resreq.set_by_type(constants.RES_CPU, float(cpu))
- resreq.set_by_type(constants.RES_MEM, int(mem))
- if duration == RPCFrontend.HAIZEA_DURATION_UNLIMITED:
- # This is an interim solution (make it run for a century).
- # TODO: Integrate concept of unlimited duration in the lease datastruct
- duration = DateTimeDelta(36500)
- else:
- duration = ISO.ParseTimeDelta(duration)
- if start == RPCFrontend.HAIZEA_START_NOW:
- leasereq = ImmediateLease(tSubmit, duration, vmimage, vmimagesize, numnodes, resreq, preemptible)
- elif start == RPCFrontend.HAIZEA_START_BESTEFFORT:
- leasereq = BestEffortLease(tSubmit, duration, vmimage, vmimagesize, numnodes, resreq, preemptible)
- else:
- if start[0] == "+":
- # Relative time
- start = round_datetime(tSubmit + ISO.ParseTime(start[1:]))
- else:
- start = ISO.ParseDateTime(start)
- leasereq = ARLease(tSubmit, start, duration, vmimage, vmimagesize, numnodes, resreq, preemptible)
+ def create_lease(self, lease_xml_str):
+ lease = Lease.from_xml_string(lease_xml_str)
+ self.accumulated.append(lease)
+ return lease.id
- self.accumulated.append(leasereq)
- return leasereq.id
-
-
-
-
Modified: branches/TP2.0/src/haizea/core/leases.py
===================================================================
--- branches/TP2.0/src/haizea/core/leases.py 2009-07-24 10:34:56 UTC (rev 615)
+++ branches/TP2.0/src/haizea/core/leases.py 2009-07-24 17:07:40 UTC (rev 616)
@@ -34,7 +34,7 @@
"""
from haizea.common.constants import LOGLEVEL_VDEBUG
-from haizea.common.utils import StateMachine, round_datetime_delta, get_lease_id, pretty_nodemap, xmlrpc_marshall_singlevalue
+from haizea.common.utils import StateMachine, round_datetime, round_datetime_delta, get_lease_id, pretty_nodemap, xmlrpc_marshall_singlevalue
from haizea.core.scheduler.slottable import ResourceReservation
from mx.DateTime import DateTime, TimeDelta, Parser
@@ -113,8 +113,8 @@
IMMEDIATE: "Immediate",
UNKNOWN: "Unknown"}
- def __init__(self, submit_time, requested_resources, start, duration,
- deadline, preemptible, software):
+ def __init__(self, id, submit_time, requested_resources, start, duration,
+ deadline, preemptible, software, state):
"""Constructs a lease.
The arguments are the fundamental attributes of a lease.
@@ -125,6 +125,8 @@
only meant to be consumed by other Haizea objects.
Arguments:
+ id -- Unique identifier for the lease. If None, one
+ will be provided.
submit_time -- The time at which the lease was submitted
requested_resources -- A dictionary (int -> Capacity) mapping
each requested node to a capacity (i.e., the amount of
@@ -139,7 +141,7 @@
software environment required by the lease.
"""
# Lease ID (read only)
- self.id = get_lease_id()
+ self.id = id
# Lease attributes
self.submit_time = submit_time
@@ -153,7 +155,9 @@
# Bookkeeping attributes:
# Lease state
- self.state = LeaseStateMachine()
+ if state == None:
+ state = Lease.STATE_NEW
+ self.state = LeaseStateMachine(initial_state = state)
# End of lease (recorded when the lease ends)
self.end = None
@@ -179,7 +183,23 @@
self.logger = logging.getLogger("LEASES")
+
@classmethod
+ def create_new(cls, submit_time, requested_resources, start, duration,
+ deadline, preemptible, software):
+ id = get_lease_id()
+ state = Lease.STATE_NEW
+ return cls(id, submit_time, requested_resources, start, duration,
+ deadline, preemptible, software, state)
+
+ @classmethod
+ def create_new_from_xml_element(cls, element):
+ lease = cls.from_xml_element(element)
+ lease.id = get_lease_id()
+ lease.state = LeaseStateMachine(initial_state = Lease.STATE_NEW)
+ return lease
+
+ @classmethod
def from_xml_file(cls, xml_file):
"""Constructs a lease from an XML file.
@@ -189,7 +209,7 @@
Argument:
xml_file -- XML file containing the lease in XML format.
"""
- cls.from_xml_element(ET.parse(xml_file).getroot())
+ return cls.from_xml_element(ET.parse(xml_file).getroot())
@classmethod
def from_xml_string(cls, xml_str):
@@ -201,7 +221,7 @@
Argument:
xml_str -- String containing the lease in XML format.
"""
- cls.from_xml_element(ET.parsestring(xml_str))
+ return cls.from_xml_element(ET.fromstring(xml_str))
@classmethod
def from_xml_element(cls, element):
@@ -213,8 +233,27 @@
Argument:
element -- Element object containing a "<lease>" element.
"""
- submit_time = Parser.DateTimeFromString(element.get("submit-time"))
+ id = element.get("id")
+
+ if id == None:
+ id = None
+ else:
+ id = int(id)
+
+ state = element.get("state")
+ if state == None:
+ state = None
+ else:
+ state = int(state)
+
+
+ submit_time = element.get("submit-time")
+ if submit_time == None:
+ submit_time = None
+ else:
+ submit_time = Parser.DateTimeFromString(submit_time)
+
nodes = Nodes.from_xml_element(element.find("nodes"))
requested_resources = nodes.get_all_nodes()
@@ -232,7 +271,11 @@
deadline = None
- preemptible = bool(element.get("preemptible"))
+ preemptible = element.get("preemptible").capitalize()
+ if preemptible == "True":
+ preemptible = True
+ elif preemptible == "False":
+ preemptible = False
software = element.find("software")
@@ -244,9 +287,64 @@
image_size = int(disk_image.get("size"))
software = DiskImageSoftwareEnvironment(image_id, image_size)
- return Lease(submit_time, requested_resources, start, duration,
- deadline, preemptible, software)
+ return Lease(id, submit_time, requested_resources, start, duration,
+ deadline, preemptible, software, state)
+
+ def to_xml(self):
+ """Returns an ElementTree XML representation of the lease
+
+ See the Haizea documentation for details on the
+ lease XML format.
+
+ """
+ lease = ET.Element("lease")
+ lease.set("id", str(self.id))
+ lease.set("state", str(self.get_state()))
+ lease.set("preemptible", str(self.preemptible))
+ if self.submit_time != None:
+ lease.set("submit-time", str(self.submit_time))
+
+ capacities = {}
+ for capacity in self.requested_resources.values():
+ key = capacity
+ for c in capacities:
+ if capacity == c:
+ key = c
+ break
+ numnodes = capacities.setdefault(key, 0)
+ capacities[key] += 1
+
+ nodes = Nodes([(numnodes,c) for c,numnodes in capacities.items()])
+ lease.append(nodes.to_xml())
+
+ start = ET.SubElement(lease, "start")
+ if self.start.requested != None:
+ exact = ET.SubElement(start, "exact")
+ exact.set("time", str(self.start.requested))
+
+ duration = ET.SubElement(lease, "duration")
+ duration.set("time", str(self.duration.requested))
+
+ software = ET.SubElement(lease, "software")
+ if isinstance(self.software, UnmanagedSoftwareEnvironment):
+ ET.SubElement(software, "none")
+ elif isinstance(self.software, DiskImageSoftwareEnvironment):
+ imagetransfer = ET.SubElement(software, "disk-image")
+ imagetransfer.set("id", self.software.image_id)
+ imagetransfer.set("size", str(self.software.image_size))
+
+ return lease
+
+ def to_xml_string(self):
+ """Returns a string XML representation of the lease
+
+ See the Haizea documentation for details on the
+ lease XML format.
+
+ """
+ return ET.tostring(self.to_xml())
+
def get_type(self):
"""Determines the type of lease
@@ -484,7 +582,6 @@
valid transitions.
"""
- initial_state = Lease.STATE_NEW
transitions = {Lease.STATE_NEW: [(Lease.STATE_PENDING, "")],
Lease.STATE_PENDING: [(Lease.STATE_SCHEDULED, ""),
@@ -557,8 +654,8 @@
Lease.STATE_REJECTED: [],
}
- def __init__(self):
- StateMachine.__init__(self, LeaseStateMachine.initial_state, LeaseStateMachine.transitions, Lease.state_str)
+ def __init__(self, initial_state):
+ StateMachine.__init__(self, initial_state, LeaseStateMachine.transitions, Lease.state_str)
class Capacity(object):
@@ -598,6 +695,15 @@
self.ninstances = dict([(type, 1) for type in types])
self.quantity = dict([(type, [0]) for type in types])
+ def get_ninstances(self, type):
+ """Gets the number of instances for a resource type
+
+ Argument:
+ type -- The type of resource (using the same name passed
+ when constructing the Capacity object)
+ """
+ return self.ninstances[type]
+
def get_quantity(self, type):
"""Gets the quantity of a single-instance resource
@@ -662,7 +768,27 @@
"""
return self.quantity.keys()
+
+ def __eq__(self, other):
+ """Tests if two capacities are the same
+
+ """
+ for type in self.quantity:
+ if not other.quantity.has_key(type):
+ return False
+ if self.ninstances[type] != other.ninstances[type]:
+ return False
+ if self.quantity[type] != other.quantity[type]:
+ return False
+ return True
+ def __ne__(self, other):
+ """Tests if two capacities are not the same
+
+ """
+ return not self == other
+
+
class Timestamp(object):
"""An exact point in time.
@@ -883,7 +1009,7 @@
start = inittime + Parser.DateTimeDeltaFromString(exact.get("time"))
exact.set("time", str(start))
- lease = Lease.from_xml_element(lease)
+ lease = Lease.create_new_from_xml_element(lease)
realduration = r.find("realduration")
if realduration != None:
@@ -982,29 +1108,26 @@
A "resources string" is a shorthand way of specifying a site
with homogeneous resources and no attributes. The format is:
- <numnodes> <resource_type>,<resource_quantity>[;<resource_type>,<resource_quantity>]*
+ <numnodes> <resource_type>:<resource_quantity>[,<resource_type>:<resource_quantity>]*
- For example: 4 CPU,100;Memory,1024
+ For example: 4 CPU:100,Memory:1024
Argument:
resource_str -- resources string
"""
- from haizea.core.scheduler.slottable import ResourceTuple
resource_str = resource_str.split(" ")
numnodes = int(resource_str[0])
- resources = resource_str[1].split(";")
+ resources = resource_str[1].split(",")
res = {}
for r in resources:
- type = r.split(",")[0]
- amount = int(r.split(",")[1])
- ResourceTuple.add_resource_type(type)
- res[type] = amount
+ type, amount = r.split(":")
+ res[type] = int(amount)
- capacity = ResourceTuple.create_empty()
+ capacity = Capacity(res.keys())
for (type,amount) in res.items():
- capacity.set_by_type(type, amount)
+ capacity.set_quantity(type, amount)
nodes = Nodes([(numnodes,capacity)])
@@ -1109,6 +1232,26 @@
return cls(nodesets)
+ def to_xml(self):
+ """Returns an ElementTree XML representation of the nodes
+
+ See the Haizea documentation for details on the
+ lease XML format.
+
+ """
+ nodes = ET.Element("nodes")
+ for (numnodes, capacity) in self.node_sets:
+ nodeset = ET.SubElement(nodes, "node-set")
+ nodeset.set("numnodes", str(numnodes))
+ for type in capacity.get_resource_types():
+ res = ET.SubElement(nodeset, "res")
+ res.set("type", type)
+ ninstances = capacity.get_ninstances(type)
+ if ninstances == 1:
+ res.set("amount", str(capacity.get_quantity(type)))
+
+ return nodes
+
def get_all_nodes(self):
"""Returns a dictionary mapping individual nodes to capacities
Modified: branches/TP2.0/src/haizea/core/manager.py
===================================================================
--- branches/TP2.0/src/haizea/core/manager.py 2009-07-24 10:34:56 UTC (rev 615)
+++ branches/TP2.0/src/haizea/core/manager.py 2009-07-24 17:07:40 UTC (rev 616)
@@ -855,7 +855,6 @@
if nextchangepoint != None and nextchangepoint <= self.nextperiodicwakeup:
# We need to wake up earlier to handle a slot table event
nextwakeup = nextchangepoint
- self.manager.scheduler.slottable.getNextChangePoint(self.lastwakeup)
self.logger.status("Going back to sleep. Waking up at %s to handle slot table event." % nextwakeup)
else:
# Nothing to do before waking up
Modified: branches/TP2.0/src/haizea/core/rpcserver.py
===================================================================
--- branches/TP2.0/src/haizea/core/rpcserver.py 2009-07-24 10:34:56 UTC (rev 615)
+++ branches/TP2.0/src/haizea/core/rpcserver.py 2009-07-24 17:07:40 UTC (rev 616)
@@ -75,7 +75,7 @@
return 0
def get_leases(self):
- return [l.xmlrpc_marshall() for l in self.manager.scheduler.leases.get_leases()]
+ return [l.to_xml_string() for l in self.manager.scheduler.leases.get_leases()]
def get_lease(self, lease_id):
return 0
@@ -84,7 +84,7 @@
return [l.xmlrpc_marshall() for l in self.manager.scheduler.queue]
def get_hosts(self):
- return [h.xmlrpc_marshall() for h in self.manager.scheduler.vm_scheduler.resourcepool.nodes]
+ return [h.xmlrpc_marshall() for h in self.manager.scheduler.vm_scheduler.resourcepool.nodes.values()]
def notify_event(self, lease_id, enactment_id, event):
pass
\ No newline at end of file
Modified: branches/TP2.0/src/haizea/core/scheduler/lease_scheduler.py
===================================================================
--- branches/TP2.0/src/haizea/core/scheduler/lease_scheduler.py 2009-07-24 10:34:56 UTC (rev 615)
+++ branches/TP2.0/src/haizea/core/scheduler/lease_scheduler.py 2009-07-24 17:07:40 UTC (rev 616)
@@ -114,6 +114,8 @@
lease -- Lease object. Its state must be STATE_NEW.
"""
self.logger.info("Lease #%i has been requested." % lease.id)
+ if lease.submit_time == None:
+ lease.submit_time = round_datetime(get_clock().get_time())
lease.print_contents()
lease.set_state(Lease.STATE_PENDING)
if get_policy().accept_lease(lease):
@@ -324,7 +326,7 @@
self.logger.info("Lease %i is scheduled. Cancelling reservations." % lease.id)
rrs = lease.get_scheduled_reservations()
for r in rrs:
- self.slottable.removeReservation(r)
+ self.slottable.remove_reservation(r)
elif lease_state in [Lease.STATE_QUEUED, Lease.STATE_SUSPENDED_QUEUED]:
# If a lease is in the queue, waiting to be scheduled, cancelling
Modified: branches/TP2.0/src/haizea/core/scheduler/resourcepool.py
===================================================================
--- branches/TP2.0/src/haizea/core/scheduler/resourcepool.py 2009-07-24 10:34:56 UTC (rev 615)
+++ branches/TP2.0/src/haizea/core/scheduler/resourcepool.py 2009-07-24 17:07:40 UTC (rev 616)
@@ -229,8 +229,8 @@
h = {}
h["id"] = self.id
h["hostname"] = self.hostname
- h["cpu"] = self.capacity.get_by_type(constants.RES_CPU)
- h["mem"] = self.capacity.get_by_type(constants.RES_MEM)
+ h["cpu"] = self.capacity.get_quantity(constants.RES_CPU)
+ h["mem"] = self.capacity.get_quantity(constants.RES_MEM)
return h
Modified: branches/TP2.0/tests/common.py
===================================================================
--- branches/TP2.0/tests/common.py 2009-07-24 10:34:56 UTC (rev 615)
+++ branches/TP2.0/tests/common.py 2009-07-24 17:07:40 UTC (rev 616)
@@ -100,7 +100,7 @@
def create_ar_lease(lease_id, submit_time, start, end, preemptible, requested_resources):
start = Timestamp(start)
duration = Duration(end - start.requested)
- lease = Lease(submit_time = submit_time,
+ lease = Lease.create_new(submit_time = submit_time,
requested_resources = requested_resources,
start = start,
duration = duration,
Modified: branches/TP2.0/tests/sample_slottables.py
===================================================================
--- branches/TP2.0/tests/sample_slottables.py 2009-07-24 10:34:56 UTC (rev 615)
+++ branches/TP2.0/tests/sample_slottables.py 2009-07-24 17:07:40 UTC (rev 616)
@@ -51,7 +51,7 @@
slottable.add_node(3, FULL_NODE)
slottable.add_node(4, FULL_NODE)
- lease1 = Lease(None,{},None,None,None,1,None)
+ lease1 = Lease.create_new(None,{},None,None,None,1,None)
lease1.id = 1
res1 = {2: HALF_NODE}
rr1_1 = ResourceReservation(lease1, T1315, T1325, res1)
@@ -59,13 +59,13 @@
slottable.add_reservation(rr1_1)
slottable.add_reservation(rr1_2)
- lease2 = Lease(None,{},None,None,None,2,None)
+ lease2 = Lease.create_new(None,{},None,None,None,2,None)
lease2.id = 2
res2 = {2: FULL_NODE, 3: FULL_NODE}
rr2 = ResourceReservation(lease2, T1330, T1345, res2)
slottable.add_reservation(rr2)
- lease3 = Lease(None,{},None,None,None,1,None)
+ lease3 = Lease.create_new(None,{},None,None,None,1,None)
lease3.id = 3
res3 = {4: FULL_NODE}
rr3_1 = ResourceReservation(lease3, T1330, T1355, res3)
@@ -73,19 +73,19 @@
slottable.add_reservation(rr3_1)
slottable.add_reservation(rr3_2)
- lease4 = Lease(None,{},None,None,None,1,None)
+ lease4 = Lease.create_new(None,{},None,None,None,1,None)
lease4.id = 4
res4 = {2: QRTR_NODE, 3: HALF_NODE}
rr4 = ResourceReservation(lease4, T1350, T1415, res4)
slottable.add_reservation(rr4)
- lease5 = Lease(None,{},None,None,None,1,None)
+ lease5 = Lease.create_new(None,{},None,None,None,1,None)
lease5.id = 5
res5 = {2: QRTR_NODE}
rr5 = ResourceReservation(lease5, T1350, T1415, res5)
slottable.add_reservation(rr5)
- lease6 = Lease(None,{},None,None,None,1,None)
+ lease6 = Lease.create_new(None,{},None,None,None,1,None)
lease6.id = 6
res6 = {1: FULL_NODE}
rr6 = ResourceReservation(lease6, T1255, T1305, res6)
Modified: branches/TP2.0/tests/test_xmlrpc.py
===================================================================
--- branches/TP2.0/tests/test_xmlrpc.py 2009-07-24 10:34:56 UTC (rev 615)
+++ branches/TP2.0/tests/test_xmlrpc.py 2009-07-24 17:07:40 UTC (rev 616)
@@ -1,5 +1,6 @@
from common import BaseXMLRPCTest
from mx.DateTime import TimeDelta
+from haizea.common.utils import reset_lease_id_counter
import haizea.cli.rpc_commands as rpc
import time
@@ -7,6 +8,7 @@
def __init__(self):
self.config = self.load_configfile("base_config_simulator.conf")
self.config.set("simulation", "clock", "real")
+ self.config.set("simulation", "resources", "4 CPU:100,Memory:1024")
self.config.set("scheduling", "backfilling", "off")
self.config.set("scheduling", "non-schedulable-interval", "2")
@@ -21,6 +23,7 @@
self.stop()
def test_ar(self):
+ reset_lease_id_counter()
self.start()
cmd = rpc.haizea_request_lease(["-D", "-t", "+00:01:00", "-d", "00:10:00", "-n", "1", "--non-preemptible",
"-c", "1", "-m", "512", "-i", "foobar.img", "-z", "600"])
@@ -35,6 +38,7 @@
self.stop()
def test_be(self):
+ reset_lease_id_counter()
self.start()
cmd = rpc.haizea_request_lease(["-D", "-t", "best_effort", "-d", "00:10:00", "-n", "4", "--non-preemptible",
"-c", "1", "-m", "512", "-i", "foobar.img", "-z", "600"])
@@ -46,18 +50,19 @@
cmd = rpc.haizea_list_leases(["-D"])
cmd.run()
# Cancel the queued request
- cmd = rpc.haizea_cancel_lease(["-D", "-l", "3"])
+ cmd = rpc.haizea_cancel_lease(["-D", "-l", "2"])
cmd.run()
cmd = rpc.haizea_list_leases(["-D"])
cmd.run()
# Cancel the running request
- cmd = rpc.haizea_cancel_lease(["-D", "-l", "2"])
+ cmd = rpc.haizea_cancel_lease(["-D", "-l", "1"])
cmd.run()
cmd = rpc.haizea_list_leases(["-D"])
cmd.run()
self.stop()
def test_im(self):
+ reset_lease_id_counter()
self.start()
cmd = rpc.haizea_request_lease(["-D", "-t", "now", "-d", "00:10:00", "-n", "1", "--non-preemptible",
"-c", "1", "-m", "512", "-i", "foobar.img", "-z", "600"])
@@ -65,7 +70,7 @@
time.sleep(5)
cmd = rpc.haizea_list_leases(["-D"])
cmd.run()
- cmd = rpc.haizea_cancel_lease(["-D", "-l", "4"])
+ cmd = rpc.haizea_cancel_lease(["-D", "-l", "1"])
cmd.run()
cmd = rpc.haizea_list_leases(["-D"])
cmd.run()
More information about the Haizea-commit
mailing list