org.jgroups.blocks.RpcDispatcher Java Examples

/** Main processing method for the SocketOpener object */
public void run()
{
    try
    {

        //String props="UDP(mcast_addr=" + ilca.getUdpMulticastAddr() +
        // ";mcast_port=" + ilca.getUdpMulticastPort()+
        // "):PING:MERGE2(min_interval=5000;max_interval=10000):FD:STABLE:NAKACK:UNICAST:FLUSH:GMS:VIEW_ENFORCER:QUEUE";
        rpcCh = new JChannel( ilca.getJGChannelProperties() );
        rpcCh.setOpt( Channel.LOCAL, Boolean.FALSE );
        disp = new RpcDispatcher( rpcCh, null, null, ilcl );
        rpcCh.connect( groupName );

        if ( log.isInfoEnabled() )
        {
            log.info( "Is Connected = " + rpcCh.isConnected() );
        }

    }
    catch ( Exception e )
    {
        log.error( "Problem getting dispatcher.", e );
    }
}
 

/**
 * Constructor for the SocketOpener object
 *
 * @param ilcl
 * @param ilca
 * @param timeOut
 * @param groupName
 * @return
 */
public static RpcDispatcher openSocket( ILateralCacheJGListener ilcl, ILateralCacheAttributes ilca, int timeOut,
                                       String groupName )
{
    JGRpcOpener opener = new JGRpcOpener( ilcl, ilca, groupName );
    Thread t = new Thread( opener );
    t.start();
    try
    {
        t.join( timeOut );
    }
    catch ( InterruptedException ire )
    {
        log.error( ire );
    }
    return opener.getSocket();
}
 

/**
 * {@inheritDoc}
 */
public void startup() throws Throwable
{
   disp = new RpcDispatcher(channel, null, this, this);

   disp.setMethodLookup(new MethodLookup()
   {
      @Override
      public Method findMethod(short key)
      {
         return methods.get(key);
      }
   });

   if (clusterName == null)
      clusterName = "jca";


   channel.connect(clusterName);
}
 

/**
 * Creates an rpc dispatcher used by this transport
 * @return an rpc dispatcher
 */
protected RpcDispatcher createRpcDispatcher()
{
   RpcDispatcher dispatcher = new RpcDispatcher(channel, null, this, this);

   dispatcher.setMethodLookup(new MethodLookup()
   {
      @Override
      public Method findMethod(short key)
      {
         return methods.get(key);
      }
   });
   return dispatcher;
}
 

public void setApplicationProperty(Long sessionId, String key, String value) {
	try {
		RpcDispatcher dispatcher = getDispatcher();
		if (dispatcher != null)
			dispatcher.callRemoteMethods(null, "setApplicationProperty", new Object[] { sessionId, key, value }, new Class[] { Long.class, String.class, String.class }, SolverServerImplementation.sAllResponses);
		else
			iServer.setApplicationProperty(sessionId, key, value);
	} catch (Exception e) {
		sLog.error("Failed to update the application property " + key + " along the cluster: " + e.getMessage(), e);
	}
}
 

public void setLoggingLevel(String name, Integer level) {
	try {
		RpcDispatcher dispatcher = getDispatcher();
		if (dispatcher != null)
			dispatcher.callRemoteMethods(null, "setLoggingLevel", new Object[] { name, level }, new Class[] { String.class, Integer.class }, SolverServerImplementation.sAllResponses);
		else
			iServer.setLoggingLevel(name, level);
	} catch (Exception e) {
		sLog.error("Failed to update the logging level for " + name + " along the cluster: " + e.getMessage(), e);
	}
}
 

/**
 * Gets the Dispatcher attribute of the JGConnectionHolder object
 *
 * @return The Dispatcher value
 * @throws IOException
 */
public synchronized RpcDispatcher getDispatcher()
    throws IOException
{
    if ( log.isDebugEnabled() )
    {
        log.debug( "Creating Dispatcher, jgroups group name " + IJGConstants.RPC_JG_GROUP_NAME );
    }

    try
    {
        if ( disp == null )
        {
            synchronized ( JGConnectionHolder.class )
            {
                if ( disp == null )
                {
                    disp = JGRpcOpener.openSocket( (ILateralCacheJGListener) LateralGroupCacheJGListener
                        .getInstance( ilca ), ilca, 5000, IJGConstants.RPC_JG_GROUP_NAME );
                }
            }
        }
    }
    catch ( Exception e )
    {
        log.error( "Problem creating dispatcher", e );
    }
    return disp;
}
 

public OnlineStudentSchedulingGenericUpdater(RpcDispatcher dispatcher, OnlineStudentSchedulingContainerRemote container) {
	super();
	iDispatcher = dispatcher;
	iContainer = container;
	setDaemon(true);
	setName("Updater[generic]");
	iSleepTimeInSeconds = ApplicationProperty.OnlineSchedulingQueueLoadInterval.intValue(); 
	iLog = Logger.getLogger(OnlineStudentSchedulingGenericUpdater.class + ".updater[generic]"); 
}
 

private RpcDispatcher getDispatcher() {
	if (iServer instanceof SolverServerImplementation)
		return ((SolverServerImplementation)iServer).getDispatcher();
	return null;
}
 

public RpcDispatcher getDispatcher() {
	return iDispatcher;
}
 

public RpcDispatcher getDispatcher() {
	return iDispatcher;
}
 

@Override
public RpcDispatcher getDispatcher() { return iDispatcher; }
 

@Override
public RpcDispatcher getDispatcher() {
	return iDispatcher;
}
 

@Override
public RpcDispatcher getDispatcher() { return iDispatcher; }
 

@Override
public RpcDispatcher getDispatcher() { return iDispatcher; }
 

@Override
public RpcDispatcher getDispatcher() { return iDispatcher; }
 

public SolverContainerWrapper(RpcDispatcher dispatcher, RemoteSolverContainer<T> container, boolean checkLocal) {
	iDispatcher = dispatcher;
	iContainer = container;
	iCheckLocal = checkLocal;
}
 

@Override
public RpcDispatcher getDispatcher() { return iDispatcher; }
 

/**
 * Gets the socket attribute of the SocketOpener object
 *
 * @return
 */
public RpcDispatcher getSocket()
{
    return disp;
}
 

public RpcDispatcher getDispatcher(); 

public RpcDispatcher getDispatcher() { return iDispatcher; }