/**
* Tries to create a new slice on this instance.
*
* @param reqType the type describing the hardware characteristics of the slice
* @param jobID the ID of the job the new slice belongs to
* @return a new {@AllocatedSlice} object if a slice with the given hardware characteristics could
* still be accommodated on this instance or <code>null</code> if the instance's remaining
* resources were insufficient to host the desired slice
*/
synchronized AllocatedSlice createSlice(final InstanceType reqType, final JobID jobID) {
// check whether we can accommodate the instance
if (remainingCapacity.getNumberOfComputeUnits() >= reqType.getNumberOfComputeUnits()
&& remainingCapacity.getNumberOfCores() >= reqType.getNumberOfCores()
&& remainingCapacity.getMemorySize() >= reqType.getMemorySize()
&& remainingCapacity.getDiskCapacity() >= reqType.getDiskCapacity()) {
// reduce available capacity by what has been requested
remainingCapacity =
InstanceTypeFactory.construct(
remainingCapacity.getIdentifier(),
remainingCapacity.getNumberOfComputeUnits() - reqType.getNumberOfComputeUnits(),
remainingCapacity.getNumberOfCores() - reqType.getNumberOfCores(),
remainingCapacity.getMemorySize() - reqType.getMemorySize(),
remainingCapacity.getDiskCapacity() - reqType.getDiskCapacity(),
remainingCapacity.getPricePerHour());
final long allocationTime = System.currentTimeMillis();
final AllocatedSlice slice = new AllocatedSlice(this, reqType, jobID, allocationTime);
this.allocatedSlices.put(slice.getAllocationID(), slice);
return slice;
}
// we cannot accommodate the instance
return null;
}
/**
* Reads the instance types configured in the config file. Each instance type is defined by a
* key/value pair. The format of the key is <code>instancemanager.cluster.type.X</code> where X is
* an ongoing integer number starting at 1. The format of the value follows the pattern
* "instancename,numComputeUnits,numCores,memorySize,diskCapacity,pricePerHour" (see {@link
* InstanceType}).
*
* @return list of available instance types sorted by price (cheapest to most expensive)
*/
private InstanceType[] populateInstanceTypeArray() {
final List<InstanceType> instanceTypes = new ArrayList<InstanceType>();
// read instance types
int count = 1;
while (true) {
final String key = INSTANCE_TYPE_PREFIX_KEY + Integer.toString(count);
String descr = GlobalConfiguration.getString(key, null);
if (descr == null) {
if (count == 1) {
LOG.info(
"Configuration does not contain at least one definition for an instance type, "
+ "using default instance type: "
+ ConfigConstants.DEFAULT_INSTANCE_TYPE);
descr = ConfigConstants.DEFAULT_INSTANCE_TYPE;
} else {
break;
}
}
// parse entry
try {
// if successful add new instance type
final InstanceType instanceType = InstanceTypeFactory.constructFromDescription(descr);
LOG.info(
"Loaded instance type " + instanceType.getIdentifier() + " from the configuration");
instanceTypes.add(instanceType);
} catch (Throwable t) {
LOG.error(
"Error parsing "
+ key
+ ":"
+ descr
+ ". Using default using default instance type: "
+ ConfigConstants.DEFAULT_INSTANCE_TYPE
+ " for instance type "
+ count
+ ".",
t);
break;
}
// Increase key index
++count;
}
return instanceTypes.toArray(new InstanceType[instanceTypes.size()]);
}
/**
* Removes the slice identified by the given allocation ID from this instance and frees up the
* allocated resources.
*
* @param allocationID the allocation ID of the slice to be removed
* @return the slice with has been removed from the instance or <code>null</code> if no slice with
* the given allocation ID could be found
*/
synchronized AllocatedSlice removeAllocatedSlice(final AllocationID allocationID) {
final AllocatedSlice slice = this.allocatedSlices.remove(allocationID);
if (slice != null) {
this.remainingCapacity =
InstanceTypeFactory.construct(
this.remainingCapacity.getIdentifier(),
this.remainingCapacity.getNumberOfComputeUnits()
+ slice.getType().getNumberOfComputeUnits(),
this.remainingCapacity.getNumberOfCores() + slice.getType().getNumberOfCores(),
this.remainingCapacity.getMemorySize() + slice.getType().getMemorySize(),
this.remainingCapacity.getDiskCapacity() + slice.getType().getDiskCapacity(),
this.remainingCapacity.getPricePerHour());
}
return slice;
}