endpointserviceinterface.java

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

        // In the future, interface objects may refer to a group context that is not necessarily the group where
        // "therealThing" lives. When that happens, this interface object will have to know which group it works
        // for without asking "theRealThing".

        ChannelMessenger res = (ChannelMessenger) found.getChannelMessenger(theRealThing.getGroup().getPeerGroupID(),
                                                                            addr.getServiceName(), addr.getServiceParameter());

        synchronized(this) {

            // We have to check again. May be we did all that in parallel with some other thread and it beat
            // us to the finish line. In which case, substitute the existing one and throw ours away.

            Reference existing = (Reference) channelCache.get(addr);
            if (existing != null) {
                Messenger m = (Messenger) existing.get();
                if ((m != null) && ((m.getState() & Messenger.USABLE) != 0)) {
                    return m;
                }
            }

            // The listenerAdaptor of this interface obj is used to support the sendMessage-with-listener API.
            res.setMessageWatcher(listenerAdaptor);
            channelCache.put(res.getDestinationAddressObject(), new WeakReference(res));
        }

        return res;
    }

    /**
     *  {@inheritDoc}
     **/
    public Messenger getMessenger( EndpointAddress addr, Object hint ) {
        
        // Get an unresolved messenger (that's immediate).
        Messenger m = getMessengerImmediate(addr, hint);
        if (m == null) {
            return null;
        }

        // Now ask the messenger to resolve: this legacy blocking API ensures that
        // only successfully resolved messengers are ever returned.
        m.resolve();
        try {
            m.waitState(Messenger.RESOLVED | Messenger.TERMINAL, TimeUtils.AMINUTE);
        } catch (InterruptedException ie) {
            Thread.interrupted();         // Do the mythology thing.
        }


        // See how it went
        int state = m.getState();
        if ((state & Messenger.TERMINAL) != 0) {
           return null;
        }
        if ((state & Messenger.RESOLVED) == 0) { // Not failed yet. But too late for us.
            return null;
        }

        // Okay, good for vanilla application consumption.
        return m;
    }

    /**
     * {@inheritDoc}
     **/
    public void propagate( Message srcMsg, String serviceName, String serviceParam) throws IOException {
        theRealThing.propagate(srcMsg, serviceName, serviceParam);
    }
    
    /**
     * {@inheritDoc}
     **/
    public void demux(Message msg) {
        theRealThing.demux(msg);
    }
    
    /**
     * {@inheritDoc}
     **/
    public void processIncomingMessage(Message message, EndpointAddress source, EndpointAddress destination) {
        theRealThing.processIncomingMessage( message, source, destination );
    }
    
    /**
     * {@inheritDoc}
     **/
    public boolean ping(EndpointAddress addr) {
        return theRealThing.ping(addr);
    }
    
    /**
     * {@inheritDoc}
     **/
    public MessengerEventListener addMessageTransport( MessageTransport transpt ) {
        // FIXME TOO: We should probably make the interface refuse to do it.
        // But that will have to wait until we have criteria to decide who
        // gets an interface object and who gets the real thing. In the
        // meantime just do it.
        
        return theRealThing.addMessageTransport( transpt );
    }
    
    /**
     * {@inheritDoc}
     **/
    public boolean removeMessageTransport( MessageTransport transpt ) {
        // FIXME TOO: We should probably make the interface refuse to do it.
        // But that will have to wait until we have criteria to decide who
        // gets an interface object and who gets the real thing. In the
        // meantime just do it.
        
        return theRealThing.removeMessageTransport( transpt );
    }
    
    /**
     * {@inheritDoc}
     **/
    public Iterator getAllMessageTransports() {
        return theRealThing.getAllMessageTransports();
    }

    /**
     * {@inheritDoc}
     **/
    public MessageTransport getMessageTransport(String name) {
        return theRealThing.getMessageTransport(name);
    }
    
    /**
     * {@inheritDoc}
     **/
    public boolean addIncomingMessageListener( EndpointListener listener, String serviceName, String serviceParam ) {
        
        return theRealThing.addIncomingMessageListener( listener, serviceName, serviceParam );
    }
    
    /**
     * {@inheritDoc}
     **/
    public void addIncomingMessageFilterListener(MessageFilterListener listener, String namespace, String name) {
        theRealThing.addIncomingMessageFilterListener( listener, namespace, name );
    }
    
    /**
     * {@inheritDoc}
     **/
    public void addOutgoingMessageFilterListener( MessageFilterListener listener, String namespace, String name ) {
        theRealThing.addOutgoingMessageFilterListener( listener, namespace, name );
    }
    
    /**
     * {@inheritDoc}
     **/
    public MessageFilterListener removeIncomingMessageFilterListener( MessageFilterListener listener, String namespace, String name ) {
        return theRealThing.removeIncomingMessageFilterListener( listener, namespace, name );
    }
    
    /**
     * {@inheritDoc}
     **/
    public MessageFilterListener removeOutgoingMessageFilterListener( MessageFilterListener listener, String namespace, String name ) {
        return theRealThing.removeOutgoingMessageFilterListener( listener, namespace, name );
    }
    
    /**
     * {@inheritDoc}
     **/
    public EndpointListener removeIncomingMessageListener(String serviceName, String serviceParam) {
        return theRealThing.removeIncomingMessageListener( serviceName, serviceParam );
    }
    
    /**
     * {@inheritDoc}
     **/
    public boolean addMessengerEventListener(MessengerEventListener listener, int prio) {
        return theRealThing.addMessengerEventListener( listener, prio );
    }
    
    /**
     * {@inheritDoc}
     **/
    public boolean removeMessengerEventListener( MessengerEventListener listener, int prio ) {
        return theRealThing.removeMessengerEventListener( listener, prio );
    }
    
    // We do not have much choice here, since applications are supposed to ditch interface objects without much thinking. Note:
    // this will never happen if, by any chance listenerAdaptor has a direct or indirect ref to this.
    public void finalize() {
        listenerAdaptor.shutdown();
    }
        
    /**
     * {@inheritDoc}
     *
     * @deprecated legacy support
     **/
    public boolean getMessenger(MessengerEventListener listener, EndpointAddress addr, Object hint) {

        Messenger m = getMessengerImmediate(addr, hint);
        if (m == null) {
            return false;
        }
        
        if (! listenerAdaptor.watchMessenger(listener, m)) {
            return false;
        }


        // Make sure that resolution is being attempted if not already
        // in progress.

        m.resolve();

        return true;
    }

    
    /**
     * {@inheritDoc}
     * @deprecated legacy support
     **/
    public Messenger getMessenger( EndpointAddress addr ) {
        return getMessenger(addr, null);
    }
}