monitorresources.java

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

    
    /**
     * Well known endpoint protocol specification identifier: the standard
     * router
     */
    public static final ModuleSpecID refRouterServiceMonitorSpecID = (ModuleSpecID)
    ID.create( URI.create( WK_ID_PREFIX + "0000010B0106" ));
    
    
    /**
     * Well known endpoint protocol specification identifier: the standard
     * tls endpoint protocol
     */
    public static final ModuleSpecID refTlsServiceMonitorSpecID = (ModuleSpecID)
    ID.create( URI.create( WK_ID_PREFIX + "0000010D0106" ));
    
    /**
     * Well known application: the Proxy
     */
    public static final ModuleSpecID refProxyServiceMonitorSpecID = (ModuleSpecID)
    ID.create( URI.create( WK_ID_PREFIX + "0000010E0106" ));
    
    /**
     * Well known endpoint protocol specification identifier: the standard
     * relay endpoint protocol
     */
    public static final ModuleSpecID refRelayServiceMonitorSpecID = (ModuleSpecID)
    ID.create( URI.create( WK_ID_PREFIX + "0000010F0106" ));
    
    
    private static ModuleClassID standardServiceMonitorClassIDs[] = new ModuleClassID[] {
        resolverServiceMonitorClassID,
        rendezvousServiceMonitorClassID,
        endpointServiceMonitorClassID,
        transportServiceMonitorClassID };
        
        public static ModuleImplAdvertisement getReferenceAllPurposeMonitorServiceImplAdvertisement(boolean includeTransports) {
            ModuleImplAdvertisement moduleImplAdvertisement = AdvertisementUtilities.createModuleImplAdvertisement(refMonitorServiceSpecID, "net.jxta.impl.meter.MonitorManager", "Service Monitor");
            StructuredTextDocument param =  (StructuredTextDocument) StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8, "serviceMonitor");
            
            addServiceMonitorServiceAdvertisement(param, refResolverServiceMonitorSpecID, "Resolver",
            "net.jxta.impl.resolver.resolverMeter.ResolverServiceMonitor",
            "net.jxta.impl.resolver.resolverMeter.ResolverServiceMetric",
            "net.jxta.impl.resolver.resolverMeter.ResolverServiceMonitorFilter");
            
            addServiceMonitorServiceAdvertisement(param, refEndpointServiceMonitorSpecID, "Endpoint",
            "net.jxta.impl.endpoint.endpointMeter.EndpointServiceMonitor",
            "net.jxta.impl.endpoint.endpointMeter.EndpointServiceMetric",
            "net.jxta.impl.endpoint.endpointMeter.EndpointServiceMonitorFilter");
            
            addServiceMonitorServiceAdvertisement(param, refTransportServiceMonitorSpecID, "Transport",
            "net.jxta.impl.endpoint.transportMeter.TransportServiceMonitor",
            "net.jxta.impl.endpoint.transportMeter.TransportServiceMetric",
            "net.jxta.impl.endpoint.transportMeter.TransportServiceMonitorFilter");
            
            addServiceMonitorServiceAdvertisement(param, refRendezvousServiceMonitorSpecID, "Rendezvous",
            "net.jxta.impl.rendezvous.rendezvousMeter.RendezvousServiceMonitor",
            "net.jxta.impl.rendezvous.rendezvousMeter.RendezvousServiceMetric",
            "net.jxta.impl.rendezvous.rendezvousMeter.RendezvousServiceMonitorFilter");
            
            moduleImplAdvertisement.setParam(param);
            return moduleImplAdvertisement;
        }
        
        
        private static void addServiceMonitorServiceAdvertisement(Element root, ModuleSpecID moduleSpecID, String title, String implClassName, String metricClassName, String filterClassName) {
            ModuleImplAdvertisement moduleImplAdvertisement = createServiceMonitorModuleImplAdvertisement(moduleSpecID, title, implClassName, metricClassName, filterClassName);
            
            Element serviceMonitorElement = DocumentSerializableUtilities.createChildElement(root, SERVICE_MONITOR_TAG);
            
            ModuleClassID moduleClassID = moduleSpecID.getBaseClass();
            DocumentSerializableUtilities.addString(serviceMonitorElement, CLASS_ID_TAG, moduleClassID.toString());
            
            Element serviceMonitorAdvertisementElement = DocumentSerializableUtilities.createChildElement(serviceMonitorElement, SERVICE_MONITOR_ADVERTISEMENT_TAG);
            Element advDoc = (Element) moduleImplAdvertisement.getDocument(MimeMediaType.XMLUTF8);
            DocumentSerializableUtilities.copyChildren(serviceMonitorAdvertisementElement, advDoc);
        }
        
        public static ModuleImplAdvertisement createServiceMonitorModuleImplAdvertisement(ModuleSpecID moduleSpecID, String title, String implClassName, String metricClassName, String filterClassName) {
            ModuleImplAdvertisement moduleImplAdvertisement = AdvertisementUtilities.createModuleImplAdvertisement(moduleSpecID, implClassName, "Service Monitor");
            
            StructuredTextDocument param =  (StructuredTextDocument) StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8, "serviceMonitor");
            
            DocumentSerializableUtilities.addString(param, SERVICE_TITLE_TAG, title);
            DocumentSerializableUtilities.addString(param, METRIC_CLASS_TAG, metricClassName);
            DocumentSerializableUtilities.addString(param, FILTER_CLASS_TAG, filterClassName);
            moduleImplAdvertisement.setParam(param);
            
            return moduleImplAdvertisement;
        }
        
        public static ModuleImplAdvertisement getServiceMonitorImplAdvertisement(ModuleClassID serviceMonitorModuleClassID, ModuleImplAdvertisement monitorServiceImplAdvertisement) {
            
            String classIDText = serviceMonitorModuleClassID.toString();
            
            StructuredDocument param = 	monitorServiceImplAdvertisement.getParam();
            
            for(Enumeration e = param.getChildren(SERVICE_MONITOR_TAG); e.hasMoreElements(); ) {
                Element serviceMonitorElement = (Element) e.nextElement();
                
                String serviceMonitorClassIDText = DocumentSerializableUtilities.getString(serviceMonitorElement, CLASS_ID_TAG, "");
                
                if (classIDText.equals(serviceMonitorClassIDText)) {
                    TextElement serviceMonitorAdvertisementElement = (TextElement) DocumentSerializableUtilities.getChildElement(serviceMonitorElement, SERVICE_MONITOR_ADVERTISEMENT_TAG);
                    return (ModuleImplAdvertisement) AdvertisementFactory.newAdvertisement(serviceMonitorAdvertisementElement);
                }
            }
            
            return null;
            
        }
        
        private static class ServiceResource {
            String serviceMonitorClassName;
            Class serviceMonitorClass;
            String serviceMonitorFilterClassName;
            Class serviceMonitorFilterClass;
            String serviceMetricClassName;
            Class serviceMetricClass;
            
            ServiceResource(ModuleImplAdvertisement moduleImplAdvertisement) throws JxtaException {
                try {
                    serviceMonitorClassName = moduleImplAdvertisement.getCode();
                    
                    serviceMonitorFilterClassName = getServiceMonitorFilterClassName(moduleImplAdvertisement);
                    serviceMonitorFilterClass = Class.forName(serviceMonitorFilterClassName);
                    
                    if (!(ServiceMonitorFilter.class).isAssignableFrom(serviceMonitorFilterClass))
                        throw new JxtaException("Bad ServiceMonitorImplAdvertisment: " + serviceMonitorFilterClassName + " is not a ServiceMonitorFilter");
                    
                    serviceMetricClassName = getServiceMetricClassName(moduleImplAdvertisement);
                    serviceMetricClass = Class.forName(serviceMetricClassName);
                    
                    if (!(ServiceMetric.class).isAssignableFrom(serviceMetricClass))
                        throw new JxtaException("Bad ServiceMonitorImplAdvertisment: " + serviceMetricClassName + " is not a ServiceMetric");
                } catch (Exception e) {
                    throw new JxtaException("Bad ServiceMonitorImplAdvertisment: Unable to load constituent parts", e);
                }
            }
        }
        
        
        /**
         * Register the Implementation Advertisement for a ServiceMonitor Type
         *  This contains the Monitor, Metric and Filter classNames
         */
        public static void registerServiceMonitorModuleImplAdvertisement(ModuleImplAdvertisement moduleImplAdvertisement) throws JxtaException {
            ModuleClassID moduleClassID = moduleImplAdvertisement.getModuleSpecID().getBaseClass();
            
            if (registeredMonitorResources.get(moduleClassID) != null)
                return;
            
            registeredMonitorResources.put(moduleClassID, new ServiceResource(moduleImplAdvertisement));
        }
        
        /**
         * Create an empty ServiceMonitorFilter for the corresponding ModuleClassID
         *
         * @exception JxtaException  If not found or other errors
         */
        public static ServiceMonitorFilter createServiceMonitorFilter(ModuleClassID moduleClassID) throws MonitorFilterException {
            try {
                ServiceResource serviceResource = (ServiceResource) registeredMonitorResources.get(moduleClassID);
                ServiceMonitorFilter serviceMonitorFilter = (ServiceMonitorFilter) serviceResource.serviceMonitorFilterClass.newInstance();
                serviceMonitorFilter.init(moduleClassID);
                return serviceMonitorFilter;
            } catch (Exception e) {
                throw new MonitorFilterException("Unable to Create Filter: " + moduleClassID);			// this should never happen, we already did our checks
            }
        }
        
        
        /**
         * Create an empty Service Metric for the corresponding ModuleClassID
         *
         * @exception JxtaException  If not found or other errors
         */
        public static ServiceMetric createServiceMetric(ModuleClassID moduleClassID) throws JxtaException {
            try {
                ServiceResource serviceResource = (ServiceResource) registeredMonitorResources.get(moduleClassID);
                ServiceMetric serviceMetric = (ServiceMetric) serviceResource.serviceMetricClass.newInstance();
                serviceMetric.init(moduleClassID);
                return serviceMetric;
            } catch (Exception e) {
                throw new JxtaException("Unable to Create Service Metric");			// this should never happen, we already did our checks
            }
        }
        
        /**
         * get ServiceMetric ClassName from its ImplAdvertisement
         */
        public static String getServiceMetricClassName(ModuleImplAdvertisement serviceMonitorModuleImplAdvertisement) {
            Element param = serviceMonitorModuleImplAdvertisement.getParam();
            return DocumentSerializableUtilities.getString(param, METRIC_CLASS_TAG, null);
        }
        
        /**
         * get ServiceMonitorFilter ClassName from its ImplAdvertisement
         */
        public static String getServiceMonitorFilterClassName(ModuleImplAdvertisement serviceMonitorModuleImplAdvertisement) {
            Element param = serviceMonitorModuleImplAdvertisement.getParam();
            return DocumentSerializableUtilities.getString(param, FILTER_CLASS_TAG, null);
        }
        
        /**
         * Get a list of all registered Service Monitor types
         */
        public static ModuleClassID[] getRegisteredModuleClassIDs() {
            return (ModuleClassID[]) standardServiceMonitorClassIDs.clone();
        }
        
        /**
         * Get the name of standard Monitor Type
         **/
        public static String getMonitorTypeName(ModuleClassID moduleClassID) {
            if(moduleClassID.equals(monitorServiceClassID)) return "monitor";
            
            if(moduleClassID.equals(resolverServiceMonitorClassID)) return "Resolver";
            
            if(moduleClassID.equals(discoveryServiceMonitorClassID)) return "Discovery";
            
            if(moduleClassID.equals(pipeServiceMonitorClassID)) return "Pipe";
            
            if(moduleClassID.equals(membershipServiceMonitorClassID)) return "Membership";
            
            if(moduleClassID.equals(rendezvousServiceMonitorClassID)) return "Rendezvous";
            
            if(moduleClassID.equals(peerinfoServiceMonitorClassID)) return "PeerInfo";
            
            if(moduleClassID.equals(endpointServiceMonitorClassID)) return "Endpoint";
            
            if(moduleClassID.equals(transportServiceMonitorClassID)) return "Transport";
            
            if(moduleClassID.equals(routerServiceMonitorClassID)) return "monitor";
            
            if(moduleClassID.equals(tlsProtoServiceMonitorClassID)) return "Tls";
            
            if(moduleClassID.equals(proxyServiceMonitorClassID)) return "Proxy";
            
            if(moduleClassID.equals(relayServiceMonitorClassID)) return "Relay";
            
            return null;
        }
        
        
}