resolverserviceimpl.java

jxta平台的开发包

            if(!endpoint.addIncomingMessageListener(responseListener, handlerName, inQueName)) {
                if (LOG.isEnabledFor(Level.ERROR)) {
                    LOG.error("Cannot register listener (already registered)");
                }
            } else {
                if (null != rendezvous) {
                    if(!rendezvous.addPropagateListener(handlerName + inQueName, responseListener)) {
                        if (LOG.isEnabledFor(Level.ERROR)) {
                            LOG.error("Cannot register listener (already registered)");
                        }
                    }
                } else {
                    if (LOG.isEnabledFor(Level.ERROR)) {
                        LOG.error("Failed to register response listener (null rendezvous service)");
                    }
                }
            }

            // Register SRDI Listener
            if (null != rendezvous) {
                srdiListener = new DemuxSrdi();

                if(!endpoint.addIncomingMessageListener(srdiListener, handlerName, srdiQueName)) {
                    if (LOG.isEnabledFor(Level.ERROR)) {
                        LOG.error("Cannot register listener (already registered)");
                    }
                } else {
                    if(!rendezvous.addPropagateListener(handlerName + srdiQueName, srdiListener)) {
                        if (LOG.isEnabledFor(Level.ERROR)) {
                            LOG.error("Cannot register listener (already registered)");
                        }
                    }
                }
            }
        } catch (Exception e) {
            if (LOG.isEnabledFor(Level.ERROR)) {
                LOG.error("failed to add listeners", e);
            }

            return -1;
        }

        routeControl = getRouteControl();

        synchronized (this) {
            membershipCredListener = new CredentialListener();
            membership.addPropertyChangeListener("defaultCredential", membershipCredListener);

            try {
                credential = membership.getDefaultCredential();

                if (null != credential) {
                    credentialDoc = credential.getDocument(MimeMediaType.XMLUTF8);
                } else {
                    credentialDoc = null;
                }
            } catch (Exception all) {
                if (LOG.isEnabledFor(Level.WARN)) {
                    LOG.warn("could not get credential", all);
                }
            }
        }

        return 0;
    }

    private RouteControl getRouteControl() {
        // FIXME tra 20031102 Until the new subscription service is implemented,
        // we use the Router Control IOCTL
        //
        // Obtain the route control object to manipulate route information when
        // sending and receiving resolver queries.

        if (routeControl == null)  {// insignificant race condition here
            // insignificant race condition here
            MessageTransport endpointRouter = (MessageTransport) endpoint.getMessageTransport("jxta");
            if (endpointRouter != null) {
                routeControl = (RouteControl) endpointRouter.transportControl(EndpointRouter.GET_ROUTE_CONTROL, null);
            } else {
                if (LOG.isEnabledFor(Level.WARN)) {
                    LOG.warn("Failed to get RouteControl object. Resolver will not set route hints.");
                }
            }
        }
        return routeControl;
    }
    /**
     * {@inheritDoc}
     */
    public void stopApp() {

        endpoint.removeIncomingMessageListener(handlerName, outQueName);
        endpoint.removeIncomingMessageListener(handlerName, inQueName);

        if (rendezvous != null) {
            rendezvous.removePropagateListener(handlerName + outQueName, queryListener);
            rendezvous.removePropagateListener(handlerName + inQueName, responseListener);
        }

        if(null != srdiListener) {
            endpoint.removeIncomingMessageListener(handlerName, srdiQueName);
            rendezvous.removePropagateListener(handlerName + srdiQueName, srdiListener);
        }

        queryListener = null;
        responseListener = null;
        srdiListener = null;

        membership.removePropertyChangeListener("defaultCredential", membershipCredListener);
        membershipCredListener = null;

        routeControl = null;
        rendezvous = null;
        membership = null;
        myGroup = null;
    }

    /**
     * {@inheritDoc}
     */
    public synchronized Service getInterface() {
        if (resolverInterface == null) {
            resolverInterface = new ResolverServiceInterface(this);
        }

        return resolverInterface;
    }

    /**
     * {@inheritDoc}
     */
    public Advertisement getImplAdvertisement() {
        return implAdvertisement;
    }

    /**
     * {@inheritDoc}
     */
    public QueryHandler registerHandler(String name, QueryHandler handler) {
        if (ResolverMeterBuildSettings.RESOLVER_METERING && (resolverServiceMonitor != null)) {
            resolverServiceMonitor.registerQueryHandlerMeter(name);
        }

        return (QueryHandler) handlers.put(name, handler);
    }

    /**
     * {@inheritDoc}
     */
    public QueryHandler unregisterHandler(String name) {
        if (ResolverMeterBuildSettings.RESOLVER_METERING && (resolverServiceMonitor != null)) {
            resolverServiceMonitor.unregisterQueryHandlerMeter(name);
        }

        return (QueryHandler) handlers.remove(name);
    }

    /**
     * given a name returns the query handler associated with it
     */
    public QueryHandler getHandler(String name) {
        return (QueryHandler) handlers.get(name);
    }

    /**
     * {@inheritDoc}
     */
    public SrdiHandler registerSrdiHandler(String name, SrdiHandler handler) {
        if (ResolverMeterBuildSettings.RESOLVER_METERING && (resolverServiceMonitor != null)) {
            resolverServiceMonitor.registerSrdiHandlerMeter(name);
        }

        return (SrdiHandler) srdiHandlers.put(name, handler);
    }

    /**
     * {@inheritDoc}
     */
    public SrdiHandler unregisterSrdiHandler(String name) {
        if (ResolverMeterBuildSettings.RESOLVER_METERING && (resolverServiceMonitor != null)) {
            resolverServiceMonitor.unregisterSrdiHandlerMeter(name);
        }

        return (SrdiHandler) srdiHandlers.remove(name);
    }

    /**
     * given a name returns the srdi handler associated with it
     */
    public SrdiHandler getSrdiHandler(String name) {
        return (SrdiHandler) srdiHandlers.get(name);
    }

    /**
     * {@inheritDoc}
     */
    public void sendQuery(String destPeer, ResolverQueryMsg query) {

        if (LOG.isEnabledFor(Level.DEBUG)) {
            LOG.debug("sending query to resolver handler: " + query.getHandlerName());
        }

        // NOTE: Add route information about the issuing peer, so the
        // resolver query responding peer can respond to the issuer without
        // requiring any route discovery. In most case the responding peer
        // is unlikely to know the route to the query issuer. This is a good
        // optimization for edge peers. This optimzation is much less
        // important for RDV peers as they are more likely to have a route
        // to peers. Also, there is the concern that adding route info
        // in resolver query exchanged between RDV will increase overhead due
        // to the larger amount of information exchanged between RDV.
        // Only update query if the query does not already contain any route
        // information. We are mostly interested in the original src
        // route information.
        if (query.getSrcPeerRoute() == null) {
            if (getRouteControl() != null) {
                // FIXME tra 20031102 Until the new subscription service
                // is implemented, we use the Router Control IOCTL
                RouteAdvertisement route = routeControl.getMyLocalRoute();
                if (route != null) {
                    query.setSrcPeerRoute((RouteAdvertisement) route.clone());
                }
                if (LOG.isEnabledFor(Level.DEBUG)) {
                    LOG.debug("Sending query with route info to " + route.getDestPeerID());
                }
            }
        }

        String queryHandlerName = query.getHandlerName();
        QueryHandlerMeter queryHandlerMeter = null;

        if (ResolverMeterBuildSettings.RESOLVER_METERING && (resolverServiceMonitor != null)) {
            queryHandlerMeter = resolverServiceMonitor.getQueryHandlerMeter(queryHandlerName);
        }

        if (destPeer == null) {
            try {
                Message queryMsg = new Message();

                XMLDocument asDoc = (XMLDocument) query.getDocument(MimeMediaType.XMLUTF8);
                MessageElement docElem = new TextDocumentMessageElement(outQueName, asDoc, null);
                queryMsg.addMessageElement("jxta", docElem);

                if (null != rendezvous) {
                    // Walk the message
                    rendezvous.walk((Message) queryMsg.clone(), handlerName, outQueName, RendezVousService.DEFAULT_TTL);

                    // propagate to local net as well
                    rendezvous.propagateToNeighbors(queryMsg, handlerName, outQueName, 2);
                } else {
                    endpoint.propagate(queryMsg, handlerName, outQueName);
                }

                if (ResolverMeterBuildSettings.RESOLVER_METERING && (queryHandlerMeter != null)) {
                    queryHandlerMeter.querySentInGroup(query);
                }
            } catch (IOException e) {
                if (ResolverMeterBuildSettings.RESOLVER_METERING && (queryHandlerMeter != null)) {
                    queryHandlerMeter.queryPropagateError();
                }

                if (LOG.isEnabledFor(Level.WARN)) {
                    LOG.warn("Failure during propagate", e);
                }
            }
        } else {
            // unicast instead
            try {
                boolean success = sendMessage(destPeer,
                                              handlerName,
                                              outQueName,
                                              outQueName,
                                              (XMLDocument) query.getDocument(MimeMediaType.XMLUTF8),
                                              false);

                if (ResolverMeterBuildSettings.RESOLVER_METERING && (queryHandlerMeter != null)) {
                    if (success) {
                        queryHandlerMeter.querySentViaUnicast(destPeer, query);
                    } else {
                        queryHandlerMeter.querySendError();
                    }
                }
            } catch (IOException e) {
                if (ResolverMeterBuildSettings.RESOLVER_METERING && (queryHandlerMeter != null)) {
                    queryHandlerMeter.querySendError();
                }
                if (LOG.isEnabledFor(Level.WARN)) {
                    LOG.warn("Failure while unicasting query", e);
                }
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    public void sendResponse(String destPeer, ResolverResponseMsg response) {

        if (destPeer == null) {
            if (rendezvous == null) {
                return;
            }

            propagateResponse(response);
        } else {
            String queryHandlerName = response.getHandlerName();
            QueryHandlerMeter queryHandlerMeter = null;

            try {
                if (ResolverMeterBuildSettings.RESOLVER_METERING && (resolverServiceMonitor != null)) {
                    queryHandlerMeter = resolverServiceMonitor.getQueryHandlerMeter(queryHandlerName);
                }

                // Check if an optional route information is
                // available to send the response
                RouteAdvertisement route = response.getSrcPeerRoute();

                if (route == null) {
                    if (LOG.isEnabledFor(Level.DEBUG)) {
                        LOG.debug("No route info available to send a response");
                    }
                } else { 
                    // ok we have a route let's pass it to the router
                    if ((null == getRouteControl()) || (routeControl.addRoute(route) == RouteControl.FAILED)) {
                        if (LOG.isEnabledFor(Level.WARN)) {
                            LOG.warn("Failed to add route " + route.display());
                        }
                    } else {
                        if (LOG.isEnabledFor(Level.DEBUG)) {