/**
* @param fa
* @return
*/
public static Flow getVmFlowFromFlowAllocation(FlowAllocation fa) {
VirtualMachine vm = (VirtualMachine) fa.getBoughtBy();
for (Commodity c : vm.getCommoditiesBought()) {
if (fa.getKey().equals(c.getKey()) && isInstanceOfFlow(c)) return (Flow) c;
}
return null;
}
private static void setUsedForVpodCommBought() {
for (VPod vpod : rg.getInstances(VPod.class)) {
if (vpod.isIsTemplate()
|| vpod.getParticipatesIn() == null
|| !vpod.getParticipatesIn().isMainMarket()) continue;
float used = 0;
for (Commodity comm : vpod.getCommoditiesBought()) {
if (comm instanceof Flow) continue;
if (!comm.getConsumes().isEmpty()) {
Commodity commSoldByProvider = comm.getConsumes().get(0);
ServiceEntity provider = commSoldByProvider.getSoldBy();
for (ServiceEntity vmtObj : vpod.getUnderlying()) {
if (vmtObj instanceof VirtualMachine) {
VirtualMachine vm = (VirtualMachine) vmtObj;
if (!isVmInDpod(vm, (DPod) provider)) {
continue;
}
float entityCommmodityUsed = 0;
List<Commodity> entityCommodities =
vm.getCommoditiesBoughtByKey(comm.eClass(), CommodityImpl.dynCommKey(vpod));
if (!entityCommodities.isEmpty()) {
entityCommmodityUsed = entityCommodities.get(0).getUsed();
}
used += entityCommmodityUsed;
}
}
comm.setUsed(used);
used = 0;
} else {
logger.warn("The commodity " + comm.getDisplayName() + " is not consuming anything");
}
}
}
}
protected Commodity getCommodityBoughtByKey(
ServiceEntity se, EClass eClass, String key, ServiceEntity provider) {
Commodity commBought = null;
for (Commodity comm : se.getCommoditiesBought()) {
boolean hasSameKey =
(comm.getKey() == null && key == null)
|| (comm.getKey() != null && key != null && comm.getKey().equals(key));
boolean isSameClass = comm.eClass() == eClass;
boolean hasSameProvider =
!comm.getConsumes().isEmpty() && comm.getConsumes().get(0).getSoldBy() == provider;
if (hasSameKey && isSameClass && hasSameProvider) {
commBought = comm;
break;
}
}
return commBought;
}
/**
*
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
*
* @generated NOT
*/
@Override
public EList<HistoricalValues> updateHistoryExtensions(SnapshotCollection snapshotCollection) {
// long start = System.currentTimeMillis();
// String typeName = ((EClass)getSEType()).getName();
EList<HistoricalValues> histValsList = new BasicEList<HistoricalValues>();
RepositoryRegistry rg = RepositoryRegistry.vmtMANAGER;
// long start4 = System.currentTimeMillis();
Set<VMTRootObject> vObj = rg.getInstances(getSEType());
// logger.info("getting SE instances fo SE type "+typeName +" took:
// "+(System.currentTimeMillis()-start4));
EList<EObject> attrList = getAttribute();
EList<ENamedElement> nes = new BasicEList<ENamedElement>();
ServiceEntityHistoryExt histExt;
// long start5 = System.currentTimeMillis();
for (VMTRootObject obj : vObj) {
// long start3 = System.currentTimeMillis();
boolean constraintFailed = false;
ServiceEntity se = (ServiceEntity) obj;
// Check constraints + that the se participates in the main market and not a template
if ((se.getServiceEntityOf() != null)
&& se.getServiceEntityOf().isMainMarket()
&& (se.getTemplateForMarket() == null)) {
for (Constraint constraint : getMatchingCriteria()) {
if (!constraint.match(obj)) {
constraintFailed = true;
break;
}
}
} else {
constraintFailed = true;
}
// and skip if any of the constraints do not match
if (constraintFailed) continue;
histExt =
(ServiceEntityHistoryExt)
se.createExtension(ReportingExtensionsPackage.eINSTANCE.getServiceEntityHistoryExt());
histExt.setSnapshotCollection(snapshotCollection);
if (scLogger.isTraceEnabled())
scLogger.trace(String.format("%s: Updating ServiceEntityHistoryExt", se.toVMTString()));
// Get the attribute value and create/add to the historical values
if (attrList.size() == 1) {
EStructuralFeature attribute = (EStructuralFeature) attrList.get(0);
HistoricalValues vals;
EList<HistoricalValues> valuesList = histExt.getHistoricalValues(attribute.getName());
// if the attribute was not added to the extension yet create it
if (valuesList == null || valuesList.isEmpty()) {
vals = ReportingFactory.eINSTANCE.createHistoricalValues();
vals.initValues(snapshotCollection);
histExt.addHistoricalValues(attribute.getName(), vals);
if (scLogger.isTraceEnabled())
scLogger.trace(
String.format(
"%s: Adding historicalValues for attribute %s",
se.toVMTString(), attribute.getName()));
} else {
// There cannot be more than 1 value for an attribute.
vals = histExt.getHistoricalValues(attribute.getName()).get(0);
}
// Only add a value if the attribute has been set already - otherwise add no value
if (obj.eIsSet(attribute)) {
Object attributeValue = obj.eGet(attribute);
vals.addValue((Float) attributeValue);
histValsList.add(vals);
if (scLogger.isTraceEnabled())
scLogger.trace(
String.format(
"%s: Adding value %f to historicalValues for attribute %s",
se.toVMTString(), attributeValue, attribute.getName()));
} else {
vals.addValue(HistoricalValuesImpl.NO_VALUE);
if (scLogger.isTraceEnabled())
scLogger.trace(
String.format(
"%s: Adding no value to historicalValues for attribute %s",
se.toVMTString(), attribute.getName()));
}
}
// Or get the list of attribute values and create/add to historical values for each
else {
nes.clear();
/* previously we assumed a list of size 3 [reference, commodity, attribute], now we assume
* the last entry is the attribute and the third to last entry is the commodity. */
EStructuralFeature attribute = (EStructuralFeature) attrList.get(attrList.size() - 1);
EReference reference = (EReference) attrList.get(attrList.size() - 3);
// instead of: nes.addAll((Collection<? extends ENamedElement>) attrList.subList(0,
// attrList.size()-1));
for (int i = 0; i < attrList.size() - 1; i++) nes.add((ENamedElement) attrList.get(i));
List<Object> matchedCommodities = obj.getValues(nes);
for (Object commObj : matchedCommodities) {
// long start2 = System.currentTimeMillis();
if (commObj instanceof Commodity) {
Commodity comm = (Commodity) commObj;
// if a history extension already exists use it, otherwise create a new one and
// initialize it.
if (comm.getHistoryExtension() == null) {
CommodityHistoryExt commHistExt =
(CommodityHistoryExt)
comm.createExtension(
ReportingExtensionsPackage.eINSTANCE.getCommodityHistoryExt());
commHistExt.init(snapshotCollection, histExt);
if (scLogger.isTraceEnabled())
scLogger.trace(
String.format(
"%s: Updating CommodityHistoryExt for %s",
se.toVMTString(), comm.toVMTString()));
}
// update the snapshot collection accumulated used values
snapshotCollection.updateOverallCommodityUsage(comm);
try {
// add the value to the historical ext - insert to the proper historical values
HistoricalValues vals =
comm.getHistoryExtension().getFeatureHistory(attribute, reference);
// Only add a value for the attributes that have been set already
if (comm.eIsSet(attribute)) {
vals.addValue((Float) comm.eGet(attribute));
histValsList.add(vals);
if (scLogger.isTraceEnabled())
scLogger.trace(
String.format(
"%s: Adding value %f to historicalValues of commodity %s for attribute %s",
se.toVMTString(),
comm.eGet(attribute),
comm.toVMTString(),
attribute.getName()));
}
// otherwise - set to NO VALUE
else {
vals.addValue(HistoricalValuesImpl.NO_VALUE);
if (scLogger.isTraceEnabled())
scLogger.trace(
String.format(
"%s: Adding no value to historicalValues of commodity %s for attribute %s",
se.toVMTString(), comm.toVMTString(), attribute.getName()));
}
} catch (Exception e) {
logger.error(
"Exception trying to update history extension for "
+ comm.getName()
+ "::"
+ attribute.getName(),
e);
}
} else {
logger.error(
"Missconfigured MetaReacord. Penultimate argument should be a Commodity: "
+ commObj);
}
// logger.info("updating a single commodity for SE type "+typeName +" took:
// "+(System.currentTimeMillis()-start2));
}
}
// logger.info("updating a single entity for SE type "+typeName +" took:
// "+(System.currentTimeMillis()-start3));
}
// logger.info("iterating over all entities of type "+typeName +" took:
// "+(System.currentTimeMillis()-start5));
// logger.info("update history extension for SE type "+typeName +" took:
// "+(System.currentTimeMillis()-start));
return histValsList;
}
/**
*
* <!-- begin-user-doc -->
* This method is used to store daily values of some commodities in db. There are two types of
* values written in this method. One which are rolled up in memory over the course of day and one
* which are directly written to db as no roll up is required.
*
* @param dayChanged boolean to find whether the day has changed from the start
* <!-- end-user-doc -->
* @generated NOT
*/
@Override
public EList<ReportingRecord> getDailyRecordList(boolean dayChanged) {
EList<ReportingRecord> returnList = new BasicEList<ReportingRecord>();
long dailyTimeStamp = 0l;
try {
RepositoryRegistry rg = RepositoryRegistry.vmtMANAGER;
Set<VMTRootObject> vObjList = rg.getInstances(getSEType());
if (dayChanged) {
dailyTimeStamp = System.currentTimeMillis() - (1000 * 60 * 60);
}
for (VMTRootObject vObj : vObjList) {
boolean constraintfailed = false;
// Check constraints
for (Constraint constraint : getMatchingCriteria()) {
if (!constraint.match(vObj)) {
constraintfailed = true;
break;
}
}
// and skip if any of the constraints do not match
if (constraintfailed) continue;
ServiceEntity se = (ServiceEntity) vObj;
if (DeployManager.vmtMANAGER.inDeploy(se)) {
continue;
}
for (NamedElementList neList : getNamedElementList()) {
if (neList.getNamedElement().size() == 1) {
if (dayChanged) {
EStructuralFeature attribute = (EStructuralFeature) neList.getNamedElement().get(0);
// Only create a record if the attribute has been set already
if (vObj.eIsSet(attribute)) {
Object attributeValue = vObj.eGet(attribute);
ReportingRecord record = ReportingFactory.eINSTANCE.createReportingRecord();
// logger.info("comm att " + vObj.getName() + " " + attribute.getName() + " value =
// " + attributeValue);
record.setTimeStamp(dailyTimeStamp);
record.setSeUuId(vObj.getUuid());
record.setPropertyType(attribute.getName());
record.setPropertySubType(attribute.getName());
record.setMinUtilization((Short) attributeValue);
record.setMaxUtilization((Short) attributeValue);
record.setAvgUtilization((Short) attributeValue);
returnList.add(record);
}
}
} else {
// To be supported later : as needed
// EReference reference = (EReference)neList.getNamedElement().get(0);
ENamedElement commodity = neList.getNamedElement().get(1);
EStructuralFeature attribute =
(EStructuralFeature)
neList.getNamedElement().get(neList.getNamedElement().size() - 1);
List<ENamedElement> nesCommodity =
new ArrayList<ENamedElement>(neList.getNamedElement());
nesCommodity.remove(neList.getNamedElement().size() - 1);
List<Object> commodityList = vObj.getValues(nesCommodity);
for (int i = 0; i < commodityList.size(); i++) {
Commodity comm = (Commodity) commodityList.get(i);
// get the attribute value from the commodity if it is set
if (comm.eIsSet(attribute)) {
Object attributeValue = comm.eGet(attribute);
// logger.info("comm att " + comm.getName() + " " + attribute.getName() + " value =
// " + attributeValue);
CommodityReportingExt crExt = null;
for (Extension ext : comm.getExtendedBy()) {
if (ext instanceof CommodityReportingExt) {
crExt = (CommodityReportingExt) ext;
if (crExt.getAttribute() == attribute) {
break;
} else {
crExt = null;
}
}
}
if (crExt == null) {
crExt = ReportingExtensionsFactory.eINSTANCE.createCommodityReportingExt();
crExt.setAttribute(attribute);
comm.getExtendedBy().add(crExt);
}
if (dayChanged) {
// Record Object
ReportingRecord record =
this.createReportingRecord(
crExt, vObj, attribute, commodity, comm, false, dailyTimeStamp);
if (record != null) {
returnList.add(record);
}
crExt.resetValues();
}
// this condition for capacity, used and utilization values
crExt.setMinUtilization(Double.parseDouble(attributeValue.toString()));
if (attribute.equals(AnalysisPackage.eINSTANCE.getCommodity_Used())
&& comm.eIsSet(AnalysisPackage.eINSTANCE.getCommodity_Peak())) {
crExt.setMaxUtilization(comm.getPeak());
} else if (attribute.equals(AnalysisPackage.eINSTANCE.getCommodity_Utilization())
&& comm.eIsSet(AnalysisPackage.eINSTANCE.getCommodity_PeakUtilization())) {
crExt.setMaxUtilization(comm.getPeakUtilization());
} else {
crExt.setMaxUtilization(Double.parseDouble(attributeValue.toString()));
}
crExt.setUtilSum(Double.parseDouble(attributeValue.toString()));
crExt.setCapacity(comm.getCapacity());
// logger.info(vObj.getDisplayName() + " -> comm -> " + commodity.getName() + " min
// = " + crExt.getMinUtilization() + " max = " + crExt.getMaxUtilization() + " sum =
// " + crExt.getUtilSum() + " cap = " + crExt.getCapacity());
}
}
}
}
}
} catch (Exception e) {
logger.error("Exception in MetaRecordImpl.getDailyRecordList() ", e);
}
return returnList;
}
/**
*
* <!-- begin-user-doc -->
* This method goes over a provided SEType (config file) entities with matching criteria defined
* in config file. It goes over the attributes required to report on and collects min,max and avg
* into extension objects for commodity and service entity.
*
* <p>Every hour it creates a list of {@link ReportingRecord} objects with data and returns this
* list.
* <!-- end-user-doc -->
*
* @param hourChanged true if the hour changed from the previous gathering of values.
* @generated NOT
*/
@Override
public EList<ReportingRecord> getReportingRecordList(boolean hourChanged) {
EList<ReportingRecord> returnList = new BasicEList<ReportingRecord>();
long hourlyTimeStamp = 0l;
try {
RepositoryRegistry rg = RepositoryRegistry.vmtMANAGER;
Set<VMTRootObject> vObjList = rg.getInstances(getSEType());
if (hourChanged) {
hourlyTimeStamp =
(System.currentTimeMillis()
- (1000 * 60 * 30)); // Give the record TS of the middle of the last hour
}
for (VMTRootObject vObj : vObjList) {
boolean constraintfailed = false;
// Check constraints
for (Constraint constraint : getMatchingCriteria()) {
if (!constraint.match(vObj)) {
constraintfailed = true;
break;
}
}
// and skip if any of the constraints do not match
if (constraintfailed) {
continue;
}
ServiceEntity se = (ServiceEntity) vObj;
if (DeployManager.vmtMANAGER.inDeploy(se)) {
continue;
}
// Get the Extension for ServiceEntity
ServiceEntityReportingExt seExt =
(ServiceEntityReportingExt)
se.findExtension(
ReportingExtensionsPackage.eINSTANCE.getServiceEntityReportingExt());
if (seExt == null) {
seExt = ReportingExtensionsFactory.eINSTANCE.createServiceEntityReportingExt();
se.getExtendedBy().add(seExt);
}
for (NamedElementList neList : getNamedElementList()) {
if (neList.getNamedElement().size() == 1) {
EStructuralFeature attribute = (EStructuralFeature) neList.getNamedElement().get(0);
// Only create a record if the attribute has been set already
if (vObj.eIsSet(attribute)) {
Object attributeValue = vObj.eGet(attribute);
if (attributeValue instanceof List<?>) {
if (hourChanged) {
// Record Object
ReportingRecord record =
this.createReportingRecord(
seExt, vObj, attribute, null, null, true, hourlyTimeStamp);
if (record != null) {
returnList.add(record);
}
// reset only numProduces fields
seExt.resetValues(attribute);
}
// this condition for numProduces value
seExt.setMinNumProduces(((List<?>) attributeValue).size());
seExt.setMaxNumProduces(((List<?>) attributeValue).size());
seExt.setProducesSum(((List<?>) attributeValue).size());
// if(logger.isDebugEnabled())logger.debug("numProduces : min = " +
// seExt.getMinNumProduces() + " max = " + seExt.getMaxNumProduces() + " sum = " +
// seExt.getProducesSum());
} else {
double val = Double.parseDouble(attributeValue.toString());
if (val > PRICE_THRESHOLD) {
val = PRICE_THRESHOLD;
}
if (attribute == AnalysisPackage.eINSTANCE.getServiceEntity_PriceIndex()) {
if (val < 0) {
if (logger.isDebugEnabled()) {
logger.error(
"SE : " + vObj.toVMTString() + " has a negative value of " + val);
for (StackTraceElement element : Thread.currentThread().getStackTrace()) {
logger.debug(element.toString());
}
}
continue;
}
}
List<EAttribute> atts = seExt.getExtAttributes(attribute);
for (EAttribute att : atts) {
seExt.eSet(att, val);
}
if (hourChanged) {
// Record Object
ReportingRecord record =
this.createReportingRecord(
seExt, vObj, attribute, null, null, false, hourlyTimeStamp);
if (record != null) {
returnList.add(record);
}
// reset only UtilIndex fields
seExt.resetValues(attribute);
}
}
}
// Or get the list of attribute values and create a record for each
} else {
EReference reference = (EReference) neList.getNamedElement().get(0);
ENamedElement commodity = neList.getNamedElement().get(1);
EStructuralFeature attribute =
(EStructuralFeature)
neList.getNamedElement().get(neList.getNamedElement().size() - 1);
List<ENamedElement> nesCommodity =
new ArrayList<ENamedElement>(neList.getNamedElement());
nesCommodity.remove(neList.getNamedElement().size() - 1);
List<Object> commodityList = vObj.getValues(nesCommodity);
for (int i = 0; i < commodityList.size(); i++) {
Commodity comm = (Commodity) commodityList.get(i);
// get the attribute value from the commodity if it is set
if (comm.eIsSet(attribute)) {
Object attributeValue = comm.eGet(attribute);
// logger.info("comm att " + comm.getName() + " " + attribute.getName() + " value =
// " + attributeValue);
CommodityReportingExt crExt = null;
for (Extension ext : comm.getExtendedBy()) {
if (ext instanceof CommodityReportingExt) {
crExt = (CommodityReportingExt) ext;
if (crExt.getAttribute() == attribute) {
break;
} else {
crExt = null;
}
}
}
if (crExt == null) {
crExt = ReportingExtensionsFactory.eINSTANCE.createCommodityReportingExt();
crExt.setAttribute(attribute);
comm.getExtendedBy().add(crExt);
}
if (hourChanged) {
// Record Object
ReportingRecord record =
this.createReportingRecord(
crExt, vObj, attribute, commodity, comm, false, hourlyTimeStamp);
if (record != null) {
returnList.add(record);
}
crExt.resetValues();
}
// this condition for capacity, used and utilization values
crExt.setMinUtilization(Double.parseDouble(attributeValue.toString()));
if (attribute.equals(AnalysisPackage.eINSTANCE.getCommodity_Used())
&& comm.eIsSet(AnalysisPackage.eINSTANCE.getCommodity_Peak())) {
crExt.setMaxUtilization(comm.getPeak());
} else if (attribute.equals(AnalysisPackage.eINSTANCE.getCommodity_Utilization())
&& comm.eIsSet(AnalysisPackage.eINSTANCE.getCommodity_PeakUtilization())) {
crExt.setMaxUtilization(comm.getPeakUtilization());
} else {
crExt.setMaxUtilization(Double.parseDouble(attributeValue.toString()));
}
crExt.setUtilSum(Double.parseDouble(attributeValue.toString()));
float capacity = comm.getCapacity();
if (capacity > CAPACITY_THRESHOLD) {
if (logger.isDebugEnabled()) {
logger.debug(
"Capacity for "
+ se.getDisplayName()
+ "::"
+ comm.getDisplayName()
+ " is "
+ capacity
+ ". Capping it to "
+ CAPACITY_THRESHOLD);
}
capacity = CAPACITY_THRESHOLD;
}
crExt.setCapacity(capacity);
crExt.setRelation(
RelationType.valueOf(reference.getName().toUpperCase()).getValue());
crExt.setCommodityKey(comm.getKey());
// if(logger.isDebugEnabled())logger.debug("comm -> " + attribute.getName() + " min
// = " + crExt.getMinUtilization() + " max = " + crExt.getMaxUtilization() + " sum =
// " + crExt.getUtilSum() + " cap = " + crExt.getCapacity());
}
}
}
}
}
} catch (Exception e) {
logger.error("Exception in MetaRecordImpl.getReportingRecordList()", e);
}
return returnList;
}
/**
* This method creates a {@link ReportingRecord} object with values from commodity , service
* entity and attribute provided to it every hour.
*
* @param reportingExtension Extension object
* @param vObj ServiceEntity object
* @param attribute attribute reported on
* @param commodityName Commodity named element
* @param commodity {@link Commodity} object to get provider uuid
* @param isNumProduces whether reporting on numProduces attribute
* @return {@link ReportingRecord} object
*/
private ReportingRecord createReportingRecord(
ReportingExtension reportingExtension,
VMTRootObject vObj,
EStructuralFeature attribute,
ENamedElement commodityName,
Commodity commodity,
boolean isNumProduces,
long snapshotTime) {
ReportingRecord record = ReportingFactory.eINSTANCE.createReportingRecord();
try {
// long snapshotTime = (System.currentTimeMillis() - (1000*60*60));
if (reportingExtension.eClass()
== ReportingExtensionsPackage.eINSTANCE.getCommodityReportingExt()) {
CommodityReportingExt crExt = (CommodityReportingExt) reportingExtension;
if (crExt.getMinUtilization() == -1d || crExt.getMaxUtilization() == -1d) {
return null;
}
record.setTimeStamp(snapshotTime);
record.setSeUuId(vObj.getUuid());
record.setPropertyType(commodityName.getName());
record.setPropertySubType(attribute.getName());
record.setMinUtilization(crExt.getMinUtilization());
record.setMaxUtilization(crExt.getMaxUtilization());
record.setAvgUtilization(crExt.getAvgUtilization());
record.setCapacity(crExt.getCapacity());
record.setRelation(crExt.getRelation());
if (crExt.getCommodityKey() != null) {
String commodityKey = truncateString(crExt.getCommodityKey(), 80);
record.setCommodityKey(commodityKey);
}
if (!commodity.getConsumes().isEmpty()
&& commodity.getConsumes().get(0).getSoldBy() != null) {
record.setProviderUuId(commodity.getConsumes().get(0).getSoldBy().getUuid());
}
// record.setStdDev(0);
} else if (reportingExtension.eClass()
== ReportingExtensionsPackage.eINSTANCE.getServiceEntityReportingExt()) {
ServiceEntityReportingExt seExt = (ServiceEntityReportingExt) reportingExtension;
if (isNumProduces) {
if (seExt.getMinNumProduces() == -1 || seExt.getMaxNumProduces() == -1) {
return null;
}
record.setTimeStamp(snapshotTime);
record.setSeUuId(vObj.getUuid());
record.setPropertyType(attribute.getName());
record.setPropertySubType(attribute.getName());
record.setMinUtilization(seExt.getMinNumProduces());
record.setMaxUtilization(seExt.getMaxNumProduces());
record.setAvgUtilization(seExt.getAvgProduces());
record.setRelation(-1);
record.setCommodityKey(null);
// record.setStdDev(0);
} else {
if (seExt.getMinPropValue() == -1d || seExt.getMaxPropValue() == -1d) {
return null;
}
if (attribute == AnalysisPackage.eINSTANCE.getServiceEntity_PriceIndex()) {
if ((seExt.getMinPropValue() < 0)
|| (seExt.getMaxPropValue() < 0)
|| (seExt.getAvgPropValue() < 0)) {
if (logger.isDebugEnabled()) {
logger.error(
"SE : "
+ vObj.toVMTString()
+ " has max, min and avg PriceIndex values of "
+ seExt.getMaxPropValue()
+ ", "
+ seExt.getMinPropValue()
+ " and "
+ seExt.getAvgPropValue()
+ " respectively");
}
return null;
}
}
record.setTimeStamp(snapshotTime);
record.setSeUuId(vObj.getUuid());
record.setPropertyType(attribute.getName());
record.setPropertySubType(attribute.getName());
record.setRelation(-1);
record.setCommodityKey(null);
record.setMinUtilization(seExt.getMinPropValue());
record.setMaxUtilization(seExt.getMaxPropValue());
record.setAvgUtilization(seExt.getAvgPropValue());
}
}
} catch (Exception e) {
logger.error("Exception in creating record ", e);
}
return record;
}
/**
* Create a DPod object layered over the given list of entities.
*
* @param seList A list of entities layered over the DPod
* @param scName The name of the Storage Controller that defined this DPod
* @return The DPod created
*/
public static DPod createDPod(
DPod dPod,
final Set<ServiceEntity> seList,
HistoryUtil historyLayeredOver,
HistoryUtil historyUnderlying) {
// Need a naming method for DPod
dPod.setDisplayName(dPod.getName());
// Create all the relationships between the providers and the dPod
Map<String, Float> key2flowCap = new HashMap<String, Float>();
key2flowCap.put(PodUtil.FLOW_KEYS[1], 0f);
key2flowCap.put(PodUtil.FLOW_KEYS[2], 0f);
float cpuCap = 0f, memCap = 0f, stCap = 0f;
for (ServiceEntity se : seList) {
attachDPodToProvider(se, dPod, historyLayeredOver);
// calculate the sum of the capacities for each type of commodity
for (Commodity comm : se.getCommodities()) {
if (comm.eClass() == AbstractionPackage.eINSTANCE.getFlow()) {
if (comm.getKey().contains(PodUtil.FLOW_KEYS[1])) {
key2flowCap.put(
PodUtil.FLOW_KEYS[1], key2flowCap.get(PodUtil.FLOW_KEYS[1]) + comm.getCapacity());
logger.trace(
"Flow-1 Commodity: "
+ comm.getDisplayName()
+ " has capacity "
+ comm.getCapacity());
logger.trace(
"Flow-1 capacity (after addition): " + key2flowCap.get(PodUtil.FLOW_KEYS[1]));
} else if (comm.getKey().contains(PodUtil.FLOW_KEYS[2])) {
key2flowCap.put(
PodUtil.FLOW_KEYS[2], key2flowCap.get(PodUtil.FLOW_KEYS[2]) + comm.getCapacity());
logger.trace("Flow-2 Commodity has capacity " + comm.getCapacity());
logger.trace(
"Flow-2 capacity (after addition): " + key2flowCap.get(PodUtil.FLOW_KEYS[2]));
}
} else if (comm.eClass() == AbstractionPackage.eINSTANCE.getCPU()) {
cpuCap += comm.getCapacity();
} else if (comm.eClass() == AbstractionPackage.eINSTANCE.getMem()) {
memCap += comm.getCapacity();
} else if (comm.eClass() == AbstractionPackage.eINSTANCE.getStorageAmount()) {
stCap += comm.getCapacity();
}
}
}
// Create commodities sold by the DPod
// The capacity of the commodities is equal to the sum of the capacities on all underlying
// entities
StorageAllocation stAlloc =
(StorageAllocation)
createObject(
AbstractionPackage.eINSTANCE.getStorageAllocation(), "ST-" + dPod.getName());
stAlloc.setCapacity(stCap);
stAlloc.setKey(CommodityImpl.dynCommKey(dPod));
stAlloc.setResizeable(false);
dPod.getCommodities().add(stAlloc);
CPUAllocation cpuAlloc =
(CPUAllocation)
createObject(AbstractionPackage.eINSTANCE.getCPUAllocation(), "CPU-" + dPod.getName());
cpuAlloc.setCapacity(cpuCap);
cpuAlloc.setKey(CommodityImpl.dynCommKey(dPod));
cpuAlloc.setResizeable(false);
dPod.getCommodities().add(cpuAlloc);
MemAllocation memAlloc =
(MemAllocation)
createObject(AbstractionPackage.eINSTANCE.getMemAllocation(), "MEM-" + dPod.getName());
memAlloc.setCapacity(memCap);
memAlloc.setKey(CommodityImpl.dynCommKey(dPod));
memAlloc.setResizeable(false);
dPod.getCommodities().add(memAlloc);
for (int level = 1; level < PodUtil.FLOW_KEYS.length; level++) {
FlowAllocation flowAlloc =
(FlowAllocation)
createObject(
AbstractionPackage.eINSTANCE.getFlowAllocation(),
"FlowAllocation-" + level + "-" + dPod.getName());
logger.info(
"Flow-" + level + " Allocation capacity " + key2flowCap.get(PodUtil.FLOW_KEYS[level]));
if (key2flowCap.get(PodUtil.FLOW_KEYS[level]) >= 9e14) {
logger.trace("Flow-" + level + " Allocation capacity is too high.");
logger.trace(
"Flow-"
+ level
+ " Allocation Capacity is "
+ key2flowCap.get(PodUtil.FLOW_KEYS[level]));
}
flowAlloc.setCapacity(key2flowCap.get(PodUtil.FLOW_KEYS[level]));
flowAlloc.setKey(PodUtil.getFlowKey(CommodityImpl.dynCommKey(dPod), level));
flowAlloc.setResizeable(false);
dPod.getCommodities().add(flowAlloc);
}
return dPod;
}
/**
* Creates all the necessary commodities and relationships between a provider and the DPod layered
* over it.
*
* @param provider The provider (Physical Machine or Storage)
* @param dPod The DPod
* @param historyLayeredOver
*/
public static void attachDPodToProvider(
final ServiceEntity provider, final DPod dPod, final HistoryUtil historyLayeredOver) {
String providerName = provider.getName();
String commKey = providerName + ":" + dPod.getName();
if (provider instanceof PhysicalMachine) {
// Create dPod commodities bought and commodities sold from the provider to the DPod
CPUAllocation cpuAllocBought =
(CPUAllocation)
dPod.buyDynamicCommodity(AbstractionPackage.eINSTANCE.getCPUAllocation(), commKey, 0);
cpuAllocBought.setName(
commKey + ":" + AbstractionPackage.eINSTANCE.getCPUAllocation().getName() + "Bought");
cpuAllocBought.setResizeable(false);
dPod.getCommoditiesBought().add(cpuAllocBought);
Commodity cpuAlloc =
provider.sellDynamicCommodity(
AbstractionPackage.eINSTANCE.getCPUAllocation(), commKey, 0, null);
provider.getCommodities().add(cpuAlloc);
cpuAllocBought.getConsumes().clear();
cpuAllocBought.getConsumes().add(cpuAlloc);
MemAllocation memAllocBought =
(MemAllocation)
dPod.buyDynamicCommodity(AbstractionPackage.eINSTANCE.getMemAllocation(), commKey, 0);
memAllocBought.setName(
commKey + ":" + AbstractionPackage.eINSTANCE.getMemAllocation().getName() + "Bought");
memAllocBought.setResizeable(false);
dPod.getCommoditiesBought().add(memAllocBought);
Commodity memAlloc =
provider.sellDynamicCommodity(
AbstractionPackage.eINSTANCE.getMemAllocation(), commKey, 0, null);
provider.getCommodities().add(memAlloc);
memAllocBought.getConsumes().clear();
memAllocBought.getConsumes().add(memAlloc);
Map<String, Commodity> key2FlowAlloc = new HashMap<>();
for (int level = 1; level < PodUtil.FLOW_KEYS.length; level++) {
String commFlowKey = PodUtil.getFlowKey(commKey, level);
FlowAllocation flowAllocBought =
(FlowAllocation)
dPod.buyDynamicCommodity(
AbstractionPackage.eINSTANCE.getFlowAllocation(), commFlowKey, 0);
flowAllocBought.setName(
commFlowKey
+ ":"
+ AbstractionPackage.eINSTANCE.getFlowAllocation().getName()
+ "Bought");
flowAllocBought.setResizeable(false);
dPod.getCommoditiesBought().add(flowAllocBought);
Commodity flowAlloc =
provider.sellDynamicCommodity(
AbstractionPackage.eINSTANCE.getFlowAllocation(), commFlowKey, 0, null);
provider.getCommodities().add(flowAlloc);
flowAllocBought.getConsumes().clear();
flowAllocBought.getConsumes().add(flowAlloc);
key2FlowAlloc.put(PodUtil.FLOW_KEYS[level], flowAlloc);
}
// set the capacity of the provider sold allocation commodities to match the capacity
// of the regular commodities
for (Commodity comm : provider.getCommodities()) {
if (comm.eClass() == AbstractionPackage.eINSTANCE.getMem())
memAlloc.setCapacity(comm.getCapacity());
else if (comm.eClass() == AbstractionPackage.eINSTANCE.getCPU())
cpuAlloc.setCapacity(comm.getCapacity());
else if (comm.eClass()
== AbstractionPackage.eINSTANCE.getFlow()) { // update the alloc comm for the same level
if (key2FlowAlloc.containsKey(comm.getKey()))
logger.trace(
"The Dpod "
+ dPod.getName()
+ "Flow-"
+ comm.getKey()
+ " capacity is "
+ key2FlowAlloc.get(comm.getKey()).getCapacity());
logger.trace(
"The Provider "
+ provider.getName()
+ "Flow-"
+ comm.getKey()
+ "capacity is "
+ comm.getCapacity());
if (key2FlowAlloc.get(comm.getKey()) != null)
key2FlowAlloc.get(comm.getKey()).setCapacity(comm.getCapacity());
}
}
} else if (provider instanceof Storage) {
StorageAllocation stAllocBought =
(StorageAllocation)
dPod.buyDynamicCommodity(
AbstractionPackage.eINSTANCE.getStorageAllocation(), commKey, 0);
stAllocBought.setName(
commKey + ":" + AbstractionPackage.eINSTANCE.getStorageAllocation().getName() + "Bought");
stAllocBought.setResizeable(false);
dPod.getCommoditiesBought().add(stAllocBought);
Commodity stAlloc =
provider.sellDynamicCommodity(
AbstractionPackage.eINSTANCE.getStorageAllocation(), commKey, 0, null);
provider.getCommodities().add(stAlloc);
stAllocBought.getConsumes().clear();
stAllocBought.getConsumes().add(stAlloc);
for (Commodity comm : provider.getCommodities()) {
if (comm.eClass() == AbstractionPackage.eINSTANCE.getStorageAmount())
stAlloc.setCapacity(comm.getCapacity());
}
}
dPod.getLayeredOver().add(provider);
historyLayeredOver.remove(provider);
}
public static <M extends VMTRootObject> void setUsedForPod(
@Nonnull Class<M> cls,
EReference classCommRef,
EReference pod2EntityRef,
EReference entityCommRef) {
@SuppressWarnings("unchecked")
Iterable<ServiceEntity> ses = (Iterable<ServiceEntity>) rg.getInstances(cls);
for (ServiceEntity se : ses) {
if (se.isIsTemplate()
|| se.getParticipatesIn() == null
|| !se.getParticipatesIn().isMainMarket()) continue;
float cpuUsed = 0f, memUsed = 0f, stAmount = 0f, flow1Used = 0f, flow2Used = 0f;
for (VMTRootObject vmtObj :
se.getRef(pod2EntityRef, AnalysisPackage.eINSTANCE.getServiceEntity())) {
for (VMTRootObject commObj :
vmtObj.getRef(entityCommRef, AnalysisPackage.eINSTANCE.getCommodity())) {
Commodity comm = (Commodity) commObj;
if (comm instanceof CPU) cpuUsed += comm.getUsed();
else if (comm instanceof Mem) memUsed += comm.getUsed();
else if (comm instanceof StorageAmount) stAmount += comm.getUsed();
else if (comm instanceof Flow) {
if (comm.getKey().contains(PodUtil.FLOW_KEYS[1])) flow1Used += comm.getUsed();
else if (comm.getKey().contains(PodUtil.FLOW_KEYS[2])) flow2Used += comm.getUsed();
}
}
}
CPUAllocation cpuAllocation =
(CPUAllocation)
se.getRef(classCommRef, AbstractionPackage.eINSTANCE.getCPUAllocation()).get(0);
MemAllocation memAllocation =
(MemAllocation)
se.getRef(classCommRef, AbstractionPackage.eINSTANCE.getMemAllocation()).get(0);
List<VMTRootObject> flowAllocation =
se.getRef(classCommRef, AbstractionPackage.eINSTANCE.getFlowAllocation());
cpuAllocation.setUsed(cpuUsed);
memAllocation.setUsed(memUsed);
if (se.getRef(classCommRef, AbstractionPackage.eINSTANCE.getStorageAllocation()).size() > 0) {
StorageAllocation stAllocation =
(StorageAllocation)
se.getRef(classCommRef, AbstractionPackage.eINSTANCE.getStorageAllocation()).get(0);
stAllocation.setUsed(stAmount);
}
for (VMTRootObject flowAllocObj : flowAllocation) {
Commodity flowComm = (Commodity) flowAllocObj;
if (flowComm.getKey().contains(PodUtil.FLOW_KEYS[1])) flowComm.setUsed(flow1Used);
else if (flowComm.getKey().contains(PodUtil.FLOW_KEYS[2])) flowComm.setUsed(flow2Used);
}
}
}
private static void setUsedForDpodCommBought() {
for (DPod se : rg.getInstances(DPod.class)) {
if (se.isIsTemplate()
|| se.getParticipatesIn() == null
|| !se.getParticipatesIn().isMainMarket()) continue;
float used = 0;
for (Commodity comm : se.getCommoditiesBought()) {
if (!comm.getConsumes().isEmpty()) {
Commodity commSoldByProvider = comm.getConsumes().get(0);
ServiceEntity provider = commSoldByProvider.getSoldBy();
for (VMTRootObject vmtObj :
provider.getRef(
getRelatedEntitiesRef(provider), AnalysisPackage.eINSTANCE.getServiceEntity())) {
if (vmtObj instanceof VirtualMachine) {
VirtualMachine vm = (VirtualMachine) vmtObj;
float entityCommmodityUsed = 0;
for (Commodity entityCommodity : vm.getCommoditiesBought()) {
if (entityCommodity.eClass() == commAllocation2CommMap.get(comm.eClass())) {
if (entityCommodity.getKey() != null
&& !comm.getKey().contains(entityCommodity.getKey())) continue;
entityCommmodityUsed = entityCommodity.getUsed();
break;
}
}
used += entityCommmodityUsed;
}
}
comm.setUsed(used);
used = 0;
} else {
logger.warn("The commodity " + comm.getDisplayName() + " is not consuming anything");
}
}
}
}
protected void sellDynamicCommodityPost(Commodity comm, ServiceEntity target) {
comm.setAccesses(target);
}
