peerinfoserviceimpl.java

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

    public boolean isLocalMonitoringAvailable(ModuleClassID moduleClassID) {
        return MeterBuildSettings.METERING && monitorManager.isLocalMonitoringAvailable(moduleClassID);
    }
    
    /**
     * {@inheritDoc}
     */
    public long[] getSupportedReportRates() {
        return MonitorManager.getReportRates();
    }
    
    /**
     * {@inheritDoc}
     */
    public boolean isSupportedReportRate(long reportRate) {
        return monitorManager.isSupportedReportRate(reportRate);
    }
    
    /**
     * {@inheritDoc}
     */
    public long getBestReportRate(long desiredReportRate) {
        return monitorManager.getBestReportRate(desiredReportRate);
    }
    
    /**
     * {@inheritDoc}
     */
    public PeerMonitorInfo getPeerMonitorInfo() {
        if (monitorManager != null) {
            return monitorManager.getPeerMonitorInfo();
        } else {
            return PeerMonitorInfo.NO_PEER_MONITOR_INFO;
        }
    }
    
    /**
     * {@inheritDoc}
     */
    public void getPeerMonitorInfo(final PeerID peerID, PeerMonitorInfoListener peerMonitorInfoListener, long timeout) throws MonitorException {
        remoteMonitorPeerInfoHandler.getPeerMonitorInfo(peerID, peerMonitorInfoListener, timeout, resolverServicePeerInfoMessenger);
    }
    
    /**
     * {@inheritDoc}
     */
    public MonitorReport getCumulativeMonitorReport(MonitorFilter monitorFilter) throws MonitorException {
        if (MeterBuildSettings.METERING) {
            throw new MonitorException(MonitorException.METERING_NOT_SUPPORTED, "Local Monitoring not Available");
        }
        return monitorManager.getCumulativeMonitorReport(monitorFilter);
        
    }
    
    /**
     * {@inheritDoc}
     */
    public void getCumulativeMonitorReport(PeerID peerID, MonitorFilter monitorFilter, MonitorListener monitorListener, long timeout) throws MonitorException {
        remoteMonitorPeerInfoHandler.getCumulativeMonitorReport(peerID, monitorFilter, monitorListener, timeout
                ,
                resolverServicePeerInfoMessenger);
    }
    
    /**
     * {@inheritDoc}
     */
    public long addMonitorListener(MonitorFilter monitorFilter, long reportRate, boolean includeCumulative, MonitorListener monitorListener) throws MonitorException {
        if (!MeterBuildSettings.METERING) {
            throw new MonitorException(MonitorException.METERING_NOT_SUPPORTED, "Local Monitoring not Available");
        }
        
        return monitorManager.addMonitorListener(monitorFilter, reportRate, includeCumulative, monitorListener);
    }
    
    /**
     * {@inheritDoc}
     */
    public void addRemoteMonitorListener(PeerID peerID, MonitorFilter monitorFilter, long reportRate, boolean includeCumulative, MonitorListener monitorListener, long lease, long timeout) throws MonitorException {
        remoteMonitorPeerInfoHandler.addRemoteMonitorListener(peerID, monitorFilter, reportRate, includeCumulative
                ,
                monitorListener, lease, timeout, resolverServicePeerInfoMessenger);
    }
    
    /**
     * {@inheritDoc}
     */
    public boolean removeMonitorListener(MonitorListener monitorListener) throws MonitorException {
        
        int numRemoved = monitorManager.removeMonitorListener(monitorListener);

        return numRemoved > 0;
    }
    
    /**
     * {@inheritDoc}
     */
    public void removeRemoteMonitorListener(PeerID peerID, MonitorListener monitorListener, long timeout) throws MonitorException {
        remoteMonitorPeerInfoHandler.removeRemoteMonitorListener(peerID, monitorListener, timeout
                ,
                resolverServicePeerInfoMessenger);
    }
    
    /**
     * {@inheritDoc}
     */
    public void removeRemoteMonitorListener(MonitorListener monitorListener, long timeout) throws MonitorException {
        remoteMonitorPeerInfoHandler.removeRemoteMonitorListener(monitorListener, timeout, resolverServicePeerInfoMessenger);
    }
    
    class PipQueryHandler implements QueryHandler {
        
        /**
         * {@inheritDoc}
         */
        public int processQuery(ResolverQueryMsg query) {
            int queryId = query.getQueryId();
            PeerID requestSourceID = null;

            try {
                requestSourceID = (PeerID) IDFactory.fromURI(new URI(query.getSrc()));
            } catch (Exception e) {
                if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                    LOG.log(Level.FINE, "PeerInfoService.processQuery got a bad query, not valid src", e);
                }
                return ResolverService.OK;
            }
            
            XMLDocument doc = null;

            try {
                doc = (XMLDocument)
                        StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8, new StringReader(query.getQuery()));
            } catch (Exception e) {
                if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                    LOG.log(Level.WARNING, "PeerInfoService.processQuery got a bad adv", e);
                }
                return ResolverService.OK;
            }
            
            PeerInfoQueryMessage pipquery = new PeerInfoQueryMsg(doc);
            
            Element requestElement = pipquery.getRequest();
            String queryType = (String) requestElement.getKey();
            
            if (queryType != null) {
                PeerInfoHandler peerInfoHandler = getPeerInfoHandler(queryType);
                
                if (peerInfoHandler != null) {
                    peerInfoHandler.processRequest(queryId, requestSourceID, pipquery, requestElement
                            ,
                            resolverServicePeerInfoMessenger);
                } else {
                    if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                        LOG.fine("No registered PeerInfoHandler for this type of request");
                    }
                }
            } else {
                if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                    LOG.fine("No request PeerInfoQueryMessage Request Element found");
                }
            }
            
            return ResolverService.OK;
        }
        
        /**
         * {@inheritDoc}
         */
        public void processResponse(ResolverResponseMsg response) {
            
            int queryId = response.getQueryId();
            
            PeerInfoResponseMessage resp = null;

            try {
                StructuredDocument doc = StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8
                        ,
                        new StringReader(response.getResponse()));
                
                resp = new PeerInfoResponseMsg(doc);
            } catch (Exception e) {
                if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                    LOG.log(Level.FINE, "PeerInfoService.processResponse got a bad adv", e);
                }
                return;
            }
            
            Element responseElement = resp.getResponse();
            String responseType = (String) responseElement.getKey();
            
            if (responseType != null) {
                PeerInfoHandler peerInfoHandler = getPeerInfoHandler(responseType);
                
                if (peerInfoHandler != null) {
                    peerInfoHandler.processResponse(queryId, resp, responseElement, resolverServicePeerInfoMessenger);
                } else {
                    if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                        LOG.fine("No registered PeerInfoHandler for this type of response");
                    }
                }
            } else {
                if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                    LOG.fine("No request PeerInfoResponseMessage Response Element found");
                }
            }
        }
    }
    

    private class ResolverServicePeerInfoMessenger implements PeerInfoMessenger {
        
        /**
         * {@inheritDoc}
         */
        public void sendPeerInfoResponse(int queryId, PeerID destinationPeerID, String peerInfoHandler, DocumentSerializable response) {
            try {
                PeerInfoResponseMessage peerInfoResponseMessage = new PeerInfoResponseMsg();

                peerInfoResponseMessage.setSourcePid(destinationPeerID);
                peerInfoResponseMessage.setTargetPid(localPeerId);
                
                long now = System.currentTimeMillis();

                peerInfoResponseMessage.setUptime(now - startTime);
                peerInfoResponseMessage.setTimestamp(now);
                
                Element responseElement = StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8, peerInfoHandler);

                response.serializeTo(responseElement);
                
                peerInfoResponseMessage.setResponse(responseElement);
                
                XMLDocument doc = (XMLDocument) peerInfoResponseMessage.getDocument(MimeMediaType.XMLUTF8);
                String peerInfoResponse = doc.toString();
                
                ResolverResponse resolverResponse = new ResolverResponse(resolverHandlerName, credentialDoc, queryId
                        ,
                        peerInfoResponse);

                resolver.sendResponse(destinationPeerID.toString(), resolverResponse);
            } catch (JxtaException e) {
                if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                    LOG.log(Level.WARNING, "Failure building document", e);
                }
            }
        }
        
        /**
         * {@inheritDoc}
         */
        public void sendPeerInfoRequest(int queryID, PeerID destinationPeerID, String peerInfoHandler, DocumentSerializable request) {
            try {
                PeerInfoQueryMsg peerInfoQueryMsg = new PeerInfoQueryMsg();

                peerInfoQueryMsg.setSourcePid(localPeerId);
                peerInfoQueryMsg.setTargetPid(destinationPeerID);
                
                Element requestElement = StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8, peerInfoHandler);

                request.serializeTo(requestElement);
                
                peerInfoQueryMsg.setRequest(requestElement);
                
                XMLDocument doc = (XMLDocument) peerInfoQueryMsg.getDocument(MimeMediaType.XMLUTF8);
                String peerInfoRequest = doc.toString();
                
                ResolverQuery resolverQuery = new ResolverQuery(resolverHandlerName, credentialDoc, localPeerId.toString()
                        ,
                        peerInfoRequest, queryID);

                resolver.sendQuery(destinationPeerID.toString(), resolverQuery);
            } catch (JxtaException e) {
                if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                    LOG.log(Level.WARNING, "Failure to build resolver query", e);
                }
            }
        }
    }
}