monitorresources.java

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

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