def run(self):
self.parse_options()
server = self.create_rpc_proxy(self.opt.server)
fields = [("id", "ID", 3), ("type", "Type", 12), ("state", "State", 9),
("start_req", "Starting time", 22),
("duration_req", "Duration", 12), ("numnodes", "Nodes", 3)]
try:
leases = server.get_queue()
if len(leases) == 0:
print "Queue is empty."
else:
leases_fields = []
for lease_xml in leases:
lease = Lease.from_xml_string(lease_xml)
lease_fields = {}
lease_fields["id"] = lease.id
lease_fields["type"] = Lease.type_str[lease.get_type()]
lease_fields["state"] = Lease.state_str[lease.get_state()]
lease_fields["start_req"] = lease.start.requested
lease_fields["duration_req"] = lease.duration.requested
lease_fields["numnodes"] = len(lease.requested_resources)
leases_fields.append(lease_fields)
console_table_printer(fields, leases_fields)
except xmlrpclib.Fault, err:
print >> sys.stderr, "XMLRPC fault: %s" % err.faultString
if self.opt.debug:
raise
def __ONEreqs_to_lease(self, opennebula_vms, group_id=None):
# The vm_with_params is used to extract the HAIZEA parameters.
# (i.e., lease-wide attributes)
vm_with_params = opennebula_vms[0]
# Per-lease attributes
start = vm_with_params.start
duration = vm_with_params.duration
preemptible = vm_with_params.preemptible
submit_time = vm_with_params.submit_time
# Per-vnode attributes
requested_resources = dict([(i+1,vm.capacity) for i, vm in enumerate(opennebula_vms)])
lease = Lease.create_new(submit_time = submit_time,
requested_resources = requested_resources,
start = start,
duration = duration,
deadline = None,
preemptible = preemptible,
software = UnmanagedSoftwareEnvironment())
lease.enactment_info = group_id
lease.vnode_enactment_info = dict([(i+1,vm.one_id) for i, vm in enumerate(opennebula_vms)])
return lease
def run(self):
self.parse_options()
server = self.create_rpc_proxy(self.opt.server)
fields = [("id","ID", 3),
("type","Type", 12),
("state","State", 9),
("start_req", "Starting time", 22),
("duration_req", "Duration", 12),
("numnodes", "Nodes", 3)]
try:
leases = server.get_queue()
if len(leases) == 0:
print "Queue is empty."
else:
leases_fields = []
for lease_xml in leases:
lease = Lease.from_xml_string(lease_xml)
lease_fields = {}
lease_fields["id"] = lease.id
lease_fields["type"] = Lease.type_str[lease.get_type()]
lease_fields["state"] = Lease.state_str[lease.get_state()]
lease_fields["start_req"] = lease.start.requested
lease_fields["duration_req"] = lease.duration.requested
lease_fields["numnodes"] = len(lease.requested_resources)
leases_fields.append(lease_fields)
console_table_printer(fields, leases_fields)
except xmlrpclib.Fault, err:
print >> sys.stderr, "XMLRPC fault: %s" % err.faultString
if self.opt.debug:
raise
def create_lease(self, lease_xml_str):
lease = Lease.from_xml_string(lease_xml_str)
lease.id = get_lease_id()
self.accumulated.append(lease)
return lease.id
def create_ar_lease(lease_id, submit_time, start, end, preemptible, requested_resources):
start = Timestamp(start)
duration = Duration(end - start.requested)
lease = Lease.create_new(submit_time = submit_time,
requested_resources = requested_resources,
start = start,
duration = duration,
deadline = None,
preemptible = preemptible,
software = None)
lease.id = lease_id
return lease
def sample_slottable_1():
slottable = SlotTable(
[(constants.RES_CPU, ResourceTuple.SINGLE_INSTANCE), (constants.RES_MEM, ResourceTuple.SINGLE_INSTANCE)]
)
FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(slottable)
slottable.add_node(1, FULL_NODE)
slottable.add_node(2, FULL_NODE)
slottable.add_node(3, FULL_NODE)
slottable.add_node(4, FULL_NODE)
lease1 = Lease.create_new(None, None, {}, None, None, None, 1, None)
lease1.id = 1
res1 = {2: HALF_NODE}
rr1_1 = ResourceReservation(lease1, T1315, T1325, res1)
rr1_2 = ResourceReservation(lease1, T1325, T1330, res1)
slottable.add_reservation(rr1_1)
slottable.add_reservation(rr1_2)
lease2 = Lease.create_new(None, 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.create_new(None, None, {}, None, None, None, 1, None)
lease3.id = 3
res3 = {4: FULL_NODE}
rr3_1 = ResourceReservation(lease3, T1330, T1355, res3)
rr3_2 = ResourceReservation(lease3, T1355, T1400, res3)
slottable.add_reservation(rr3_1)
slottable.add_reservation(rr3_2)
lease4 = Lease.create_new(None, 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.create_new(None, 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.create_new(None, None, {}, None, None, None, 1, None)
lease6.id = 6
res6 = {1: FULL_NODE}
rr6 = ResourceReservation(lease6, T1255, T1305, res6)
slottable.add_reservation(rr6)
return slottable, [lease1, lease2, lease3, lease4, lease5, lease6]
def __gen_lease(self):
submit_time = None
user_id = None
res = self.config.get(LWFGenerator.NODES_SEC, LWFGenerator.RESOURCES_OPT)
res = Capacity.from_resources_string(res)
numnodes = self._get_numnodes(None)
requested_resources = dict([(i+1,res) for i in xrange(numnodes)])
start, delta = self._get_start(self.start_type, None)
start = Timestamp(TimeDelta(seconds=start))
duration = self._get_duration()
duration = Duration(TimeDelta(seconds=duration))
deadline = None
preemptible = False
software = self._get_software()
l = Lease.create_new(submit_time, user_id, requested_resources,
start, duration, deadline, preemptible, software)
return l
def run(self):
self.parse_options()
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:
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) * 100)
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(lease_id=None,
submit_time=None,
requested_resources=requested_resources,
start=Timestamp(Timestamp.NOW),
duration=Duration(duration),
deadline=None,
preemptible=preemptible,
software=DiskImageSoftwareEnvironment(
self.opt.vmimage, self.opt.vmimagesize),
state=None)
elif self.opt.start == haizea_request_lease.START_BESTEFFORT:
lease = Lease(lease_id=None,
submit_time=None,
requested_resources=requested_resources,
start=Timestamp(Timestamp.UNSPECIFIED),
duration=Duration(duration),
deadline=None,
preemptible=preemptible,
software=DiskImageSoftwareEnvironment(
self.opt.vmimage, self.opt.vmimagesize),
state=None)
else:
start = self.__absolute_time(self.opt.start)
lease = Lease(lease_id=None,
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),
state=None)
lease_xml_str = ET.tostring(lease.to_xml())
server = self.create_rpc_proxy(self.opt.server)
try:
lease_id = server.create_lease(lease_xml_str)
print "Lease submitted correctly."
print "Lease ID: %i" % lease_id
except xmlrpclib.Fault, err:
print >> sys.stderr, "XMLRPC fault: %s" % err.faultString
if self.opt.debug:
raise
def create_lease(self, lease_xml_str):
lease = Lease.from_xml_string(lease_xml_str)
lease.id = get_lease_id()
self.accumulated.append(lease)
return lease.id
def run(self):
self.parse_options()
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:
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) * 100)
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(lease_id = None,
submit_time = None,
requested_resources = requested_resources,
start = Timestamp(Timestamp.NOW),
duration = Duration(duration),
deadline = None,
preemptible=preemptible,
software = DiskImageSoftwareEnvironment(self.opt.vmimage, self.opt.vmimagesize),
state = None
)
elif self.opt.start == haizea_request_lease.START_BESTEFFORT:
lease = Lease(lease_id = None,
submit_time = None,
requested_resources = requested_resources,
start = Timestamp(Timestamp.UNSPECIFIED),
duration = Duration(duration),
deadline = None,
preemptible=preemptible,
software = DiskImageSoftwareEnvironment(self.opt.vmimage, self.opt.vmimagesize),
state = None
)
else:
start = self.__absolute_time(self.opt.start)
lease = Lease(lease_id = None,
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),
state = None
)
lease_xml_str = ET.tostring(lease.to_xml())
server = self.create_rpc_proxy(self.opt.server)
try:
lease_id = server.create_lease(lease_xml_str)
print "Lease submitted correctly."
print "Lease ID: %i" % lease_id
except xmlrpclib.Fault, err:
print >> sys.stderr, "XMLRPC fault: %s" % err.faultString
if self.opt.debug:
raise
