1 package org.sourceforge.jemm.database.remote.client;
2
3 import org.sourceforge.jemm.comm.client.RPCClient;
4 import org.sourceforge.jemm.comm.connection.ClientConnectionFactory;
5 import org.sourceforge.jemm.comm.connection.ConnectionException;
6 import org.sourceforge.jemm.database.ClassId;
7 import org.sourceforge.jemm.database.ClassInfo;
8 import org.sourceforge.jemm.database.ClientId;
9 import org.sourceforge.jemm.database.ClientThreadId;
10 import org.sourceforge.jemm.database.Database;
11 import org.sourceforge.jemm.database.DatabaseDebugIF;
12 import org.sourceforge.jemm.database.EnumId;
13 import org.sourceforge.jemm.database.EnumInfo;
14 import org.sourceforge.jemm.database.GetObjectResp;
15 import org.sourceforge.jemm.database.LockAcquiredListener;
16 import org.sourceforge.jemm.database.ObjectSyncData;
17 import org.sourceforge.jemm.database.ObjectSyncResp;
18 import org.sourceforge.jemm.database.StructureModifiedException;
19 import org.sourceforge.jemm.database.remote.shared.RDbClientIF;
20 import org.sourceforge.jemm.database.remote.shared.RDbServerIF;
21 import org.sourceforge.jemm.lifecycle.TypeRequest;
22 import org.sourceforge.jemm.lifecycle.TypeResponse;
23 import org.sourceforge.jemm.types.ID;
24
25
26
27
28
29
30 public class RemoteDatabase implements Database {
31
32 protected ClientId listenerClientId;
33 protected LockAcquiredListener lockListener;
34
35 private final RPCClient rpcClient;
36 private final RDbServerIF serverIF;
37
38
39
40
41
42
43 public RemoteDatabase(ClientConnectionFactory clientFactory) throws ConnectionException {
44 rpcClient = new RPCClient(clientFactory);
45 rpcClient.registerIF(RDbClientIF.class, new RDbClientIF()
46 {
47
48 @Override
49 public void lockAcquired(String threadId, ID objectId) {
50 LockAcquiredListener targetListener = lockListener;
51 if(targetListener != null)
52 targetListener.lockAcquired(new ClientThreadId(listenerClientId,threadId), objectId);
53 }
54 });
55 rpcClient.connect();
56 serverIF = (RDbServerIF) rpcClient.getServerIF(RDbServerIF.class);
57 }
58
59 @Override
60 public void acquireLock(ClientThreadId threadId, ID jemmId) {
61 serverIF.acquireLock(threadId.getThreadId(),jemmId);
62 }
63
64 @Override
65 public ClassInfo getClassInfo(ClientId clientId, ClassId classId) {
66 return serverIF.getClassInfo(classId);
67 }
68
69 @Override
70 public DatabaseDebugIF getDebugInterface() {
71 return null;
72 }
73
74 @Override
75 public EnumInfo getEnumInfo(ClientId clientId, EnumId enumId) {
76 return serverIF.getEnumInfo(enumId);
77 }
78
79 @Override
80 public GetObjectResp getObject(ClientId clientId, ID id) {
81 return serverIF.getObject(id);
82 }
83
84 @Override
85 public ID getRoot(ClientId clientId, String rootName) {
86 return serverIF.getRoot(rootName);
87 }
88
89 @Override
90 public ID newObject(ClientId clientId, ClassId classId) {
91 return serverIF.newObject(classId);
92 }
93
94 @Override
95 public void referenceCleared(ClientId clientId, ID... ids) {
96 serverIF.referenceCleared(ids);
97 }
98
99 @Override
100 public ClassId registerClass(ClientId clientId, ClassInfo classInfo) throws StructureModifiedException {
101 return serverIF.registerClass(classInfo);
102 }
103
104 @Override
105 public EnumId registerEnum(ClientId clientId, EnumInfo enumInfo) throws StructureModifiedException {
106 return serverIF.registerEnum(enumInfo);
107 }
108
109 @Override
110 public void releaseLock(ClientThreadId threadId, ID id) {
111 serverIF.releaseLock(threadId.getThreadId(),id);
112 }
113
114 @Override
115 public void removeLockAcquiredListener(ClientId clientId) {
116 if(this.listenerClientId != clientId)
117 throw new IllegalStateException("removeLockAcquireListener called on non-linked client");
118
119 lockListener = null;
120 clientId = null;
121 }
122
123 @Override
124 public void setClientLockAcquiredListener(ClientId clientId,
125 LockAcquiredListener listener) {
126 if(this.listenerClientId != null)
127 throw new IllegalStateException("client lock acquire listener already set");
128
129 this.lockListener = listener;
130 this.listenerClientId = clientId;
131 }
132
133 @Override
134 public void setRoot(ClientId clientId, String rootName, ID newValue) {
135 serverIF.setRoot(rootName,newValue);
136 }
137
138 @Override
139 public ID setRootIfNull(ClientId clientId, String rootName, ID newValue) {
140 return serverIF.setRootIfNull(rootName,newValue);
141 }
142
143 @Override
144 public ObjectSyncResp synchroniseObject(ClientId clientId, ID jemmId,
145 ObjectSyncData syncData) {
146 return serverIF.synchroniseObject(jemmId,syncData);
147 }
148
149
150
151
152 public void shutdown() {
153 rpcClient.close();
154 }
155
156 @Override
157 public void clientDisconnect(ClientId clientId) {
158
159 }
160
161 @Override
162 public TypeResponse<?> processTypeRequest(ClientId clientId,
163 ClassId classId, ID objId, TypeRequest<?> request) {
164 return serverIF.processTypeRequest(classId,objId,request);
165 }
166 }