Package org.jboss.remoting.callback

Examples of org.jboss.remoting.callback.InvokerCallbackHandler


                                        obj);
              
               callbackRequest.setReturnPayload(callbackHandleObject);
            }
           
            InvokerCallbackHandler callbackHandler = callbackContainer.getCallbackHandler();
           
            callbackHandler.handleCallback(callbackRequest);
         }
         else
         {
            log.error("Could not find callback handler to call upon for handleCallback " +
                      "where session id equals " + sessionId);
         }
      }
      else if(InternalInvocation.ADDLISTENER.equals(methodName))
      {
         if(handler == null)
         {
            throw new InvalidConfigurationException(
               "Can not accept a callback listener since there are no ServerInvocationHandlers " +
               "registered. Please add via xml configuration or via the Connector's " +
               "addInvocationHandler() method.");

         }
         InvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         handler.addListener(callbackHandler);
      }
      else if(InternalInvocation.REMOVELISTENER.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = removeCallbackHandler(invocation);
         if(callbackHandler != null)
         {
            if(handler == null)
            {
               throw new InvalidConfigurationException(
                  "Can not remove a callback listener since there are no ServerInvocationHandlers " +
                  "registered.  Please add via xml configuration or via the Connector's " +
                  "addInvocationHandler() method.");
            }
            handler.removeListener(callbackHandler);

            if(trace) { log.trace("ServerInvoker (" + this + ") removing server callback handler " + callbackHandler + "."); }

            callbackHandler.destroy();
         }
         else
         {
            String sessionId = ServerInvokerCallbackHandler.getId(invocation);
            throw new RuntimeException("Can not remove callback listener from target server with " +
               "id of " + sessionId + " as it does not exist as a registered callback listener.");
         }
      }
      else if(InternalInvocation.GETCALLBACKS.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         if(trace) { log.trace("ServerInvoker (" + this + ") getting callbacks for callback handler " + callbackHandler + "."); }
         result = callbackHandler.getCallbacks();
      }
      else if(InternalInvocation.ACKNOWLEDGECALLBACK.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         if(trace) { log.trace("ServerInvoker (" + this + ") acknowledge callback on callback handler " + callbackHandler + "."); }
         callbackHandler.acknowledgeCallbacks(param);
      }
      else if(InternalInvocation.ADDCLIENTLISTENER.equals(methodName))
      {
         String sessionId = ServerInvokerCallbackHandler.getId(invocation);
         Object[] params = param.getParameters();

         // the only elements should be the callback handler and possibly the callback handle object
         if(params == null || params.length < 0 || params.length > 3)
         {
            log.error("Recieved addClientListener InternalInvocation, but getParameters() " +
                      "returned: " + params);
            throw new RuntimeException(
               "InvokerCallbackHandler and callback handle object (optional) must be supplied as " +
               "the only parameter objects within the InternalInvocation when calling " +
               "addClientListener.");
         }

         InvokerCallbackHandler callbackHandler = (InvokerCallbackHandler)params[0];
         Object callbackHandleObject = params[1];
         CallbackContainer callbackContainer =
            new CallbackContainer(callbackHandler, callbackHandleObject);                         
        
         clientCallbackListener.put(sessionId, callbackContainer);
View Full Code Here


                                        obj);
              
               callbackRequest.setReturnPayload(callbackHandleObject);
            }
           
            InvokerCallbackHandler callbackHandler = callbackContainer.getCallbackHandler();
           
            callbackHandler.handleCallback(callbackRequest);
         }
         else
         {
            log.error("Could not find callback handler to call upon for handleCallback " +
                      "where session id equals " + sessionId);
         }
      }
      else if(InternalInvocation.ADDLISTENER.equals(methodName))
      {
         if(handler == null)
         {
            throw new InvalidConfigurationException(
               "Can not accept a callback listener since there are no ServerInvocationHandlers " +
               "registered. Please add via xml configuration or via the Connector's " +
               "addInvocationHandler() method.");

         }
         InvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         handler.addListener(callbackHandler);
      }
      else if(InternalInvocation.REMOVELISTENER.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = removeCallbackHandler(invocation);
         if(callbackHandler != null)
         {
            if(handler == null)
            {
               throw new InvalidConfigurationException(
                  "Can not remove a callback listener since there are no ServerInvocationHandlers " +
                  "registered.  Please add via xml configuration or via the Connector's " +
                  "addInvocationHandler() method.");
            }
            handler.removeListener(callbackHandler);

            if(trace) { log.trace("ServerInvoker (" + this + ") removing server callback handler " + callbackHandler + "."); }

            callbackHandler.destroy();
         }
         else
         {
            String sessionId = ServerInvokerCallbackHandler.getId(invocation);
            throw new RuntimeException("Can not remove callback listener from target server with " +
               "id of " + sessionId + " as it does not exist as a registered callback listener.");
         }
      }
      else if(InternalInvocation.GETCALLBACKS.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         if(trace) { log.trace("ServerInvoker (" + this + ") getting callbacks for callback handler " + callbackHandler + "."); }
         result = callbackHandler.getCallbacks(invocation.getRequestPayload());
      }
      else if(InternalInvocation.ACKNOWLEDGECALLBACK.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         if(trace) { log.trace("ServerInvoker (" + this + ") acknowledge callback on callback handler " + callbackHandler + "."); }
         callbackHandler.acknowledgeCallbacks(param);
      }
      else if(InternalInvocation.ADDCLIENTLISTENER.equals(methodName))
      {
         String sessionId = ServerInvokerCallbackHandler.getId(invocation);
         Object[] params = param.getParameters();

         // the only elements should be the callback handler and possibly the callback handle object
         if(params == null || params.length < 0 || params.length > 3)
         {
            log.error("Recieved addClientListener InternalInvocation, but getParameters() " +
                      "returned: " + params);
            throw new RuntimeException(
               "InvokerCallbackHandler and callback handle object (optional) must be supplied as " +
               "the only parameter objects within the InternalInvocation when calling " +
               "addClientListener.");
         }

         InvokerCallbackHandler callbackHandler = (InvokerCallbackHandler)params[0];
         Object callbackHandleObject = params[1];
         CallbackContainer callbackContainer =
            new CallbackContainer(callbackHandler, callbackHandleObject);                         
        
         clientCallbackListener.put(sessionId, callbackContainer);
View Full Code Here

         Collection holders = localServerLocators.values();
         Iterator itr = holders.iterator();
         while(itr.hasNext())
         {
            CallbackHandlerHolder holder = (CallbackHandlerHolder)itr.next();
            InvokerCallbackHandler holderhandler = holder.getHandler();
            boolean handlersEqual = holderhandler.equals(callbackhandler);
            InvokerLocator handlerLocator = holder.getLocator();
            boolean locatorsEqual = handlerLocator.equals(locator);
            if(handlersEqual && locatorsEqual)
            {
               // the entry already exists for this pair, so return null
View Full Code Here

               if (!sessionId.equals(prefix))
                  continue;
               if (index >= 0)
                  listenerId = listenerId.substring(index + 1);
               CallbackHandlerHolder holder = (CallbackHandlerHolder) entry.getValue();
               InvokerCallbackHandler holderHandler = holder.getHandler();
               if(holderHandler.equals(handler))
               {
                  CallbackLocatorHolder locatorHolder = new CallbackLocatorHolder(listenerId, holder.getLocator());
                  holderList.add(locatorHolder);
               }
            }
View Full Code Here

                                        obj);
              
               callbackRequest.setReturnPayload(callbackHandleObject);
            }
           
            InvokerCallbackHandler callbackHandler = callbackContainer.getCallbackHandler();
           
            callbackHandler.handleCallback(callbackRequest);
         }
         else
         {
            log.error("Could not find callback handler to call upon for handleCallback " +
                      "where session id equals " + sessionId);
         }
      }
      else if(InternalInvocation.ADDLISTENER.equals(methodName))
      {
         if(handler == null)
         {
            throw new InvalidConfigurationException(
               "Can not accept a callback listener since there are no ServerInvocationHandlers " +
               "registered. Please add via xml configuration or via the Connector's " +
               "addInvocationHandler() method.");

         }
         ServerInvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         if (registerCallbackListeners)
         {
            connectionNotifier.addListenerFirst(callbackHandler);
         }
         handler.addListener(callbackHandler);
      }
      else if(InternalInvocation.REMOVELISTENER.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = removeCallbackHandler(invocation);
         if(callbackHandler != null)
         {
            if(handler == null)
            {
               throw new InvalidConfigurationException(
                  "Can not remove a callback listener since there are no ServerInvocationHandlers " +
                  "registered.  Please add via xml configuration or via the Connector's " +
                  "addInvocationHandler() method.");
            }
            if (registerCallbackListeners)
            {
               connectionNotifier.removeListener(callbackHandler);
            }
            handler.removeListener(callbackHandler);

            if(trace) { log.trace("ServerInvoker (" + this + ") removing server callback handler " + callbackHandler + "."); }

            callbackHandler.destroy();
         }
         else
         {
            String sessionId = ServerInvokerCallbackHandler.getId(invocation);
            throw new RuntimeException("Can not remove callback listener from target server with " +
               "id of " + sessionId + " as it does not exist as a registered callback listener.");
         }
      }
      else if(InternalInvocation.GETCALLBACKS.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         if(trace) { log.trace("ServerInvoker (" + this + ") getting callbacks for callback handler " + callbackHandler + "."); }
         result = callbackHandler.getCallbacks(invocation.getRequestPayload());
      }
      else if(InternalInvocation.ACKNOWLEDGECALLBACK.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         if(trace) { log.trace("ServerInvoker (" + this + ") acknowledge callback on callback handler " + callbackHandler + "."); }
         callbackHandler.acknowledgeCallbacks(param);
      }
      else if(InternalInvocation.ADDCLIENTLISTENER.equals(methodName))
      {
         String sessionId = ServerInvokerCallbackHandler.getId(invocation);
         Object[] params = param.getParameters();

         // the only elements should be the callback handler and possibly the callback handle object
         if(params == null || params.length < 0 || params.length > 3)
         {
            log.error("Recieved addClientListener InternalInvocation, but getParameters() " +
                      "returned: " + params);
            throw new RuntimeException(
               "InvokerCallbackHandler and callback handle object (optional) must be supplied as " +
               "the only parameter objects within the InternalInvocation when calling " +
               "addClientListener.");
         }

         InvokerCallbackHandler callbackHandler = (InvokerCallbackHandler)params[0];
         Object callbackHandleObject = params[1];
         CallbackContainer callbackContainer =
            new CallbackContainer(callbackHandler, callbackHandleObject);                         
        
         clientCallbackListener.put(sessionId, callbackContainer);
View Full Code Here

         Collection holders = localServerLocators.values();
         Iterator itr = holders.iterator();
         while(itr.hasNext())
         {
            CallbackHandlerHolder holder = (CallbackHandlerHolder)itr.next();
            InvokerCallbackHandler holderhandler = holder.getHandler();
            boolean handlersEqual = holderhandler.equals(callbackhandler);
            InvokerLocator handlerLocator = holder.getLocator();
            boolean locatorsEqual = handlerLocator.equals(locator);
            if(handlersEqual && locatorsEqual)
            {
               // the entry already exists for this pair, so return null
View Full Code Here

               if (!sessionId.equals(prefix))
                  continue;
               if (index >= 0)
                  listenerId = listenerId.substring(index + 1);
               CallbackHandlerHolder holder = (CallbackHandlerHolder) entry.getValue();
               InvokerCallbackHandler holderHandler = holder.getHandler();
               if(holderHandler.equals(handler))
               {
                  CallbackLocatorHolder locatorHolder = new CallbackLocatorHolder(listenerId, holder.getLocator());
                  holderList.add(locatorHolder);
               }
            }
View Full Code Here

                                        obj);
              
               callbackRequest.setReturnPayload(callbackHandleObject);
            }
           
            InvokerCallbackHandler callbackHandler = callbackContainer.getCallbackHandler();
           
            callbackHandler.handleCallback(callbackRequest);
         }
         else
         {
            log.error("Could not find callback handler to call upon for handleCallback " +
                      "where session id equals " + sessionId);
         }
      }
      else if(InternalInvocation.ADDLISTENER.equals(methodName))
      {
         if(handler == null)
         {
            throw new InvalidConfigurationException(
               "Can not accept a callback listener since there are no ServerInvocationHandlers " +
               "registered. Please add via xml configuration or via the Connector's " +
               "addInvocationHandler() method.");

         }
         ServerInvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         if (registerCallbackListeners)
         {
            connectionNotifier.addListenerFirst(callbackHandler);
            if(leasePeriod > 0)
            {
               leaseManagement = true;
            }
         }
         handler.addListener(callbackHandler);
      }
      else if(InternalInvocation.REMOVELISTENER.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = removeCallbackHandler(invocation);
         if(callbackHandler != null)
         {
            if (registerCallbackListeners)
            {
//               connectionNotifier.removeListener(callbackHandler);
               removeConnectionListener(callbackHandler);
            }
           
            callbackHandler.destroy();
           
            if(handler == null)
            {
               throw new InvalidConfigurationException(
                  "Can not remove a callback listener since there are no ServerInvocationHandlers " +
                  "registered.  Please add via xml configuration or via the Connector's " +
                  "addInvocationHandler() method.");
            }
           
            handler.removeListener(callbackHandler);

            if(trace) { log.trace("ServerInvoker (" + this + ") removing server callback handler " + callbackHandler + "."); }
         }
         else
         {
            String sessionId = ServerInvokerCallbackHandler.getId(invocation);
            throw new RuntimeException("Can not remove callback listener from target server with " +
               "id of " + sessionId + " as it does not exist as a registered callback listener.");
         }
      }
      else if(InternalInvocation.GETCALLBACKS.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         if(trace) { log.trace("ServerInvoker (" + this + ") getting callbacks for callback handler " + callbackHandler + "."); }
         result = callbackHandler.getCallbacks(invocation.getRequestPayload());
      }
      else if(InternalInvocation.ACKNOWLEDGECALLBACK.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         if(trace) { log.trace("ServerInvoker (" + this + ") acknowledge callback on callback handler " + callbackHandler + "."); }
         callbackHandler.acknowledgeCallbacks(param);
      }
      else if(InternalInvocation.ADDCLIENTLISTENER.equals(methodName))
      {
         String sessionId = ServerInvokerCallbackHandler.getId(invocation);
         Object[] params = param.getParameters();

         // the only elements should be the callback handler and possibly the callback handle object
         if(params == null || params.length < 0 || params.length > 3)
         {
            log.debug("Received addClientListener InternalInvocation, but getParameters() " +
                      "returned: " + params);
            throw new RuntimeException(
               "InvokerCallbackHandler and callback handle object (optional) must be supplied as " +
               "the only parameter objects within the InternalInvocation when calling " +
               "addClientListener.");
         }

         InvokerCallbackHandler callbackHandler = (InvokerCallbackHandler)params[0];
         Object callbackHandleObject = params[1];
         CallbackContainer callbackContainer =
            new CallbackContainer(callbackHandler, callbackHandleObject);                         
        
         clientCallbackListener.put(sessionId, callbackContainer);
View Full Code Here

            throw new InvalidConfigurationException("Can not accept a callback listener since there are no " +
                                                    "ServerInvocationHandlers registered.  Please add via xml configuration " +
                                                    "or via the Connector's addInvocationHandler() method.");

         }
         InvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         handler.addListener(callbackHandler);
      }
      else if(InternalInvocation.REMOVELISTENER.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = removeCallbackHandler(invocation);
         if(callbackHandler != null)
         {
            if(handler == null)
            {
               throw new InvalidConfigurationException("Can not remove a callback listener since there are no " +
                                                       "ServerInvocationHandlers registered.  Please add via xml configuration " +
                                                       "or via the Connector's addInvocationHandler() method.");
            }
            handler.removeListener(callbackHandler);
            if(log.isTraceEnabled())
            {
               log.trace("ServerInvoker (" + this + ") removing server callback handler " + callbackHandler + ".");
            }

            callbackHandler.destroy();
         }
         else
         {
            String sessionId = ServerInvokerCallbackHandler.getId(invocation);
            throw new RuntimeException("Can not remove callback listener from target server with id of " + sessionId + " as it does not exist as a registered callback listener.");
         }
      }
      else if(InternalInvocation.GETCALLBACKS.equals(methodName))
      {
         ServerInvokerCallbackHandler callbackHandler = getCallbackHandler(invocation);
         if(log.isTraceEnabled())
         {
            log.trace("ServerInvoker (" + this + ") getting callbacks for callback handler " + callbackHandler + ".");
         }

         result = callbackHandler.getCallbacks();
      }
      else if(InternalInvocation.ADDCLIENTLISTENER.equals(methodName))
      {
         String sessionId = ServerInvokerCallbackHandler.getId(invocation);
         Object[] params = param.getParameters();
         // the only elements should be the callback handler and possibly the callback handle object
         if(params == null || params.length < 0 || params.length > 3)
         {
            log.error("Recieved addClientListener InternalInvocation, but getParameters() " +
                      "returned: " + params);
            throw new RuntimeException("InvokerCallbackHandler and callback handle object (optional) must be supplied as the only " +
                                       "parameter objects within the InternalInvocation when " +
                                       "calling addClientListener.");
         }
         InvokerCallbackHandler callbackHandler = (InvokerCallbackHandler) params[0];
         Object callbackHandleObject = params[1];
         CallbackContainer callbackContainer = new CallbackContainer(callbackHandler, callbackHandleObject);
         clientCallbackListener.put(sessionId, callbackContainer);

         log.debug("ServerInvoker (" + this + ") added client callback handler " + callbackHandler + " with session id of " + sessionId +
                   " and callback handle object of " + callbackHandleObject + ".");

      }
      else if(InternalInvocation.REMOVECLIENTLISTENER.equals(methodName))
      {
         String sessionId = ServerInvokerCallbackHandler.getId(invocation);
         log.debug("ServerInvoker (" + this + ") removing client callback handler with session id of " + sessionId + ".");
         Object cbo = clientCallbackListener.remove(sessionId);
         if(cbo == null)
         {
            throw new RuntimeException("Can not remove callback listener from callback server with id of " + sessionId + " as it does not exist as a registered callback listener.");
         }

      }
      else if(InternalInvocation.HANDLECALLBACK.equals(methodName))
      {
         String sessionId = ServerInvokerCallbackHandler.getId(invocation);
         if(log.isTraceEnabled())
         {
            log.trace("ServerInvoker (" + this + ") is being asked to deliver callback on client callback handler with session id of " + sessionId + ".");
         }
         CallbackContainer callbackContainer = (CallbackContainer) clientCallbackListener.get(sessionId);
         if(callbackContainer != null && callbackContainer.getCallbackHandler() != null)
         {
            Object[] params = param.getParameters();
            Callback callbackRequest = (Callback) params[0];
            Map callbackHandleObject = callbackRequest.getReturnPayload();
            if(callbackHandleObject == null)
            {
               callbackHandleObject = new HashMap();
            }
            callbackHandleObject.put(Callback.CALLBACK_HANDLE_OBJECT_KEY, callbackContainer.getCallbackHandleObject());
            callbackRequest.setReturnPayload(callbackHandleObject);
            InvokerCallbackHandler callbackHandler = callbackContainer.getCallbackHandler();
            callbackHandler.handleCallback(callbackRequest);
         }
         else
         {
            log.error("Could not find callback handler to call upon for handleCallback " +
                      "where session id equals " + sessionId);
View Full Code Here

            try
            {
               Iterator it = callbackHandlers.iterator();
               while (it.hasNext())
               {
                  InvokerCallbackHandler callbackHandler = (InvokerCallbackHandler) it.next();
                  log.info("sending callback: " + ++counter);
                  callbackHandler.handleCallback(new Callback("callback"));
               }
               log.info("sent callback");
            }
            catch (HandleCallbackException e)
            {
View Full Code Here

TOP

Related Classes of org.jboss.remoting.callback.InvokerCallbackHandler

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.