java/test/Freeze/evictor/RemoteEvictorI.java

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 package test.Freeze.evictor;
  11 import test.Freeze.evictor.Test.*;
  12
  13 public final class RemoteEvictorI extends _RemoteEvictorDisp
  14 {
  15     private static void
  16     test(boolean b)
  17     {
  18         if(!b)
  19         {
  20             throw new RuntimeException();
  21         }
  22     }
  23
  24     static class Initializer implements Freeze.ServantInitializer
  25     {
  26         public void
  27         initialize(Ice.ObjectAdapter adapter, Ice.Identity ident, String facet, Ice.Object servant)
  28         {
  29             if(servant instanceof AccountI)
  30             {
  31                 AccountI account = (AccountI)servant;
  32                 account.init((Freeze.TransactionalEvictor)_evictor);
  33             }
  34             else if(facet.length() == 0)
  35             {
  36                 ServantI servantImpl =  (ServantI) ((_ServantTie) servant).ice_delegate();
  37                 servantImpl.init(_remoteEvictor, _evictor);
  38             }
  39             else
  40             {
  41                 ServantI servantImpl =  (ServantI) ((_FacetTie) servant).ice_delegate();
  42                 servantImpl.init(_remoteEvictor, _evictor);
  43             }
  44         }
  45
  46         void init(RemoteEvictorI remoteEvictor, Freeze.Evictor evictor)
  47         {
  48             _remoteEvictor = remoteEvictor;
  49             _evictor = evictor;
  50         }
  51
  52         private RemoteEvictorI _remoteEvictor;
  53         private Freeze.Evictor _evictor;
  54     }
  55
  56     RemoteEvictorI(Ice.Communicator communicator, String envName, String category, boolean transactional)
  57     {
  58         _envName = envName;
  59         _category = category;
  60
  61         //
  62         // NOTE: COMPILERBUG: The timeout here is required for MacOS X. It shouldn't be too low since
  63         // some operations can take some time to complete on slow machines.
  64         //
  65         _evictorAdapter = communicator.
  66             createObjectAdapterWithEndpoints(java.util.UUID.randomUUID().toString(), "default -t 60000");
  67
  68         Initializer initializer = new Initializer();
  69
  70         if(transactional)
  71         {
  72             _evictor = Freeze.Util.createTransactionalEvictor(_evictorAdapter, envName, category, null, initializer,
  73                                                               null, true);
  74         }
  75         else
  76         {
  77             _evictor = Freeze.Util.createBackgroundSaveEvictor(_evictorAdapter, envName, category, initializer, null,
  78                                                                true);
  79         }
  80
  81         //
  82         // Check that we can get an iterator on a non-existing facet
  83         //
  84         Freeze.EvictorIterator p = _evictor.getIterator("foo", 1);
  85         test(p.hasNext() == false);
  86
  87         initializer.init(this, _evictor);
  88
  89         _evictorAdapter.addServantLocator(_evictor, category);
  90         _evictorAdapter.activate();
  91     }
  92
  93     public void
  94     setSize(int size, Ice.Current current)
  95     {
  96         _evictor.setSize(size);
  97     }
  98
  99     public ServantPrx
 100     createServant(String id, int value, Ice.Current current)
 101         throws AlreadyRegisteredException, EvictorDeactivatedException
 102     {
 103         Ice.Identity ident = new Ice.Identity();
 104         ident.category = _category;
 105         ident.name = id;
 106         _ServantTie tie = new _ServantTie();
 107         tie.ice_delegate(new ServantI(tie, this, _evictor, value));
 108         try
 109         {
 110             return ServantPrxHelper.uncheckedCast(_evictor.add(tie, ident));
 111         }
 112         catch(Ice.AlreadyRegisteredException e)
 113         {
 114             throw new AlreadyRegisteredException();
 115         }
 116         catch(Ice.ObjectAdapterDeactivatedException e)
 117         {
 118             throw new EvictorDeactivatedException();
 119         }
 120         catch(Freeze.EvictorDeactivatedException e)
 121         {
 122             throw new EvictorDeactivatedException();
 123         }
 124         catch(Ice.LocalException e)
 125         {
 126             System.out.println("Throwing " + e.toString());
 127             throw e;
 128         }
 129     }
 130
 131     public ServantPrx
 132     getServant(String id, Ice.Current current)
 133     {
 134         Ice.Identity ident = new Ice.Identity();
 135         ident.category = _category;
 136         ident.name = id;
 137         return ServantPrxHelper.uncheckedCast(_evictorAdapter.createProxy(ident));
 138     }
 139
 140     public void
 141     saveNow(Ice.Current current)
 142     {
 143         if(_evictor instanceof Freeze.BackgroundSaveEvictor)
 144         {
 145             _evictor.getIterator("", 1);
 146         }
 147         //
 148         // Otherwise everything is always saved
 149         //
 150     }
 151
 152     public void
 153     deactivate(Ice.Current current)
 154     {
 155         _evictorAdapter.destroy();
 156         current.adapter.remove(current.adapter.getCommunicator().stringToIdentity(_category));
 157     }
 158
 159     public void
 160     destroyAllServants(String facet, Ice.Current current)
 161     {
 162         //
 163         // Only for test purpose: don't use such a small value in
 164         // a real application!
 165         //
 166         int batchSize = 2;
 167
 168         Freeze.EvictorIterator p = _evictor.getIterator(facet, batchSize);
 169         while(p.hasNext())
 170         {
 171             _evictor.remove((Ice.Identity) p.next());
 172         }
 173     }
 174
 175     final public String
 176     envName()
 177     {
 178         return _envName;
 179     }
 180
 181     private final String _envName;
 182     private String _category;
 183     private Freeze.Evictor _evictor;
 184     private Ice.ObjectAdapter _evictorAdapter;
 185 }