Mercurial > hg > blitz_condensed

comparison src/org/dancres/blitz/remote/AdminProxy.java @ 0:3dc0c5604566

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial checkin of blitz 2.0 fcs - no installer yet.
author Dan Creswell <dan.creswell@gmail.com>
date Sat, 21 Mar 2009 11:00:06 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:3dc0c5604566
1 package org.dancres.blitz.remote;
2
3 import java.io.Serializable;
4 import java.io.IOException;
5
6 import java.rmi.RemoteException;
7
8 import net.jini.core.entry.Entry;
9
10 import net.jini.core.discovery.LookupLocator;
11
12 import net.jini.core.transaction.TransactionException;
13 import net.jini.core.transaction.Transaction;
14
15 import net.jini.core.lease.Lease;
16
17 import net.jini.space.JavaSpace;
18
19 import net.jini.admin.JoinAdmin;
20
21 import net.jini.id.Uuid;
22 import net.jini.id.ReferentUuid;
23 import net.jini.id.ReferentUuids;
24
25 import com.sun.jini.admin.DestroyAdmin;
26
27 import com.sun.jini.outrigger.JavaSpaceAdmin;
28 import com.sun.jini.outrigger.AdminIterator;
29
30 import org.dancres.blitz.stats.Switch;
31 import org.dancres.blitz.stats.Stat;
32
33 import org.dancres.blitz.mangler.MangledEntry;
34 import org.dancres.blitz.mangler.EntryMangler;
35
36 import org.dancres.blitz.remote.view.EntryViewUID;
37
38 /**
39 Handles all admin-related functions for Blitz.
40 */
41 public class AdminProxy implements DestroyAdmin, JoinAdmin, Serializable,
42 ReferentUuid, StatsAdmin,
43 BlitzAdmin, JavaSpaceAdmin {
44 AdminServer theStub;
45 Uuid theUuid;
46
47 AdminProxy(AdminServer anAdminStub, Uuid aUuid) {
48 theStub = anAdminStub;
49 theUuid = aUuid;
50 }
51
52 private synchronized EntryMangler getMangler() {
53 return EntryMangler.getMangler();
54 }
55
56 public Uuid getReferentUuid() {
57 return theUuid;
58 }
59
60 /**
61 * Get the current attribute sets for the service.
62 *
63 * @return the current attribute sets for the service
64 * @throws java.rmi.RemoteException
65 */
66 public Entry[] getLookupAttributes() throws RemoteException {
67 return theStub.getLookupAttributes();
68 }
69
70 /**
71 * Add attribute sets for the service. The resulting set will be used
72 * for all future joins. The attribute sets are also added to all
73 * currently-joined lookup services.
74 *
75 * @param attrSets the attribute sets to add
76 * @throws java.rmi.RemoteException
77 */
78 public void addLookupAttributes(Entry[] attrSets) throws RemoteException {
79 theStub.addLookupAttributes(attrSets);
80 }
81
82 /**
83 * Modify the current attribute sets, using the same semantics as
84 * ServiceRegistration.modifyAttributes. The resulting set will be used
85 * for all future joins. The same modifications are also made to all
86 * currently-joined lookup services.
87 *
88 * @param attrSetTemplates the templates for matching attribute sets
89 * @param attrSets the modifications to make to matching sets
90 * @throws java.rmi.RemoteException
91 *
92 * @see net.jini.core.lookup.ServiceRegistration#modifyAttributes
93 */
94 public void modifyLookupAttributes(Entry[] attrSetTemplates,
95 Entry[] attrSets)
96 throws RemoteException {
97 theStub.modifyLookupAttributes(attrSetTemplates, attrSets);
98 }
99
100 /**
101 * Get the list of groups to join. An empty array means the service
102 * joins no groups (as opposed to "all" groups).
103 *
104 * @return an array of groups to join. An empty array means the service
105 * joins no groups (as opposed to "all" groups).
106 * @throws java.rmi.RemoteException
107 * @see #setLookupGroups
108 */
109 public String[] getLookupGroups() throws RemoteException {
110 return theStub.getLookupGroups();
111 }
112
113 /**
114 * Add new groups to the set to join. Lookup services in the new
115 * groups will be discovered and joined.
116 *
117 * @param groups groups to join
118 * @throws java.rmi.RemoteException
119 * @see #removeLookupGroups
120 */
121 public void addLookupGroups(String[] groups) throws RemoteException {
122 theStub.addLookupGroups(groups);
123 }
124
125 /**
126 * Remove groups from the set to join. Leases are cancelled at lookup
127 * services that are not members of any of the remaining groups.
128 *
129 * @param groups groups to leave
130 * @throws java.rmi.RemoteException
131 * @see #addLookupGroups
132 */
133 public void removeLookupGroups(String[] groups) throws RemoteException {
134 theStub.removeLookupGroups(groups);
135 }
136
137 /**
138 * Replace the list of groups to join with a new list. Leases are
139 * cancelled at lookup services that are not members of any of the
140 * new groups. Lookup services in the new groups will be discovered
141 * and joined.
142 *
143 * @param groups groups to join
144 * @throws java.rmi.RemoteException
145 * @see #getLookupGroups
146 */
147 public void setLookupGroups(String[] groups) throws RemoteException {
148 theStub.setLookupGroups(groups);
149 }
150
151 /**
152 *Get the list of locators of specific lookup services to join.
153 *
154 * @return the list of locators of specific lookup services to join
155 * @throws java.rmi.RemoteException
156 * @see #setLookupLocators
157 */
158 public LookupLocator[] getLookupLocators() throws RemoteException {
159 return theStub.getLookupLocators();
160 }
161
162 /**
163 * Add locators for specific new lookup services to join. The new
164 * lookup services will be discovered and joined.
165 *
166 * @param locators locators of specific lookup services to join
167 * @throws java.rmi.RemoteException
168 * @see #removeLookupLocators
169 */
170 public void addLookupLocators(LookupLocator[] locators)
171 throws RemoteException {
172 theStub.addLookupLocators(locators);
173 }
174
175 /**
176 * Remove locators for specific lookup services from the set to join.
177 * Any leases held at the lookup services are cancelled.
178 *
179 * @param locators locators of specific lookup services to leave
180 * @throws java.rmi.RemoteException
181 * @see #addLookupLocators
182 */
183 public void removeLookupLocators(LookupLocator[] locators)
184 throws RemoteException {
185 theStub.removeLookupLocators(locators);
186 }
187
188 /**
189 * Replace the list of locators of specific lookup services to join
190 * with a new list. Leases are cancelled at lookup services that were
191 * in the old list but are not in the new list. Any new lookup services
192 * will be discovered and joined.
193 *
194 * @param locators locators of specific lookup services to join
195 * @throws java.rmi.RemoteException
196 * @see #getLookupLocators
197 */
198 public void setLookupLocators(LookupLocator[] locators)
199 throws RemoteException {
200 theStub.setLookupLocators(locators);
201 }
202
203 public void destroy() throws RemoteException {
204 theStub.destroy();
205 }
206
207 public boolean equals(Object anObject) {
208 return ReferentUuids.compare(this, anObject);
209 }
210
211 public Stat[] getStats() throws RemoteException {
212 return theStub.getStats();
213 }
214
215 public void setSwitches(Switch[] aListOfSwitches) throws RemoteException {
216 theStub.setSwitches(aListOfSwitches);
217 }
218
219 public void requestSnapshot() throws RemoteException,
220 TransactionException, IOException {
221 theStub.requestSnapshot();
222 }
223
224 public void shutdown() throws RemoteException, IOException {
225 theStub.shutdown();
226 }
227
228 public void backup(String aDir) throws RemoteException, IOException {
229 theStub.backup(aDir);
230 }
231
232 public void clean() throws RemoteException, IOException {
233 theStub.clean();
234 }
235
236 public void reap() throws RemoteException {
237 theStub.reap();
238 }
239
240 /************************************************************************
241 * JavaSpaceAdmin
242 ***********************************************************************/
243
244 public JavaSpace space() throws RemoteException {
245 return theStub.getJavaSpaceProxy();
246 }
247
248 public AdminIterator contents(Entry aTmpl, Transaction aTxn)
249 throws TransactionException, RemoteException {
250
251 ViewResult myResult =
252 theStub.newView(new MangledEntry[] {packEntry(aTmpl)},
253 aTxn, Lease.FOREVER, false, Long.MAX_VALUE,
254 AdminIteratorImpl.CHUNK_SIZE);
255
256 // We only want the UID from this lease
257 EntryViewUID myViewId = (EntryViewUID) myResult.getLease().getUID();
258
259 return new AdminIteratorImpl(getMangler(), myViewId, theStub,
260 myResult.getInitialBatch());
261 }
262
263 public AdminIterator contents(Entry aTmpl, Transaction aTxn, int aFetchSize)
264 throws TransactionException, RemoteException {
265
266 ViewResult myResult =
267 theStub.newView(new MangledEntry[] {packEntry(aTmpl)},
268 aTxn, Lease.FOREVER, false, Long.MAX_VALUE,
269 AdminIteratorImpl.CHUNK_SIZE);
270
271 // We only want the UID from this lease
272 EntryViewUID myViewId = (EntryViewUID) myResult.getLease().getUID();
273
274 return new AdminIteratorImpl(getMangler(), myViewId,
275 aFetchSize, theStub, myResult.getInitialBatch());
276 }
277
278 private MangledEntry packEntry(Entry anEntry) {
279 if (anEntry == null)
280 return MangledEntry.NULL_TEMPLATE;
281 // Is it a snapshot?
282 else if (anEntry instanceof MangledEntry)
283 return (MangledEntry) anEntry;
284 else
285 return getMangler().mangle(anEntry);
286 }
287 }