View Javadoc

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   * RemoteDatabase is the client side of a remote client/server pairing.
27   *  
28   * @author Rory Graves
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  	 * Create a remote database instance.
40  	 * @param clientFactory The connection factory used to connect to the remote server instance.
41  	 * @throws ConnectionException On error connecting to the remote server
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 	 * Shutdown the connection to the remote server.
151 	 */
152 	public void shutdown() {
153 		rpcClient.close();
154 	}
155 
156 	@Override
157 	public void clientDisconnect(ClientId clientId) {
158 		// do nothing, not supported on client side.
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 }