/** * Build a Map between VO name and a collection of reservation summary information. This * collection of reservation summary information is itself a Map between the reservation * description and a summary of all reservations with that same description. Those reservations * without a description are ignored. * * @param reservations a Map between reservation ID and a corresponding ReservationInfo object * describing that reservation. * @return a Map of VO to reservation-description summaries. */ private Map<String, Map<String, ReservationSummaryInfo>> buildSummaryInfo( Map<String, ReservationInfo> reservations) { Map<String, Map<String, ReservationSummaryInfo>> summary = new HashMap<>(); for (Map.Entry<String, ReservationInfo> entry : reservations.entrySet()) { String reservationId = entry.getKey(); ReservationInfo info = entry.getValue(); /* * Ignore those reservations that don't have a state or that * state is a final one */ if (!info.hasState() || info.getState().isFinalState()) { _log.debug("ignoring reservation " + reservationId + " as state is undefined or final"); continue; } /* Skip those reservations that don't have a description */ if (!info.hasDescription() || info.getDescription().isEmpty()) { _log.debug( "ignoring reservation " + reservationId + " as description is undefined or empty"); continue; } /* Skip all those reservations that don't have a well-defined VO */ if (!info.hasVo() || info.getVo().isEmpty()) { _log.debug("ignoring reservation " + reservationId + " as VO is undefined or empty"); continue; } String voName = info.getVo(); ReservationSummaryInfo thisSummary; Map<String, ReservationSummaryInfo> thisVoSummary; thisVoSummary = summary.get(voName); if (thisVoSummary == null) { thisVoSummary = new HashMap<>(); summary.put(voName, thisVoSummary); } thisSummary = thisVoSummary.get(info.getDescription()); if (thisSummary == null) { thisSummary = new ReservationSummaryInfo(); thisVoSummary.put(info.getDescription(), thisSummary); } // update summary with this reservation. thisSummary.addReservationInfo(reservationId, info); } return summary; }
/** * Update the provided StateUpdate object so that later processing this StateUpdate will alter * dCache state such that it reflects the information held in this object. * * @param update the StateUpdate to use * @param voName the name of the VO * @param basePath the StatePath under which metrics will be added * @param oldInfo the previous ReservationSummaryInfo or null if this description is new. */ public void updateMetrics( StateUpdate update, String voName, StatePath basePath, ReservationSummaryInfo oldInfo) { StatePath spacePath = basePath.newChild(PATH_ELEMENT_SPACE_BRANCH); if (totalNeedsUpdating(oldInfo)) { update.appendUpdate( spacePath.newChild(PATH_ELEMENT_TOTAL_METRIC), new IntegerStateValue(getTotal(), true)); } if (freeNeedsUpdating(oldInfo)) { update.appendUpdate( spacePath.newChild(PATH_ELEMENT_FREE_METRIC), new IntegerStateValue(getFree(), true)); } if (allocatedNeedsUpdating(oldInfo)) { update.appendUpdate( spacePath.newChild(PATH_ELEMENT_ALLOCATED_METRIC), new IntegerStateValue(getAllocated(), true)); } if (usedNeedsUpdating(oldInfo)) { update.appendUpdate( spacePath.newChild(PATH_ELEMENT_USED_METRIC), new IntegerStateValue(getUsed(), true)); } StatePath resvPath = basePath.newChild(PATH_ELEMENT_RESERVATIONS_BRANCH); /* Activity if there was an existing summary information */ if (oldInfo != null) { oldInfo.purgeMissingIds(update, resvPath, this); /* Add those entries that are new */ for (String newId : _ids) { if (!oldInfo.hasId(newId)) { update.appendUpdate(resvPath.newChild(newId), new StateComposite(true)); } } } else { /* Add the VO name (we need to this only once) */ update.appendUpdate( basePath.newChild(PATH_ELEMENT_VO_NAME_METRIC), new StringStateValue(voName, true)); /* Add all IDs */ for (String id : _ids) { update.appendUpdate(resvPath.newChild(id), new StateComposite(true)); } } }
/** * Purge all IDs that are not present in this ReservationSummaryInfo but are missing from a new * version of ReservationSummaryInfo * * @param update the StateUpdate to add adjust. * @param basePath the base path of the IDs * @param newInfo the new version of this ReservationSummaryInfo */ public void purgeMissingIds( StateUpdate update, StatePath basePath, ReservationSummaryInfo newInfo) { for (String id : _ids) { if (!newInfo.hasId(id)) { update.purgeUnder(basePath.newChild(id)); } } }
/** * Add metrics that update dCache state to reflect the changes. We assume those elements that * should be removed have been purged * * @param update * @param currentSummary * @param futureSummary */ private void addMetrics( StateUpdate update, Map<String, Map<String, ReservationSummaryInfo>> currentSummary, Map<String, Map<String, ReservationSummaryInfo>> futureSummary) { for (Map.Entry<String, Map<String, ReservationSummaryInfo>> voEntry : futureSummary.entrySet()) { String voName = voEntry.getKey(); if (_log.isDebugEnabled()) { _log.debug("Checking vo " + voName); } Map<String, ReservationSummaryInfo> futureDescriptions = voEntry.getValue(); Map<String, ReservationSummaryInfo> currentDescriptions = currentSummary.get(voName); StatePath voPath = buildVoPath(voName); /* Scan through descriptions after transition is applied */ for (Map.Entry<String, ReservationSummaryInfo> entry : futureDescriptions.entrySet()) { String description = entry.getKey(); ReservationSummaryInfo futureInfo = entry.getValue(); /* * Try to establish the corresponding current * ReservationSummaryInfo for this description */ ReservationSummaryInfo currentInfo = currentDescriptions != null ? currentDescriptions.get(description) : null; if (!futureInfo.equals(currentInfo)) { futureInfo.updateMetrics( update, voName, buildDescriptionPath(voPath, description), currentInfo); } } } }
public boolean allocatedNeedsUpdating(ReservationSummaryInfo oldInfo) { return oldInfo == null || oldInfo.getAllocated() != getAllocated(); }
public boolean freeNeedsUpdating(ReservationSummaryInfo oldInfo) { return oldInfo == null || oldInfo.getFree() != getFree(); }
public boolean totalNeedsUpdating(ReservationSummaryInfo oldInfo) { return oldInfo == null || oldInfo.getTotal() != getTotal(); }