remotemonitorpeerinfohandler.java

jxta_src_2.41b jxta 2.41b 最新版源码 from www.jxta.org

        final RequestInfo requestInfo = new RequestInfo(peerID, queryId, monitorListener, timeout, peerInfoMessenger);

        requestInfo.requestedLease = lease;

        requestInfos.put(new Integer(queryId), requestInfo);

        timer.schedule(new TimerTask() {
                    public void run() {
                        if (!requestInfo.responseReceived) {
                            MonitorEvent monitorEvent = MonitorEvent.createFailureEvent(MonitorEvent.TIMEOUT, requestInfo.peerId,
                                                        requestInfo.queryId);
                            requestInfo.monitorListener.monitorRequestFailed(monitorEvent);
                            requestInfos.remove(requestInfo);
                        }
                    }
                }
                , timeout);
        scheduleTimeout(requestInfo);
    }

    public void removeRemoteMonitorListener(PeerID peerID,
                                            MonitorListener monitorListener,
                                            long timeout,
                                            PeerInfoMessenger peerInfoMessenger) throws MonitorException {
        int queryId = peerInfoServiceImpl.getNextQueryId();

        RequestInfo oldRequestInfo = null;

        for (Enumeration e = requestInfos.elements(); e.hasMoreElements();) {
            RequestInfo ri = (RequestInfo) e.nextElement();

            if (ri.monitorListener == monitorListener) {
                oldRequestInfo = ri;
                break;
            }
        }

        if (oldRequestInfo != null) {
            RemoteMonitorQuery remoteMonitorQuery = RemoteMonitorQuery.createRemoveMonitorListenerQuery(oldRequestInfo.leaseId);

            peerInfoMessenger.sendPeerInfoRequest(queryId, peerID, MONITOR_HANDLER_NAME, remoteMonitorQuery);

            final RequestInfo requestInfo = new RequestInfo(peerID, queryId, monitorListener, timeout, peerInfoMessenger);

            requestInfo.origRequestId = oldRequestInfo.queryId;
            requestInfos.put(new Integer(queryId), requestInfo);
        }

        final RequestInfo requestInfo = oldRequestInfo;

        timer.schedule(new TimerTask() {
                    public void run() {

                        requestInfos.remove(new Integer(requestInfo.queryId));
                    }
                }
                , timeout);

    }

    public void removeRemoteMonitorListener(MonitorListener monitorListener,
                                            long timeout,
                                            PeerInfoMessenger peerInfoMessenger) throws MonitorException {
        for (Enumeration e = requestInfos.elements(); e.hasMoreElements();) {
            RequestInfo requestInfo = (RequestInfo) e.nextElement();

            if (requestInfo.monitorListener == monitorListener) {
                removeRemoteMonitorListener(requestInfo.peerId, monitorListener, timeout, peerInfoMessenger);
            }
        }
    }

    public void processRequest(int queryId,
                               PeerID requestSourceID,
                               PeerInfoQueryMessage peerInfoQueryMessage,
                               Element requestElement,
                               PeerInfoMessenger peerInfoMessenger) {
        try {
            RemoteMonitorQuery remoteMonitorQuery = (RemoteMonitorQuery) DocumentSerializableUtilities.getDocumentSerializable(
                                                        requestElement, RemoteMonitorQuery.class);

            if (remoteMonitorQuery.isRegisterMonitorQuery()) {
                handleRegisterMonitorQuery(queryId, requestSourceID, peerInfoQueryMessage, remoteMonitorQuery, peerInfoMessenger);

            } else
                if (remoteMonitorQuery.isCumulativeReportQuery()) {
                    handleCumulativeReportQuery(queryId, requestSourceID, peerInfoQueryMessage, remoteMonitorQuery.getMonitorFilter(),
                                                peerInfoMessenger);

                } else
                    if (remoteMonitorQuery.isRemoveMonitorQuery()) {
                        handleRemoveMonitorQuery(queryId, requestSourceID, peerInfoQueryMessage, remoteMonitorQuery, peerInfoMessenger);

                    } else
                        if (remoteMonitorQuery.isPeerMonitorInfoQuery()) {
                            handlePeerMonitorInfoQuery(queryId, requestSourceID, peerInfoQueryMessage, peerInfoMessenger);

                        } else
                            if (remoteMonitorQuery.isLeaseRenewal()) {
                                handleLeaseRenewalQuery(queryId, requestSourceID, peerInfoQueryMessage, remoteMonitorQuery, peerInfoMessenger);

                            }
        } catch (Exception e) {
            if (LOG.isEnabledFor(Level.DEBUG)) {
                LOG.debug("Monitor failed in processQuery", e);
            }
        }
    }

    public void processResponse(int queryId,
                                PeerInfoResponseMessage peerInfoResponseMessage,
                                Element responseElement,
                                PeerInfoMessenger peerInfoMessenger) {

        RemoteMonitorResponse remoteMonitorResponse = null;

        try {
            remoteMonitorResponse = (RemoteMonitorResponse) DocumentSerializableUtilities.getDocumentSerializable(responseElement,
                                    RemoteMonitorResponse.class);
            RequestInfo requestInfo = (RequestInfo) requestInfos.get(new Integer(queryId));

            if (requestInfo != null) {
                requestInfo.responseReceived = true;

                resetTimeout(requestInfo);
                if (remoteMonitorResponse.isMonitorRegistered()) {
                    int leaseId = remoteMonitorResponse.getLeaseId();
                    long leaseLength = remoteMonitorResponse.getLease();

                    requestInfo.leaseId = leaseId;
                    scheduleLeaseRenewal(requestInfo, leaseLength);

                } else
                    if (remoteMonitorResponse.isMonitorRemoved()) {
                        requestInfos.remove(new Integer(requestInfo.origRequestId));
                        requestInfos.remove(new Integer(queryId));

                    } else
                        if (remoteMonitorResponse.isCumulativeReport() || remoteMonitorResponse.isMonitorReport()) {
                            MonitorReport monitorReport = remoteMonitorResponse.getMonitorReport();
                            MonitorEvent monitorEvent = MonitorEvent.createRemoteMonitorReportEvent(requestInfo.peerId, requestInfo.queryId,
                                                        monitorReport);

                            requestInfo.monitorListener.processMonitorReport(monitorEvent);

                        } else
                            if (remoteMonitorResponse.isInvalidFilter()) {
                                MonitorEvent monitorEvent = MonitorEvent.createFailureEvent(MonitorEvent.INVALID_MONITOR_FILTER,
                                                            requestInfo.peerId, requestInfo.queryId);

                                requestInfo.monitorListener.monitorRequestFailed(monitorEvent);
                                requestInfos.remove(new Integer(queryId));

                            } else
                                if (remoteMonitorResponse.isInvalidReportRate()) {
                                    MonitorEvent monitorEvent = MonitorEvent.createFailureEvent(MonitorEvent.INVALID_REPORT_RATE, requestInfo.peerId,
                                                                requestInfo.queryId);

                                    requestInfo.monitorListener.monitorRequestFailed(monitorEvent);
                                    requestInfos.remove(new Integer(queryId));

                                } else
                                    if (remoteMonitorResponse.isMeteringNotSupported()) {
                                        MonitorEvent monitorEvent = MonitorEvent.createFailureEvent(MonitorEvent.REFUSED, requestInfo.peerId,
                                                                    requestInfo.queryId);

                                        requestInfo.monitorListener.monitorRequestFailed(monitorEvent);
                                        requestInfos.remove(new Integer(queryId));

                                    } else
                                        if (remoteMonitorResponse.isRequestDenied()) {
                                            MonitorEvent monitorEvent = MonitorEvent.createFailureEvent(MonitorEvent.REFUSED, requestInfo.peerId,
                                                                        requestInfo.queryId);

                                            requestInfo.monitorListener.monitorRequestFailed(monitorEvent);

                                        } else
                                            if (remoteMonitorResponse.isPeerMonitorInfo()) {
                                                PeerMonitorInfoEvent peerMonitorInfoEvent = new PeerMonitorInfoEvent(requestInfo.peerId,
                                                        remoteMonitorResponse.getPeerMonitorInfo());

                                                requestInfo.peerMonitorInfoListener.peerMonitorInfoReceived(peerMonitorInfoEvent);
                                                requestInfos.remove(new Integer(queryId));

                                            } else
                                                if (remoteMonitorResponse.isLeaseRenewed()) {
                                                    long lease = remoteMonitorResponse.getLease();
                                                    int origRequestId = requestInfo.origRequestId;
                                                    RequestInfo origRequest = (RequestInfo) requestInfos.get(new Integer(origRequestId));

                                                    scheduleLeaseRenewal(origRequest, lease);
                                                    requestInfos.remove(new Integer(queryId));
                                                }

            }
        } catch (DocumentSerializationException e) {
            if (LOG.isEnabledFor(Level.DEBUG)) {
                LOG.debug("Document Serialization Failed", e);
            }
        }

    }

    private void resetTimeout(RequestInfo requestInfo) {
        timeouts.put(new Integer(requestInfo.queryId), new Long(requestInfo.timeout + System.currentTimeMillis()));
    }

    private long getTimeout(int queryId) {
        return ((Long) timeouts.get(new Integer(queryId))).longValue();
    }
    private void scheduleTimeout(final RequestInfo requestInfo) {
        final int queryId = requestInfo.queryId;

        timer.schedule(
            new TimerTask() {
                public void run() {
                    if (requestInfos.containsKey(new Integer(queryId))) {
                        try {
                            if (System.currentTimeMillis() > getTimeout(queryId)) {
                                MonitorEvent monitorEvent = MonitorEvent.createFailureEvent(MonitorEvent.TIMEOUT, requestInfo.peerId,
                                                            queryId);
                                requestInfo.monitorListener.monitorRequestFailed(monitorEvent);
                            }
                        } catch (Exception e) {}
                    }
                    else {
                        cancel();
                    }
                }
            }
            , requestInfo.timeout, requestInfo.timeout);
    }

    private void scheduleLeaseRenewal(RequestInfo requestInfo, long leaseLength) {
        long roundTrip = requestInfo.requestTime - System.currentTimeMillis();
        long renewTime = leaseLength - roundTrip - 30 * 1000L; // 30s comfort
        // zone.
        final int queryId = requestInfo.queryId;

        if (renewTime > MIN_LEASE) {
            timer.schedule(new TimerTask() {
                        public void run() {
                            try {
                                renewLease(queryId);
                            } catch (Exception e) {
                                if (LOG.isEnabledFor(Level.DEBUG)) {
                                    LOG.debug("Lease Renewal Failed", e);
                                }
                            }
                        }
                    }
                    , renewTime);
        }
    }

    private void handleRegisterMonitorQuery(final int queryId,
                                            final PeerID requestSourceID,
                                            PeerInfoQueryMessage peerInfoQueryMessage,
                                            RemoteMonitorQuery remoteMonitorQuery,
                                            final PeerInfoMessenger peerInfoMessenger) {
        MonitorFilter monitorFilter = remoteMonitorQuery.getMonitorFilter();
        long lease = remoteMonitorQuery.getLease();
        long reportRate = remoteMonitorQuery.getReportRate();