Mercurial > hg > blitz_stable
comparison src/org/dancres/blitz/remote/LocalSpace.java @ 0:3dc0c5604566
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.IOException; | |
4 | |
5 import java.rmi.RemoteException; | |
6 import java.rmi.MarshalledObject; | |
7 import java.rmi.NoSuchObjectException; | |
8 import java.util.logging.Level; | |
9 import java.util.logging.Logger; | |
10 import java.util.ArrayList; | |
11 import java.util.List; | |
12 | |
13 import net.jini.core.event.RemoteEventListener; | |
14 import net.jini.core.event.EventRegistration; | |
15 | |
16 import net.jini.core.entry.Entry; | |
17 | |
18 import net.jini.core.lease.Lease; | |
19 import net.jini.core.lease.UnknownLeaseException; | |
20 import net.jini.core.lease.LeaseDeniedException; | |
21 | |
22 import net.jini.core.transaction.Transaction; | |
23 import net.jini.core.transaction.TransactionException; | |
24 import net.jini.core.transaction.UnknownTransactionException; | |
25 import net.jini.core.transaction.server.TransactionManager; | |
26 import net.jini.core.discovery.LookupLocator; | |
27 import net.jini.discovery.DiscoveryLocatorManagement; | |
28 import net.jini.space.JavaSpace; | |
29 import net.jini.space.JavaSpace05; | |
30 import net.jini.config.Configuration; | |
31 import net.jini.config.ConfigurationException; | |
32 import net.jini.id.UuidFactory; | |
33 import net.jini.id.Uuid; | |
34 | |
35 import org.dancres.blitz.*; | |
36 import org.dancres.blitz.config.ConfigurationFactory; | |
37 import org.dancres.blitz.remote.view.ViewRegistration; | |
38 import org.dancres.blitz.remote.view.EntryViewFactory; | |
39 import org.dancres.blitz.remote.view.EntryViewUID; | |
40 import org.dancres.blitz.stats.Stat; | |
41 import org.dancres.blitz.stats.StatsBoard; | |
42 import org.dancres.blitz.stats.Switch; | |
43 import org.dancres.blitz.stats.SwitchSettings; | |
44 import org.dancres.blitz.lease.SpaceUID; | |
45 import org.dancres.blitz.lease.LeaseBounds; | |
46 import org.dancres.blitz.notify.RemoteEventDispatcher; | |
47 | |
48 import org.dancres.blitz.mangler.MangledEntry; | |
49 | |
50 import org.dancres.blitz.txn.TxnGateway; | |
51 import org.dancres.blitz.txn.StoragePersonalityFactory; | |
52 | |
53 /** | |
54 <p>An entirely local implementation of a JavaSpace using Blitz. Useful for | |
55 debugging where one would like client and server co-located. An instance | |
56 of this class, when configured with an appropriate | |
57 <code>TxnGateway</code> instance, can provide an embedded space | |
58 implementation. For an example, see <code>TxnStress</code></p> | |
59 | |
60 @see org.dancres.blitz.txn.TxnGateway | |
61 @see org.dancres.blitz.test.TxnStress | |
62 | |
63 @todo Add support for lease renewal. | |
64 */ | |
65 public class LocalSpace implements BlitzServer { | |
66 static final Logger theLogger = | |
67 Logging.newLogger("org.dancres.blitz.remote.LocalSpace", Level.INFO); | |
68 | |
69 private Uuid theUuid; | |
70 | |
71 private BlitzProxy theSpaceProxy; | |
72 | |
73 private TxnGateway theTxnGate; | |
74 | |
75 private AdminProxy theAdminProxy; | |
76 | |
77 private TxnParticipantProxy theTxnProxy; | |
78 | |
79 private boolean isStopped; | |
80 | |
81 private SpaceImpl theSpace; | |
82 | |
83 public LocalSpace(TxnGateway aGateway) throws Exception { | |
84 init(aGateway); | |
85 } | |
86 | |
87 public LocalSpace() throws Exception { | |
88 init(null); | |
89 } | |
90 | |
91 public JavaSpace05 getProxy() { | |
92 return theSpaceProxy; | |
93 } | |
94 | |
95 private void init(TxnGateway aGateway) | |
96 throws RemoteException, ConfigurationException { | |
97 | |
98 theUuid = UuidFactory.generate(); | |
99 | |
100 StoragePersonalityFactory.getPersonality(); | |
101 | |
102 theAdminProxy = | |
103 ProxyFactory.newAdminProxy(this, theUuid); | |
104 | |
105 theSpaceProxy = | |
106 ProxyFactory.newBlitzProxy(this, theUuid); | |
107 | |
108 theTxnProxy = | |
109 ProxyFactory.newTxnParticipantProxy(this, theUuid); | |
110 theTxnGate = aGateway; | |
111 | |
112 RemoteEventDispatcher.setSource(theSpaceProxy); | |
113 | |
114 try { | |
115 theSpace = new SpaceImpl(theTxnGate); | |
116 | |
117 } catch (Exception anE) { | |
118 theLogger.log(Level.SEVERE, "Failed to start space", anE); | |
119 throw new RemoteException("Failed to start space", anE); | |
120 } | |
121 } | |
122 | |
123 public LeaseImpl write(MangledEntry anEntry, Transaction aTxn, | |
124 long aLeaseTime) | |
125 throws RemoteException, TransactionException { | |
126 | |
127 stopBarrier(); | |
128 | |
129 try { | |
130 WriteTicket myTicket = theSpace.write(anEntry, aTxn, aLeaseTime); | |
131 | |
132 return | |
133 ProxyFactory.newEntryLeaseImpl(this, theUuid, | |
134 myTicket.getUID(), | |
135 myTicket.getExpirationTime()); | |
136 } catch (IOException anIOE) { | |
137 theLogger.log(Level.SEVERE, "SpaceImpl has disk problems", anIOE); | |
138 throw new RemoteException("Space has disk problems", anIOE); | |
139 } | |
140 } | |
141 | |
142 public MangledEntry take(MangledEntry anEntry, Transaction aTxn, | |
143 long aWaitTime) | |
144 throws RemoteException, TransactionException { | |
145 | |
146 stopBarrier(); | |
147 | |
148 try { | |
149 return theSpace.take(anEntry, aTxn, aWaitTime); | |
150 } catch (IOException anIOE) { | |
151 theLogger.log(Level.SEVERE, "SpaceImpl has disk problems", anIOE); | |
152 throw new RemoteException("Space has disk problems", anIOE); | |
153 } | |
154 } | |
155 | |
156 public MangledEntry read(MangledEntry anEntry, Transaction aTxn, | |
157 long aWaitTime) | |
158 throws RemoteException, TransactionException { | |
159 | |
160 stopBarrier(); | |
161 | |
162 try { | |
163 return theSpace.read(anEntry, aTxn, aWaitTime); | |
164 } catch (IOException anIOE) { | |
165 theLogger.log(Level.SEVERE, "SpaceImpl has disk problems", anIOE); | |
166 throw new RemoteException("Space has disk problems", anIOE); | |
167 } | |
168 } | |
169 | |
170 public MangledEntry takeIfExists(MangledEntry anEntry, Transaction aTxn, | |
171 long aWaitTime) | |
172 throws RemoteException, TransactionException { | |
173 | |
174 stopBarrier(); | |
175 | |
176 try { | |
177 return theSpace.takeIfExists(anEntry, aTxn, aWaitTime); | |
178 } catch (IOException anIOE) { | |
179 theLogger.log(Level.SEVERE, "SpaceImpl has disk problems", anIOE); | |
180 throw new RemoteException("Space has disk problems", anIOE); | |
181 } | |
182 } | |
183 | |
184 public MangledEntry readIfExists(MangledEntry anEntry, Transaction aTxn, | |
185 long aWaitTime) | |
186 throws RemoteException, TransactionException { | |
187 | |
188 stopBarrier(); | |
189 | |
190 try { | |
191 return theSpace.readIfExists(anEntry, aTxn, aWaitTime); | |
192 } catch (IOException anIOE) { | |
193 theLogger.log(Level.SEVERE, "SpaceImpl has disk problems", anIOE); | |
194 throw new RemoteException("Space has disk problems", anIOE); | |
195 } | |
196 } | |
197 | |
198 public EventRegistration notify(MangledEntry anEntry, Transaction aTxn, | |
199 RemoteEventListener aListener, | |
200 long aLeaseTime, | |
201 MarshalledObject aHandback) | |
202 throws RemoteException, TransactionException { | |
203 | |
204 stopBarrier(); | |
205 | |
206 try { | |
207 RegTicket myTicket = | |
208 theSpace.notify(anEntry, aTxn, aListener, aLeaseTime, | |
209 aHandback); | |
210 | |
211 LeaseImpl myLease = | |
212 ProxyFactory.newLeaseImpl(this, theUuid, | |
213 myTicket.getUID(), | |
214 myTicket.getExpirationTime()); | |
215 | |
216 return new EventRegistration(myTicket.getSourceId(), theSpaceProxy, | |
217 myLease, myTicket.getSeqNum()); | |
218 } catch (IOException anIOE) { | |
219 theLogger.log(Level.SEVERE, "SpaceImpl has disk problems", anIOE); | |
220 throw new RemoteException("Space has disk problems", anIOE); | |
221 } | |
222 } | |
223 | |
224 public int prepare(TransactionManager mgr, long id) | |
225 throws UnknownTransactionException, RemoteException { | |
226 | |
227 stopBarrier(); | |
228 | |
229 return theSpace.getTxnControl().prepare(mgr, id); | |
230 } | |
231 | |
232 public void commit(TransactionManager mgr, long id) | |
233 throws UnknownTransactionException, RemoteException { | |
234 | |
235 stopBarrier(); | |
236 | |
237 theSpace.getTxnControl().commit(mgr, id); | |
238 } | |
239 | |
240 public void abort(TransactionManager mgr, long id) | |
241 throws UnknownTransactionException, RemoteException { | |
242 | |
243 stopBarrier(); | |
244 | |
245 theSpace.getTxnControl().abort(mgr, id); | |
246 } | |
247 | |
248 public int prepareAndCommit(TransactionManager mgr, long id) | |
249 throws UnknownTransactionException, RemoteException { | |
250 | |
251 stopBarrier(); | |
252 | |
253 return theSpace.getTxnControl().prepareAndCommit(mgr, id); | |
254 } | |
255 | |
256 /* ********************************************************************* | |
257 * Landlord | |
258 ******************************************************************** */ | |
259 public long renew(SpaceUID aUID, long aDuration) | |
260 throws UnknownLeaseException, LeaseDeniedException, RemoteException { | |
261 | |
262 // System.out.println("Renew: " + aUID + ", " + aDuration); | |
263 | |
264 stopBarrier(); | |
265 | |
266 try { | |
267 long myResult = theSpace.getLeaseControl().renew(aUID, aDuration); | |
268 | |
269 // System.out.println("Renew: " + myResult); | |
270 | |
271 return myResult; | |
272 } catch (IOException anIOE) { | |
273 theLogger.log(Level.SEVERE, "Space has disk problems", anIOE); | |
274 throw new RemoteException("Space has disk problems", anIOE); | |
275 } | |
276 } | |
277 | |
278 public void cancel(SpaceUID aUID) | |
279 throws UnknownLeaseException, RemoteException { | |
280 | |
281 stopBarrier(); | |
282 | |
283 try { | |
284 theSpace.getLeaseControl().cancel(aUID); | |
285 } catch (IOException anIOE) { | |
286 theLogger.log(Level.SEVERE, "Space has disk problems", anIOE); | |
287 throw new RemoteException("Space has disk problems", anIOE); | |
288 } | |
289 } | |
290 | |
291 public LeaseResults renew(SpaceUID[] aLeases, long[] aDurations) | |
292 throws RemoteException { | |
293 | |
294 stopBarrier(); | |
295 | |
296 long[] myNewDurations = new long[aLeases.length]; | |
297 Exception[] myFails = null; | |
298 | |
299 for (int i = 0; i < aLeases.length; i++) { | |
300 try { | |
301 myNewDurations[i] = | |
302 theSpace.getLeaseControl().renew(aLeases[i], | |
303 aDurations[i]); | |
304 } catch (LeaseDeniedException anLDE) { | |
305 if (myFails == null) | |
306 myFails = initFails(aLeases.length, i); | |
307 | |
308 myNewDurations[i] = -1; | |
309 myFails[i] = anLDE; | |
310 } catch (UnknownLeaseException anULE) { | |
311 if (myFails == null) | |
312 myFails = initFails(aLeases.length, i); | |
313 | |
314 myNewDurations[i] = -1; | |
315 myFails[i] = anULE; | |
316 } catch (IOException anIOE) { | |
317 theLogger.log(Level.SEVERE, "Space has disk problems", anIOE); | |
318 throw new RemoteException("Space has disk problems", anIOE); | |
319 } | |
320 } | |
321 | |
322 return new LeaseResults(myNewDurations, myFails); | |
323 } | |
324 | |
325 public LeaseResults cancel(SpaceUID[] aLeases) | |
326 throws RemoteException { | |
327 | |
328 stopBarrier(); | |
329 | |
330 Exception[] myFails = null; | |
331 | |
332 for (int i = 0; i < aLeases.length; i++) { | |
333 try { | |
334 theSpace.getLeaseControl().cancel(aLeases[i]); | |
335 } catch (UnknownLeaseException aULE) { | |
336 if (myFails == null) | |
337 myFails = initFails(aLeases.length, i); | |
338 | |
339 myFails[i] = aULE; | |
340 } catch (IOException anIOE) { | |
341 theLogger.log(Level.SEVERE, "Space has disk problems", anIOE); | |
342 throw new RemoteException("Space has disk problems", anIOE); | |
343 } | |
344 } | |
345 | |
346 if (myFails != null) | |
347 return new LeaseResults(null, myFails); | |
348 else | |
349 return null; | |
350 } | |
351 | |
352 private Exception[] initFails(int aLength, int anOffset) { | |
353 return new Exception[aLength]; | |
354 } | |
355 | |
356 /* ********************************************************************* | |
357 * Administrable::getAdmin support | |
358 ******************************************************************** */ | |
359 | |
360 public Object getAdmin() throws RemoteException { | |
361 stopBarrier(); | |
362 | |
363 return theAdminProxy; | |
364 } | |
365 | |
366 /* ********************************************************************* | |
367 * JoinAdmin | |
368 ******************************************************************** */ | |
369 /** | |
370 * Get the current attribute sets for the service. | |
371 * | |
372 * @return the current attribute sets for the service | |
373 * @throws java.rmi.RemoteException | |
374 */ | |
375 public Entry[] getLookupAttributes() throws RemoteException { | |
376 stopBarrier(); | |
377 | |
378 throw new UnsupportedOperationException(); | |
379 } | |
380 | |
381 /** | |
382 * Add attribute sets for the service. The resulting set will be used | |
383 * for all future joins. The attribute sets are also added to all | |
384 * currently-joined lookup services. | |
385 * | |
386 * @param attrSets the attribute sets to add | |
387 * @throws java.rmi.RemoteException | |
388 */ | |
389 public void addLookupAttributes(Entry[] attrSets) throws RemoteException { | |
390 stopBarrier(); | |
391 | |
392 throw new UnsupportedOperationException(); | |
393 } | |
394 | |
395 /** | |
396 * Modify the current attribute sets, using the same semantics as | |
397 * ServiceRegistration.modifyAttributes. The resulting set will be used | |
398 * for all future joins. The same modifications are also made to all | |
399 * currently-joined lookup services. | |
400 * | |
401 * @param attrSetTemplates the templates for matching attribute sets | |
402 * @param attrSets the modifications to make to matching sets | |
403 * @throws java.rmi.RemoteException | |
404 * | |
405 * @see net.jini.core.lookup.ServiceRegistration#modifyAttributes | |
406 */ | |
407 public void modifyLookupAttributes(Entry[] attrSetTemplates, | |
408 Entry[] attrSets) | |
409 throws RemoteException { | |
410 stopBarrier(); | |
411 | |
412 throw new UnsupportedOperationException(); | |
413 } | |
414 | |
415 /** | |
416 * Get the list of groups to join. An empty array means the service | |
417 * joins no groups (as opposed to "all" groups). | |
418 * | |
419 * @return an array of groups to join. An empty array means the service | |
420 * joins no groups (as opposed to "all" groups). | |
421 * @throws java.rmi.RemoteException | |
422 * @see #setLookupGroups | |
423 */ | |
424 public String[] getLookupGroups() throws RemoteException { | |
425 stopBarrier(); | |
426 | |
427 throw new UnsupportedOperationException(); | |
428 } | |
429 | |
430 /** | |
431 * Add new groups to the set to join. Lookup services in the new | |
432 * groups will be discovered and joined. | |
433 * | |
434 * @param groups groups to join | |
435 * @throws java.rmi.RemoteException | |
436 * @see #removeLookupGroups | |
437 */ | |
438 public void addLookupGroups(String[] groups) throws RemoteException { | |
439 stopBarrier(); | |
440 | |
441 throw new UnsupportedOperationException(); | |
442 } | |
443 | |
444 /** | |
445 * Remove groups from the set to join. Leases are cancelled at lookup | |
446 * services that are not members of any of the remaining groups. | |
447 * | |
448 * @param groups groups to leave | |
449 * @throws java.rmi.RemoteException | |
450 * @see #addLookupGroups | |
451 */ | |
452 public void removeLookupGroups(String[] groups) throws RemoteException { | |
453 stopBarrier(); | |
454 | |
455 throw new UnsupportedOperationException(); | |
456 } | |
457 | |
458 /** | |
459 * Replace the list of groups to join with a new list. Leases are | |
460 * cancelled at lookup services that are not members of any of the | |
461 * new groups. Lookup services in the new groups will be discovered | |
462 * and joined. | |
463 * | |
464 * @param groups groups to join | |
465 * @throws java.rmi.RemoteException | |
466 * @see #getLookupGroups | |
467 */ | |
468 public void setLookupGroups(String[] groups) throws RemoteException { | |
469 stopBarrier(); | |
470 | |
471 throw new UnsupportedOperationException(); | |
472 } | |
473 | |
474 private DiscoveryLocatorManagement getDLM() { | |
475 throw new UnsupportedOperationException(); | |
476 } | |
477 | |
478 /** | |
479 *Get the list of locators of specific lookup services to join. | |
480 * | |
481 * @return the list of locators of specific lookup services to join | |
482 * @throws java.rmi.RemoteException | |
483 * @see #setLookupLocators | |
484 */ | |
485 public LookupLocator[] getLookupLocators() throws RemoteException { | |
486 stopBarrier(); | |
487 | |
488 throw new UnsupportedOperationException(); | |
489 } | |
490 | |
491 /** | |
492 * Add locators for specific new lookup services to join. The new | |
493 * lookup services will be discovered and joined. | |
494 * | |
495 * @param locators locators of specific lookup services to join | |
496 * @throws java.rmi.RemoteException | |
497 * @see #removeLookupLocators | |
498 */ | |
499 public void addLookupLocators(LookupLocator[] locators) | |
500 throws RemoteException { | |
501 stopBarrier(); | |
502 | |
503 throw new UnsupportedOperationException(); | |
504 } | |
505 | |
506 /** | |
507 * Remove locators for specific lookup services from the set to join. | |
508 * Any leases held at the lookup services are cancelled. | |
509 * | |
510 * @param locators locators of specific lookup services to leave | |
511 * @throws java.rmi.RemoteException | |
512 * @see #addLookupLocators | |
513 */ | |
514 public void removeLookupLocators(LookupLocator[] locators) | |
515 throws RemoteException { | |
516 stopBarrier(); | |
517 | |
518 throw new UnsupportedOperationException(); | |
519 } | |
520 | |
521 /** | |
522 * Replace the list of locators of specific lookup services to join | |
523 * with a new list. Leases are cancelled at lookup services that were | |
524 * in the old list but are not in the new list. Any new lookup services | |
525 * will be discovered and joined. | |
526 * | |
527 * @param locators locators of specific lookup services to join | |
528 * @throws java.rmi.RemoteException | |
529 * @see #getLookupLocators | |
530 */ | |
531 public void setLookupLocators(LookupLocator[] locators) | |
532 throws RemoteException { | |
533 stopBarrier(); | |
534 | |
535 throw new UnsupportedOperationException(); | |
536 } | |
537 | |
538 public void destroy() throws RemoteException { | |
539 stopBarrier(); | |
540 | |
541 blockCalls(); | |
542 | |
543 try { | |
544 theSpace.stop(); | |
545 } catch (Exception anE) { | |
546 throw new RemoteException("Failed to destroy", anE); | |
547 } | |
548 } | |
549 | |
550 private void blockCalls() { | |
551 synchronized(this) { | |
552 isStopped = true; | |
553 } | |
554 } | |
555 | |
556 private void unblockCalls() { | |
557 synchronized(this) { | |
558 isStopped = false; | |
559 } | |
560 } | |
561 | |
562 /** | |
563 Used to check whether calls are blocked and, if they are, throws | |
564 a RemoteException back to the client. | |
565 */ | |
566 private void stopBarrier() throws RemoteException { | |
567 synchronized(this) { | |
568 if (isStopped) | |
569 throw new RemoteException("Remote calls not permitted"); | |
570 } | |
571 } | |
572 | |
573 public TxnControl getTxnControl() { | |
574 return theSpace.getTxnControl(); | |
575 } | |
576 | |
577 public void stop() throws RemoteException { | |
578 destroy(); | |
579 } | |
580 | |
581 /* ********************************************************************* | |
582 * StatsAdmin | |
583 ******************************************************************** */ | |
584 | |
585 public Stat[] getStats() throws RemoteException { | |
586 stopBarrier(); | |
587 | |
588 return StatsBoard.get().getStats(); | |
589 } | |
590 | |
591 public void setSwitches(Switch[] aListOfSwitches) throws RemoteException { | |
592 stopBarrier(); | |
593 | |
594 SwitchSettings.get().update(aListOfSwitches); | |
595 } | |
596 | |
597 /* ********************************************************************* | |
598 * EntryViewAdmin | |
599 ******************************************************************** */ | |
600 public JavaSpace getJavaSpaceProxy() throws RemoteException { | |
601 return theSpaceProxy; | |
602 } | |
603 | |
604 public ViewResult newView(MangledEntry[] aTemplates, Transaction aTxn, | |
605 long aLeaseDuration, boolean isJavaSpace05, | |
606 long aLimit, int anInitialChunk) | |
607 throws RemoteException, TransactionException { | |
608 | |
609 stopBarrier(); | |
610 | |
611 try { | |
612 long myDuration = aLeaseDuration; | |
613 | |
614 /* | |
615 Bound the lease if we're instructed to do so - we may not | |
616 be required to if this is an emulation of the old | |
617 JavaSpaceAdmin::contents call | |
618 */ | |
619 if (isJavaSpace05) | |
620 myDuration = LeaseBounds.boundView(aLeaseDuration); | |
621 | |
622 /* | |
623 * JavaSpace05 holds locks only for a non-null transaction. | |
624 * JavaSpaceAdmin never holds locks but uses the transaction to | |
625 * test visibility | |
626 */ | |
627 boolean holdLocks = | |
628 (isJavaSpace05) ? (aTxn != null) : false; | |
629 | |
630 /* | |
631 If we're being asked to do JavaSpace05, we're performing the new contents | |
632 operation which means we should pass true for holdlocks, false otherwise | |
633 */ | |
634 ViewRegistration myReg = | |
635 EntryViewFactory.get().newView(aTemplates, aTxn, holdLocks, | |
636 myDuration, aLimit, theSpace); | |
637 | |
638 /* | |
639 Okay, got a view, now we need an initial batch | |
640 */ | |
641 EntryChit[] myInitialBatch = getNext(myReg.getUID(), anInitialChunk); | |
642 | |
643 return new ViewResult( | |
644 ProxyFactory.newLeaseImpl(this, theUuid, | |
645 myReg.getUID(), | |
646 myReg.getExpiry()), | |
647 myInitialBatch); | |
648 } catch (IOException anIOE) { | |
649 throw new RemoteException("Failed to create view", anIOE); | |
650 } | |
651 } | |
652 | |
653 public EntryChit[] getNext(EntryViewUID aUid, int aChunkSize) | |
654 throws RemoteException { | |
655 | |
656 stopBarrier(); | |
657 | |
658 ArrayList myNext = new ArrayList(); | |
659 | |
660 EntryView myView = EntryViewFactory.get().getView(aUid); | |
661 | |
662 /* | |
663 View could have expired or been otherwise lost | |
664 */ | |
665 if (myView == null) | |
666 throw new NoSuchObjectException("View has been lost"); | |
667 | |
668 try { | |
669 for (int i = 0; i < aChunkSize; i++) { | |
670 EntryChit myChit = myView.next(); | |
671 | |
672 if (myChit == null) | |
673 break; | |
674 else | |
675 myNext.add(myChit); | |
676 } | |
677 } catch (TransactionException aTE) { | |
678 throw new RemoteException("View was prematurely destroyed - was a transaction ended?", aTE); | |
679 } catch (IOException anIOE) { | |
680 throw new RemoteException("Couldn't recover an Entry", anIOE); | |
681 } | |
682 | |
683 if (myNext.size() == 0) | |
684 return null; | |
685 | |
686 EntryChit[] myChits = new EntryChit[myNext.size()]; | |
687 myChits = (EntryChit[]) myNext.toArray(myChits); | |
688 | |
689 return myChits; | |
690 } | |
691 | |
692 /** | |
693 Deletes a specific entity returned from an | |
694 <code>EntryView</code> via an <code>EntryChit</code> | |
695 */ | |
696 public void delete(Object aCookie) throws RemoteException { | |
697 stopBarrier(); | |
698 | |
699 try { | |
700 theSpace.getLeaseControl().cancel((SpaceUID) aCookie); | |
701 } catch (IOException anIOE) { | |
702 theLogger.log(Level.SEVERE, "Space has disk problems", anIOE); | |
703 throw new RemoteException("Space has disk problems", anIOE); | |
704 } catch (UnknownLeaseException aULE) { | |
705 // It's gone already, fail silently | |
706 } | |
707 } | |
708 | |
709 public void close(EntryViewUID aUid) throws RemoteException { | |
710 stopBarrier(); | |
711 | |
712 EntryViewFactory.get().delete(aUid); | |
713 } | |
714 | |
715 /* ********************************************************************* | |
716 * JavaSpace05 | |
717 ******************************************************************** */ | |
718 | |
719 public List write(List aMangledEntries, Transaction aTxn, List aLeaseTimes) | |
720 throws RemoteException, TransactionException { | |
721 | |
722 stopBarrier(); | |
723 | |
724 try { | |
725 List myTickets = theSpace.write(aMangledEntries, aTxn, aLeaseTimes); | |
726 | |
727 for (int i = 0; i < myTickets.size(); i++) { | |
728 WriteTicket myTicket = (WriteTicket) myTickets.get(i); | |
729 | |
730 Lease myLease = | |
731 ProxyFactory.newEntryLeaseImpl(this, theUuid, | |
732 myTicket.getUID(), | |
733 myTicket.getExpirationTime()); | |
734 | |
735 myTickets.set(i, myLease); | |
736 } | |
737 | |
738 return myTickets; | |
739 } catch (IOException anIOE) { | |
740 theLogger.log(Level.SEVERE, "SpaceImpl has disk problems", anIOE); | |
741 throw new RemoteException("Space has disk problems", anIOE); | |
742 } | |
743 } | |
744 | |
745 public List take(MangledEntry[] aTemplates, Transaction aTxn, | |
746 long aWaitTime, long aLimit) | |
747 throws RemoteException, TransactionException { | |
748 | |
749 stopBarrier(); | |
750 | |
751 try { | |
752 return theSpace.take(aTemplates, aTxn, aWaitTime, aLimit); | |
753 } catch (IOException anIOE) { | |
754 theLogger.log(Level.SEVERE, "SpaceImpl has disk problems", anIOE); | |
755 throw new RemoteException("Space has disk problems", anIOE); | |
756 } | |
757 } | |
758 | |
759 public EventRegistration | |
760 registerForVisibility(MangledEntry[] aTemplates, Transaction aTxn, | |
761 RemoteEventListener aListener, long aLeaseTime, | |
762 MarshalledObject aHandback, | |
763 boolean visibilityOnly) | |
764 throws RemoteException, TransactionException { | |
765 | |
766 stopBarrier(); | |
767 | |
768 try { | |
769 RegTicket myTicket = | |
770 theSpace.visibility(aTemplates, aTxn, aListener, aLeaseTime, | |
771 aHandback, visibilityOnly); | |
772 | |
773 LeaseImpl myLease = | |
774 ProxyFactory.newLeaseImpl(this, theUuid, | |
775 myTicket.getUID(), | |
776 myTicket.getExpirationTime()); | |
777 | |
778 return new EventRegistration(myTicket.getSourceId(), theSpaceProxy, | |
779 myLease, myTicket.getSeqNum()); | |
780 } catch (IOException anIOE) { | |
781 theLogger.log(Level.SEVERE, "SpaceImpl has disk problems", anIOE); | |
782 throw new RemoteException("Space has disk problems", anIOE); | |
783 } | |
784 } | |
785 | |
786 /* ********************************************************************* | |
787 * BlitzAdmin | |
788 ******************************************************************** */ | |
789 public void requestSnapshot() throws RemoteException, | |
790 TransactionException, IOException { | |
791 stopBarrier(); | |
792 theSpace.getTxnControl().requestSnapshot(); | |
793 } | |
794 | |
795 public void shutdown() throws RemoteException { | |
796 // stopBarrier is done in destroyImpl | |
797 destroy(); | |
798 } | |
799 | |
800 public void backup(String aDir) throws RemoteException, IOException { | |
801 stopBarrier(); | |
802 theSpace.getTxnControl().backup(aDir); | |
803 } | |
804 | |
805 public void clean() throws RemoteException, IOException { | |
806 stopBarrier(); | |
807 | |
808 blockCalls(); | |
809 | |
810 theSpace.empty(); | |
811 | |
812 unblockCalls(); | |
813 } | |
814 | |
815 public void reap() throws RemoteException { | |
816 theSpace.reap(); | |
817 } | |
818 | |
819 /* ********************************************************************* | |
820 * ServiceProxyAccessor | |
821 ******************************************************************** */ | |
822 | |
823 public Object getServiceProxy() throws RemoteException { | |
824 stopBarrier(); | |
825 | |
826 return theSpaceProxy; | |
827 } | |
828 } |