blob: 89940d62b3c392924b3384b688649d1126904da6 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
/*******************************************************************************
* Copyright (c) 2009 Composent, Inc. and others. All rights reserved. This
* program and the accompanying materials are made available under the terms of
* the Eclipse Public License v1.0 which accompanies this distribution, and is
* available at http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Composent, Inc. - initial API and implementation
******************************************************************************/
package org.eclipse.ecf.examples.internal.remoteservices.hello.ds.consumer;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.ecf.examples.remoteservices.hello.IHello;
import org.eclipse.ecf.examples.remoteservices.hello.IHelloAsync;
import org.eclipse.ecf.remoteservice.IAsyncCallback;
import org.eclipse.ecf.remoteservice.IRemoteService;
import org.eclipse.ecf.remoteservice.IRemoteServiceProxy;
import org.eclipse.ecf.remoteservice.RemoteServiceHelper;
import org.eclipse.equinox.concurrent.future.IFuture;
public class HelloClientComponent {
private static final String CONSUMER_NAME = "helloclientcomponent";
public void bindHello(IHello proxy) {
// First print out on console that we got a proxy instance
System.out.println("Got proxy IHello="+proxy);
// Call proxy synchronously. Note that this call may block or fail due to
// synchronous communication with remote service
System.out.println("STARTING remote call via proxy...");
proxy.hello(CONSUMER_NAME+" via proxy");
System.out.println("COMPLETED remote call via proxy");
System.out.println();
// If the proxy is also an instance of IHelloAsync then use
// this asynchronous interface to invoke methods asynchronously
if (proxy instanceof IHelloAsync) {
IHelloAsync helloA = (IHelloAsync) proxy;
// Create callback for use in IHelloAsync
IAsyncCallback callback = new IAsyncCallback<String>() {
public void onSuccess(String result) {
System.out.println("COMPLETED remote call with callback SUCCESS with result="+result);
System.out.println();
}
public void onFailure(Throwable t) {
System.out.println("COMPLETED remote call with callback FAILED with exception="+t);
System.out.println();
}
};
// Call asynchronously with callback
System.out.println("STARTING async remote call via callback...");
helloA.helloAsync(CONSUMER_NAME + " via async proxy with listener", callback);
System.out.println("LOCAL async invocation complete");
System.out.println();
// Call asynchronously with future
System.out.println("STARTING async remote call via future...");
Future<String> future = helloA.helloAsync(CONSUMER_NAME + " via async proxy with future");
System.out.println("LOCAL async future invocation complete");
System.out.println();
try {
while (!future.isDone()) {
// do some other stuff
System.out.println("LOCAL future not yet done...so we're doing other stuff while waiting for future to be done");
Thread.sleep(200);
}
// Now it's done, so this will not block
String result = future.get();
System.out.println("COMPLETED remote call with future SUCCEEDED with result="+result);
System.out.println();
} catch (OperationCanceledException e) {
System.out.println("COMPLETED remote call with callback CANCELLED with exception="+e);
System.out.println();
e.printStackTrace();
} catch (InterruptedException e) {
System.out.println("COMPLETED remote call with callback INTERRUPTED with exception="+e);
System.out.println();
e.printStackTrace();
} catch (ExecutionException e) {
System.out.println("COMPLETED remote call with callback INTERRUPTED with exception="+e);
System.out.println();
e.printStackTrace();
}
}
// It's also possible to get the remote service directly from the proxy
IRemoteService remoteService = ((IRemoteServiceProxy) proxy).getRemoteService();
Assert.isNotNull(remoteService);
// In this case, we will make an non-blocking call and immediately get a 'future'...which is
// a placeholder for a result of the remote computation. This will not block.
System.out.println("STARTING async remote call via future...");
IFuture future = RemoteServiceHelper.futureExec(remoteService, "hello",
new Object[] { CONSUMER_NAME + " future" });
System.out.println("LOCAL async future invocation complete");
System.out.println();
// Client can execute arbitrary code here...
try {
// This blocks until communication and computation have completed successfully
while (!future.isDone()) {
// do some other stuff
System.out.println("LOCAL future not yet done...so we're doing other stuff while waiting for future to be done");
Thread.sleep(200);
}
// Now it's done, so this will not block
Object result = future.get();
System.out.println("COMPLETED remote call with future SUCCEEDED with result="+result);
System.out.println();
} catch (Exception e) {
e.printStackTrace();
}
}
}
|
