peerinfoserviceimpl.java

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

				monitorManager = MonitorManager.registerMonitorManager(pg);		// Fix-Me: This will become a service lookup when MonitorService is a real service
        } catch (JxtaException e) {
            throw new PeerGroupException("Unable to load MonitorManager", e);
        }

		// record start time at end of successful init
		startTime = System.currentTimeMillis();
        
        if (LOG.isEnabledFor(Level.INFO)) {
            StringBuffer configInfo = new StringBuffer( "Configuring PeerInfo Service : " + assignedID );
            
            configInfo.append( "\n\tImplementation:" );
            configInfo.append( "\n\t\tImpl Description: " + implAdvertisement.getDescription() );
            configInfo.append( "\n\t\tImpl URI : " + implAdvertisement.getUri() );
            configInfo.append( "\n\t\tImpl Code : " + implAdvertisement.getCode() );
            
            configInfo.append( "\n\tGroup Params:" );
            configInfo.append( "\n\t\tGroup: " + pg.getPeerGroupName() );
            configInfo.append( "\n\t\tGroup ID: " + pg.getPeerGroupID() );
            configInfo.append( "\n\t\tPeer ID: " + pg.getPeerID() );
            
            LOG.info( configInfo );
        }
	}




	/**
	 *  Returns the group to which this service is attached.
	 *
	 *@return    PeerGroup the group
	 */
	public PeerGroup getGroup() {
		return pg;
	}

	class PipQueryHandler implements QueryHandler {

		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 (LOG.isEnabledFor(Level.DEBUG)) {
					LOG.debug("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 (LOG.isEnabledFor(Level.WARN)) {
					LOG.warn("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 (LOG.isEnabledFor(Level.DEBUG)) {
						LOG.debug("No registered PeerInfoHandler for this type of request");
					}
				} 
			} else {
				if (LOG.isEnabledFor(Level.DEBUG)) {
					LOG.debug("No request PeerInfoQueryMessage Request Element found");
				}
			}
			
			return ResolverService.OK;
		}
	
	
		public void processResponse(ResolverResponseMsg response) {
	
			int queryId = response.getQueryId();
			
			PeerInfoResponseMessage resp = null;
			try {
				StructuredDocument doc = StructuredDocumentFactory.newStructuredDocument(
				                             MimeMediaType.XMLUTF8,
				                             new StringReader(response.getResponse()) );
	
				resp = (PeerInfoResponseMessage) new PeerInfoResponseMsg( doc );
			} catch (Exception e) {
				if (LOG.isEnabledFor(Level.DEBUG)) {
					LOG.debug("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 (LOG.isEnabledFor(Level.DEBUG)) {
						LOG.debug("No registered PeerInfoHandler for this type of response");
					}
				} 
			} else {
				if (LOG.isEnabledFor(Level.DEBUG)) {
					LOG.debug("No request PeerInfoResponseMessage Response Element found");
				}
			}
			
			return;
		}
	}
	

	private class ResolverServicePeerInfoMessenger implements PeerInfoMessenger {
		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 = (XMLDocument) 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 (LOG.isEnabledFor(Level.WARN)) {
					LOG.warn( "Failure building document", e);
				}			
			}	
		}
	
		public void sendPeerInfoRequest(int queryID, PeerID destinationPeerID, String peerInfoHandler, DocumentSerializable request) {
			try {
				PeerInfoQueryMsg peerInfoQueryMsg = new PeerInfoQueryMsg();
				peerInfoQueryMsg.setSourcePid(localPeerId);
				peerInfoQueryMsg.setTargetPid(destinationPeerID);
	
				Element requestElement = (XMLDocument) 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 (LOG.isEnabledFor(Level.WARN)) {
					LOG.warn("Failure to build resolver query",e);
	}
			}
		}
	}

	public boolean isLocalMonitoringAvailable() {
        if (MeterBuildSettings.METERING) 
        	return true;
        else
        	return false;
	}

	public boolean isLocalMonitoringAvailable( ModuleClassID moduleClassID ) {
		if (MeterBuildSettings.METERING) {
			return monitorManager.isLocalMonitoringAvailable(moduleClassID);
		} else
			return false;
	}

	public long[] getSupportedReportRates() {
		return monitorManager.getReportRates();
	}

    public boolean isSupportedReportRate(long reportRate) {
        return monitorManager.isSupportedReportRate(reportRate);
    }
    
    public long getBestReportRate(long desiredReportRate) {
        return monitorManager.getBestReportRate(desiredReportRate);
    }

    public PeerMonitorInfo getPeerMonitorInfo() { 
        if (monitorManager != null)
        	return monitorManager.getPeerMonitorInfo(); 
        else
        	return PeerMonitorInfo.NO_PEER_MONITOR_INFO;
    }

    public void getPeerMonitorInfo(final PeerID peerID, PeerMonitorInfoListener peerMonitorInfoListener, long timeout) throws MonitorException {
		remoteMonitorPeerInfoHandler.getPeerMonitorInfo(peerID, peerMonitorInfoListener, timeout, resolverServicePeerInfoMessenger);
    }
		
    
	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);

	}
	
  	public void getCumulativeMonitorReport(PeerID peerID, MonitorFilter monitorFilter, MonitorListener monitorListener, long timeout) throws MonitorException {
		remoteMonitorPeerInfoHandler.getCumulativeMonitorReport(peerID, monitorFilter, monitorListener, timeout, resolverServicePeerInfoMessenger);
    }
  

	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);
	}
		
	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);
    }


	public boolean removeMonitorListener(MonitorListener monitorListener) throws MonitorException {

		int numRemoved = monitorManager.removeMonitorListener(monitorListener);
		return numRemoved > 0;
	}
	
	public void removeRemoteMonitorListener (PeerID peerID, MonitorListener monitorListener, long timeout) throws MonitorException {
		remoteMonitorPeerInfoHandler.removeRemoteMonitorListener(peerID, monitorListener, timeout, resolverServicePeerInfoMessenger);
    }


	public void removeRemoteMonitorListener (MonitorListener monitorListener, long timeout) throws MonitorException {
		remoteMonitorPeerInfoHandler.removeRemoteMonitorListener(monitorListener, timeout, resolverServicePeerInfoMessenger);
    }



	


}