KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > remoting > callback > pull > memory > callbackstore > JBossASCallbackTestClient


1 /*
2  * JBoss, the OpenSource J2EE webOS
3  *
4  * Distributable under LGPL license.
5  * See terms of license at gnu.org.
6  */

7 package org.jboss.remoting.callback.pull.memory.callbackstore;
8
9 import org.jboss.dtf.MultipleTestRunner;
10 import org.jboss.remoting.AbstractInvokerTest;
11 import org.jboss.remoting.Callback;
12 import org.jboss.remoting.Client;
13 import org.jboss.remoting.HandleCallbackException;
14 import org.jboss.remoting.InvocationRequest;
15 import org.jboss.remoting.InvokerCallbackHandler;
16 import org.jboss.remoting.InvokerLocator;
17 import org.jboss.remoting.transport.Connector;
18 import org.jboss.samples.callback.CallbackServer;
19
20 import java.util.List JavaDoc;
21
22 /**
23  * @author <a HREF="mailto:telrod@e2technologies.net">Tom Elrod</a>
24  */

25 public class JBossASCallbackTestClient
26 {
27    // Default locator values
28
private static String JavaDoc transport = "socket";
29    private static String JavaDoc host = "localhost";
30    private static int port = 5412;
31
32    private String JavaDoc locatorURI = null;
33
34    private Client remotingClient;
35    private CallbackHandler pullCallbackHandler;
36 // private PushCallbackHandler pushCallbackHandler;
37

38    private boolean isCallbackDone = false;
39
40    private int numberOfCallbacks = 520;
41
42    public JBossASCallbackTestClient(String JavaDoc name, String JavaDoc locatorURI)
43    {
44       this.locatorURI = locatorURI;
45    }
46
47    public void createRemotingClient() throws Exception JavaDoc
48    {
49       InvokerLocator locator = new InvokerLocator(locatorURI);
50       System.out.println("Calling remoting server with locator uri of: " + locatorURI);
51
52       // This could have been new Client(locator), but want to show that subsystem param is null
53
// Could have also been new Client(locator, "sample");
54
remotingClient = new Client(locator, null);
55
56    }
57
58    public void makeInvocation(String JavaDoc param) throws Throwable JavaDoc
59    {
60       Object JavaDoc response = remotingClient.invoke(param, null);
61       System.out.println("Invocation response: " + response);
62    }
63
64    public void testPullCallback() throws Throwable JavaDoc
65    {
66       createRemotingClient();
67       numberOfCallbacks = calculateNumberOfCallbacks();
68       System.out.println("Number of callbacks need to activate persitence: " + numberOfCallbacks);
69       pullCallbackHandler = new CallbackHandler();
70       // by passing only the callback handler, will indicate pull callbacks
71
remotingClient.addListener(pullCallbackHandler);
72
73 // setupCallbackServer();
74

75       // need to tell server handler how many
76
makeInvocation("" + numberOfCallbacks);
77
78       // now make invocation on server, which should cause a callback to happen
79
makeInvocation("Do something");
80
81       boolean didItWork = checkForCallback();
82
83       System.out.println("Did id work = " + didItWork);
84
85       int totalCallbacks = 0;
86       if(didItWork)
87       {
88          boolean gotExpectedException = false;
89
90          // now need to go get the callbacks until none left.
91
int callbacksReceived = getAllCallbacks();
92
93          System.out.println("callbacks received = " + callbacksReceived);
94          totalCallbacks = totalCallbacks + callbacksReceived;
95       }
96
97       System.out.println("total callbacks received: " + totalCallbacks);
98       System.out.println("total callbacks expected: " + numberOfCallbacks);
99
100
101       // remove callback handler from server
102
// remotingClient.removeListener(pushCallbackHandler);
103

104
105
106 // List callbacks = remotingClient.getCallbacks();
107
// Iterator itr = callbacks.iterator();
108
// while(itr.hasNext())
109
// {
110
// Object obj = itr.next();
111
// if(obj instanceof Callback)
112
// {
113
// System.out.println("Callback value = " + ((Callback)obj).getCallbackObject());
114
// }
115
// else
116
// {
117
// System.out.println("Callback value = " + obj);
118
// }
119
// }
120
//
121
// // remove callback handler from server
122
remotingClient.removeListener(pullCallbackHandler);
123       remotingClient.disconnect();
124       remotingClient = null;
125    }
126
127    /**
128     * calculate how many 102400 byte callback messages it will take to consume 30%
129     * of the vm's memory. The CallbackInvocationHandler will take care of consuming 70%
130     * so need to make sure we have enough callbacks to trigger persistence.
131     */

132    private int calculateNumberOfCallbacks()
133    {
134       long max = Runtime.getRuntime().maxMemory();
135       int targetMem = (int) (max * 0.3);
136       int num = targetMem / 102400;
137       return num;
138    }
139
140    private int getAllCallbacks() throws Throwable JavaDoc
141    {
142       int counter = 0;
143       List JavaDoc callbacks = null;
144
145       callbacks = remotingClient.getCallbacks();
146       while(callbacks.size() > 0)
147       {
148          System.out.println("callbacks.size() = " + callbacks.size());
149          counter = counter + callbacks.size();
150          for(int i = 0; i < callbacks.size(); i++)
151          {
152             ((Callback) callbacks.get(i)).getCallbackObject();
153          }
154
155          // need to give time for server to clean up mem
156
Thread.currentThread().sleep(2000);
157          callbacks = remotingClient.getCallbacks();
158       }
159       return counter;
160    }
161
162    private boolean checkForCallback() throws Throwable JavaDoc
163    {
164       boolean isComplete = false;
165
166       int waitPeriod = 5000;
167       while(true)
168       {
169          //isComplete = pushCallbackHandler.isComplete();
170
isComplete = ((Boolean JavaDoc) remotingClient.invoke("getdone")).booleanValue();
171          if(!isComplete)
172          {
173             try
174             {
175                Thread.currentThread().sleep(waitPeriod);
176             }
177             catch(InterruptedException JavaDoc e)
178             {
179                e.printStackTrace();
180             }
181          }
182          else
183          {
184             break;
185          }
186       }
187       return isComplete;
188    }
189
190 // private void setupCallbackServer() throws Throwable
191
// {
192
// // Using loctor with port value one higher than the target server
193
// String callbackLocatorURI = transport + "://" + host + ":" + (port + 1);
194
// InvokerLocator callbackLocator = new InvokerLocator(callbackLocatorURI);
195
//
196
// // call to create remoting server to
197
// // receive client callbacks.
198
// setupServer(callbackLocator);
199
//
200
// pushCallbackHandler = new PushCallbackHandler();
201
// // Callback handle object will be passed back as part of the callback object
202
// String callbackHandleObject = "pushcallback";
203
// // by passing only the callback handler, will indicate pull callbacks
204
// remotingClient.addListener(pushCallbackHandler, callbackLocator, callbackHandleObject);
205
// }
206

207    public void setupServer(InvokerLocator locator) throws Exception JavaDoc
208    {
209       System.out.println("Starting remoting server with locator uri of: " + locator);
210       Connector connector = new Connector();
211       connector.setInvokerLocator(locator.getLocatorURI());
212       connector.start();
213
214       CallbackServer.SampleInvocationHandler invocationHandler = new CallbackServer.SampleInvocationHandler();
215       // first parameter is sub-system name. can be any String value.
216
connector.addInvocationHandler("sample", invocationHandler);
217    }
218
219
220    /**
221     * Can pass transport and port to be used as parameters.
222     * Valid transports are 'rmi' and 'socket'.
223     *
224     * @param args
225     */

226    public static void main(String JavaDoc[] args)
227    {
228       if(args != null && args.length == 2)
229       {
230          transport = args[0];
231          port = Integer.parseInt(args[1]);
232       }
233       String JavaDoc locatorURI = transport + "://" + host + ":" + port;
234       JBossASCallbackTestClient client = new JBossASCallbackTestClient(JBossASCallbackTestClient.class.getName(), locatorURI);
235       try
236       {
237          client.testPullCallback();
238       }
239       catch(Throwable JavaDoc e)
240       {
241          e.printStackTrace();
242          System.exit(1);
243       }
244       System.exit(0);
245    }
246
247    public class PushCallbackHandler extends CallbackHandler
248    {
249
250    }
251
252    public class CallbackHandler implements InvokerCallbackHandler
253    {
254       boolean isComplete = false;
255
256       /**
257        * Will take the callback message and send back to client.
258        * If client locator is null, will store them till client polls to get them.
259        *
260        * @param invocation
261        * @throws org.jboss.remoting.HandleCallbackException
262        *
263        */

264       public void handleCallback(InvocationRequest invocation) throws HandleCallbackException
265       {
266          if(invocation instanceof Callback)
267          {
268             Callback callback = (Callback) invocation;
269             System.out.println("Received callback value of: " + callback.getCallbackObject());
270             System.out.println("Received callback handle object of: " + callback.getCallbackHandleObject());
271             System.out.println("Received callback server invoker of: " + callback.getServerLocator());
272          }
273          else
274          {
275             System.out.println("Received callback value of: " + invocation.getParameter());
276          }
277          isComplete = true;
278       }
279
280       public boolean isComplete()
281       {
282          return isComplete;
283       }
284    }
285
286 }
Popular Tags