|
1 package org.sapia.ubik.rmi.server;
2
3 import java.rmi.RemoteException  ;
4 import java.util.Collections ;
5 import java.util.HashMap ;
6 import java.util.HashSet ;
7 import java.util.Iterator ;
8 import java.util.Map ;
9 import java.util.Properties ;
10 import java.util.Set ;
11 import java.util.WeakHashMap ;
12
13 import org.sapia.ubik.net.ServerAddress;
14 import org.sapia.ubik.rmi.Consts;
15 import org.sapia.ubik.rmi.server.transport.TransportManager;
16 import org.sapia.ubik.rmi.server.transport.socket.SocketTransportProvider;
17
18
19
36 public class ServerTable implements Server {
37 static final String DEFAULT_TRANSPORT_TYPE = SocketTransportProvider.TRANSPORT_TYPE;
38
39 private static Map _interfaceCache = Collections.synchronizedMap(new WeakHashMap ());
41 Map _serversByType = Collections.synchronizedMap(new HashMap ());
42
43
46
47
50 public void start() {
51 }
53
54
57 public void close() {
58 Iterator itr = _serversByType.values().iterator();
59 ServerRef ref;
60
61 while (itr.hasNext()) {
62 ref = (ServerRef) itr.next();
63 ref.server.close();
64 }
65 }
66
67
72 public ServerAddress getServerAddress() {
73 return getServerRef(DEFAULT_TRANSPORT_TYPE).server.getServerAddress();
74 }
75
76 public ServerAddress getServerAddress(String transportType) {
77 return getServerRef(transportType).server.getServerAddress();
78 }
79
80
83
84
89 public RemoteRef getRemoteRef(String transportType) {
90 return getServerRef(transportType).ref;
91 }
92
93
98 public OID getOID(String transportType) {
99 return getServerRef(transportType).oid;
100 }
101
102
105 boolean isInit(String transportType) {
106 return _serversByType.get(transportType) != null;
107 }
108
109 ServerAddress init(Object remote, String transportType)
110 throws RemoteException , IllegalStateException {
111 Server s = TransportManager.getProviderFor(transportType).newDefaultServer();
112 s.start();
113
114 return doInit(remote, s, transportType);
120 }
121
122 ServerAddress init(Object remote)
123 throws RemoteException , IllegalStateException {
124 return init(remote, 0);
125 }
126
127 ServerAddress init(Object remote, int port)
128 throws RemoteException , IllegalStateException {
129 return doInit(remote, port, ServerTable.DEFAULT_TRANSPORT_TYPE);
130 }
131
132 ServerAddress init(Object remote, String transportType, Properties props)
133 throws RemoteException , IllegalStateException {
134
135 if(Log.isDebug()){
136 Log.debug(getClass(), "Getting server for transport : " + transportType +
137 ": properties: " + props);
138 }
139 Server s = TransportManager.getProviderFor(transportType).newServer(props);
140
141 s.start();
142
143 return doInit(remote, s, transportType);
149 }
150
151 private synchronized ServerAddress doInit(Object remote, int port,
152 String transportType) throws RemoteException , IllegalStateException {
153 if (_serversByType.get(transportType) != null) {
154 throw new IllegalStateException ("server already created");
155 }
156
157 if (Log.isDebug()) {
158 Log.debug(ServerTable.class, "initializing server");
159 }
160
161 Server s;
162
163 try {
164 s = TransportManager.getDefaultProvider().newServer(port);
165 } catch (java.io.IOException e) {
166 throw new java.rmi.RemoteException ("could not create singleton server", e);
167 }
168
169 s.start();
170
171 return doInit(remote, s, transportType);
177 }
178
179 private synchronized ServerAddress doInit(Object remote, Server s,
180 String transportType) throws RemoteException , IllegalStateException {
181 if (_serversByType.get(transportType) != null) {
182 throw new IllegalStateException ("server already created");
183 }
184
185 ServerRef serverRef = new ServerRef();
186 serverRef.server = s;
187
188 if (Log.isDebug()) {
189 Log.debug(ServerTable.class,
190 "server listening on: " + serverRef.server.getServerAddress());
191 }
192
193 if (remote != null) {
194 serverRef.oid = generateOID();
195
196 serverRef.ref = initRef(remote, serverRef.oid, serverRef);
201 serverRef.stub = (Stub) Hub.getStubFor(serverRef.ref, remote);
202 }
203
204 _serversByType.put(transportType, serverRef);
205
206 return serverRef.server.getServerAddress();
207 }
208
209 final RemoteRef initStub(Object remote, String transportType) {
210 return initRef(remote, generateOID(), getServerRef(transportType));
211 }
212
213 static Class [] getInterfacesFor(Class clazz) {
214 Class [] cachedInterfaces = (Class []) _interfaceCache.get(clazz);
215
216 if (cachedInterfaces == null) {
217 HashSet set = new HashSet ();
218 Class current = clazz;
219 appendInterfaces(current, set);
220 set.add(Stub.class);
221
222 cachedInterfaces = (Class []) set.toArray(new Class [set.size()]);
223 _interfaceCache.put(clazz, cachedInterfaces);
224 }
225
226 return cachedInterfaces;
227 }
228
229 static void appendInterfaces(Class current, Set interfaces) {
230 Class [] ifs = current.getInterfaces();
231
232 for (int i = 0; i < ifs.length; i++) {
233 appendInterfaces(ifs[i], interfaces);
234 interfaces.add(ifs[i]);
235 }
236
237 current = current.getSuperclass();
238
239 if (current != null) {
240 appendInterfaces(current, interfaces);
241 }
242 }
243
244 ServerRef getServerRef(String transportType) throws IllegalArgumentException {
245 ServerRef ref = (ServerRef) _serversByType.get(transportType);
246
247 if (ref == null) {
248 throw new IllegalStateException ("No server for type: " + transportType);
249 }
250
251 return ref;
252 }
253
254 static synchronized OID generateOID() {
255 return new OID(UIDGenerator.createdUID());
256 }
257
258 private final RemoteRef initRef(Object remote, OID oid, ServerRef serverRef) {
259 RemoteRefEx rmiHandler = new RemoteRefEx(oid,
260 serverRef.server.getServerAddress());
261
262 rmiHandler.setCallBack((System.getProperty(Consts.CALLBACK_ENABLED) != null) &&
263 System.getProperty(Consts.CALLBACK_ENABLED).equalsIgnoreCase("true"));
264
265 if (Log.isDebug()) {
266 Log.debug(ServerTable.class,
267 remote + " is call-back: " + rmiHandler.isCallBack());
268 }
269
270 Hub.serverRuntime.objectTable.register(oid, remote);
272
273 return rmiHandler;
274 }
275 }
276 |
Popular Tags |
Java API By Example, From Geeks To Geeks.