monitormanager.java

JXTA&#8482 is a set of open, generalized peer-to-peer (P2P) protocols that allow any networked devi

        }    // nothing changed

        long now = System.currentTimeMillis();

        if (oldPulseRateIndex == NOT_PULSING) { // case 1: No pulse to pulse
            for (int i = 0; i < filtersPerRate.length; i++) {
                if (filtersPerRate[i] != 0) {
                    previousReportTimes[i] = now;
                } else {
                    previousReportTimes[i] = NO_PRIOR_REPORT;
                }
            }

            pulseNumber = 0;
            nextPulseTime = now + pulseRate;
        } else if (pulseRateIndex == NOT_PULSING) {// case 2: pulse to No pulse
            // Do nothing
        } else if (pulseRateIndex < oldPulseRateIndex) { // case 3: pulse going to a faster pulse
            for (int i = pulseRateIndex; i < (oldPulseRateIndex - 1); i++) {
                if (filtersPerRate[i] != 0) {
                    previousReportTimes[i] = now;
                } else {
                    previousReportTimes[i] = NO_PRIOR_REPORT;
                }
            }

            long timeToNextPulse = nextPulseTime - now;

            if (pulseRate < timeToNextPulse) {
                int numPulsesToNow = (int) (timeToNextPulse / pulseRate);
                int numNewToOldPulses = (int) (supportedReportRates[oldPulseRateIndex] / supportedReportRates[pulseRateIndex]);

                pulseNumber += (numNewToOldPulses - numPulsesToNow) * pulsesPerRate[pulseRateIndex];
                timeToNextPulse = now - (numPulsesToNow * pulseRate);
            } else {
                pulseNumber += (pulsesPerRate[oldPulseRateIndex] - pulsesPerRate[pulseRateIndex]);
            }

        } else if (pulseRateIndex > oldPulseRateIndex) { // case 3: pulse going to a  slower pulse
            int nextPulseNumber = pulseNumber + pulsesPerRate[oldPulseRateIndex];

            pulseNumber = ((nextPulseNumber - 1) / pulsesPerRate[pulseRateIndex]) * pulsesPerRate[pulseRateIndex];
            nextPulseTime += (nextPulseNumber - pulseNumber) * supportedReportRates[0];

            for (int i = 0; i < pulseRateIndex; i++) {
                previousReportTimes[i] = NO_PRIOR_REPORT;
            }
        }

        reportThread.interrupt();
    }

    private MonitorReport getMonitorReport(MonitorFilter monitorFilter, long reportRate, long previousDeltaTime, long beginReportTime) {
        MonitorReport monitorReport = new MonitorReport(previousDeltaTime, beginReportTime, false);

        for (Iterator i = monitorFilter.getModuleClassIDs(); i.hasNext();) {
            ModuleClassID moduleClassID = (ModuleClassID) i.next();

            ServiceMonitorFilter serviceMonitorFilter = monitorFilter.getServiceMonitorFilter(moduleClassID);

            ServiceMonitor serviceMonitor = getServiceMonitor(moduleClassID);

            if (serviceMonitorFilter != null) {
                ServiceMetric serviceMetric = serviceMonitor.getServiceMetric(serviceMonitorFilter, previousDeltaTime
                        ,
                        beginReportTime, getReportRateIndex(reportRate), reportRate);

                if (serviceMetric != null) {
                    monitorReport.addServiceMetric(serviceMetric);
                }
            }
        }
        return monitorReport;
    }

    public void validateCumulativeMonitorFilter(MonitorFilter monitorFilter) throws MonitorFilterException {
        boolean isAnyServiceFilters = false;

        for (Iterator i = monitorFilter.getServiceMonitorFilters(); i.hasNext();) {
            ServiceMonitorFilter serviceMonitorFilter = (ServiceMonitorFilter) i.next();

            ModuleClassID moduleClassID = serviceMonitorFilter.getModuleClassID();
            ServiceMonitor serviceMonitor = getServiceMonitor(moduleClassID);

            if (serviceMonitor == null) {
                throw new MonitorFilterException(MonitorFilterException.SERVICE_NOT_SUPPORTED, moduleClassID);
            }

            serviceMonitor.validateCumulativeServiceMonitorFilter(serviceMonitorFilter);
            isAnyServiceFilters = true;
        }

        if (!isAnyServiceFilters) {
            throw new MonitorFilterException("Empty Monitor Filter");
        }

    }

    public void validateMonitorFilter(MonitorFilter monitorFilter, long reportRate) throws MonitorFilterException {

        if (!isSupportedReportRate(reportRate)) {
            throw new MonitorFilterException(MonitorFilterException.REPORT_RATE_NOT_SUPPORTED, reportRate);
        }

        boolean isAnyServiceFilters = false;

        for (Iterator i = monitorFilter.getServiceMonitorFilters(); i.hasNext();) {
            ServiceMonitorFilter serviceMonitorFilter = (ServiceMonitorFilter) i.next();

            ModuleClassID moduleClassID = serviceMonitorFilter.getModuleClassID();
            ServiceMonitor serviceMonitor = getServiceMonitor(moduleClassID);

            if (serviceMonitor == null) {
                throw new MonitorFilterException(MonitorFilterException.SERVICE_NOT_SUPPORTED, moduleClassID);
            }

            serviceMonitor.validateServiceMonitorFilter(serviceMonitorFilter, reportRate);
            isAnyServiceFilters = true;
        }

        if (!isAnyServiceFilters) {
            throw new MonitorFilterException("Empty Monitor Filter");
        }
    }

    public MonitorFilter createSupportedCumulativeMonitorFilter(MonitorFilter monitorFilter) throws MonitorFilterException {
        MonitorFilter newMonitorFilter = new MonitorFilter(monitorFilter.getDescription());
        boolean anythingAdded = false;

        for (Iterator i = monitorFilter.getServiceMonitorFilters(); i.hasNext();) {
            ServiceMonitorFilter serviceMonitorFilter = (ServiceMonitorFilter) i.next();

            ModuleClassID moduleClassID = serviceMonitorFilter.getModuleClassID();
            ServiceMonitor serviceMonitor = getServiceMonitor(moduleClassID);

            if (serviceMonitor == null) {
                continue;
            }

            ServiceMonitorFilter newServiceMonitorFilter = serviceMonitor.createSupportedCumulativeServiceMonitorFilter(
                    serviceMonitorFilter);

            if (newServiceMonitorFilter != null) {
                newMonitorFilter.addServiceMonitorFilter(newServiceMonitorFilter);
                anythingAdded = true;
            }
        }

        if (anythingAdded) {
            return newMonitorFilter;
        } else {
            return null;
        }
    }

    public MonitorFilter createSupportedMonitorFilter(MonitorFilter monitorFilter, long reportRate) throws MonitorFilterException {
        MonitorFilter newMonitorFilter = new MonitorFilter(monitorFilter.getDescription());
        boolean anythingAdded = false;

        for (Iterator i = monitorFilter.getServiceMonitorFilters(); i.hasNext();) {
            ServiceMonitorFilter serviceMonitorFilter = (ServiceMonitorFilter) i.next();

            ModuleClassID moduleClassID = serviceMonitorFilter.getModuleClassID();
            ServiceMonitor serviceMonitor = getServiceMonitor(moduleClassID);

            if (serviceMonitor == null) {
                continue;
            }

            ServiceMonitorFilter newServiceMonitorFilter = serviceMonitor.createSupportedServiceMonitorFilter(serviceMonitorFilter
                    ,
                    reportRate);

            if (newServiceMonitorFilter != null) {
                newMonitorFilter.addServiceMonitorFilter(newServiceMonitorFilter);
                anythingAdded = true;
            }
        }

        if (anythingAdded) {
            return newMonitorFilter;
        } else {
            return null;
        }
    }

    public synchronized long addMonitorListener(MonitorFilter monitorFilter, long reportRate, boolean includeCumulative, MonitorListener monitorListener) throws MonitorException {

        validateMonitorFilter(monitorFilter, reportRate); // if validation fails, it will throw an exception

        if (includeCumulative) {
            validateCumulativeMonitorFilter(monitorFilter);
        }    // if validation fails, it will throw an exception

        int reportRateIndex = getReportRateIndex(reportRate);

        try {
            monitorFilter = (MonitorFilter) DocumentSerializableUtilities.copyDocumentSerializable(monitorFilter); // make a copy of the filter
        } catch (DocumentSerializationException e) {
            throw new MonitorException(MonitorException.SERIALIZATION, "Error trying to copy MonitorFilter");
        }

        MonitorListenerInfo monitorListenerInfo = new MonitorListenerInfo(monitorListener, reportRate, monitorFilter
                ,
                includeCumulative);

        monitorListenerInfos.add(monitorListenerInfo);
        filtersPerRate[reportRateIndex]++;

        if ((filtersPerRate[reportRateIndex] == 1) && (pulseRateIndex != NOT_PULSING) && (reportRateIndex > pulseRateIndex)) {
            previousReportTimes[reportRateIndex] = previousReportTimes[pulseRateIndex];
        }

        for (Iterator i = monitorFilter.getModuleClassIDs(); i.hasNext();) {
            ModuleClassID moduleClassID = (ModuleClassID) i.next();

            ServiceMonitorFilter serviceMonitorFilter = monitorFilter.getServiceMonitorFilter(moduleClassID);
            ServiceMonitorPulseInfo serviceMonitorPulseInfo = serviceMonitorPulseInfos.get(moduleClassID);

            serviceMonitorPulseInfo.registerServiceMonitorFilter(serviceMonitorFilter, reportRateIndex, reportRate);
        }

        resetPulseRate();

        return reportRate;
    }

    private MonitorListenerInfo getMonitorListenerInfo(MonitorListener monitorListener) {
        for (Object monitorListenerInfo1 : monitorListenerInfos) {
            MonitorListenerInfo monitorListenerInfo = (MonitorListenerInfo) monitorListenerInfo1;

            if (monitorListenerInfo.monitorListener == monitorListener) {
                return monitorListenerInfo;
            }
        }
        return null;
    }

    public synchronized int removeMonitorListener(MonitorListener monitorListener) {
        int numRemoved = 0;

        for (;;) { // remove all instances of this listener
            MonitorListenerInfo monitorListenerInfo = getMonitorListenerInfo(monitorListener);

            if (monitorListenerInfo == null) {
                break;
            } else {
                MonitorFilter monitorFilter = monitorListenerInfo.monitorFilter;
                long reportRate = monitorListenerInfo.reportRate;
                int reportRateIndex = monitorListenerInfo.reportRateIndex;

                monitorListenerInfos.remove(monitorListenerInfo);
                numRemoved++;
                filtersPerRate[reportRateIndex]--;

                for (Iterator i = monitorFilter.getModuleClassIDs(); i.hasNext();) {
                    ModuleClassID moduleClassID = (ModuleClassID) i.next();

                    ServiceMonitorFilter serviceMonitorFilter = monitorFilter.getServiceMonitorFilter(moduleClassID);
                    ServiceMonitorPulseInfo serviceMonitorPulseInfo = serviceMonitorPulseInfos.get(moduleClassID);

                    serviceMonitorPulseInfo.deregisterServiceMonitorFilter(serviceMonitorFilter, reportRateIndex, reportRate);
                }
            }
        }

        resetPulseRate();

        return numRemoved;
    }

    public synchronized MonitorReport getCumulativeMonitorReport(MonitorFilter monitorFilter) throws MonitorException {
        validateCumulativeMonitorFilter(monitorFilter);

        long beginReportTime = System.currentTimeMillis();

        MonitorReport monitorReport = new MonitorReport(startTime, beginReportTime, true);

        for (Iterator i = monitorFilter.getModuleClassIDs(); i.hasNext();) {