java/demo/Freeze/casino/Server.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 class Server extends Ice.Application
  11 {
  12     static class ObjectFactory implements Ice.ObjectFactory
  13     {
  14         ObjectFactory(Class factoryClass)
  15         {
  16             _factoryClass = factoryClass;
  17         }
  18
  19         public Ice.Object
  20         create(String type)
  21         {
  22             try
  23             {
  24                 return (Ice.Object)_factoryClass.newInstance();
  25             }
  26             catch(InstantiationException ex)
  27             {
  28                 throw new Ice.InitializationException(ex.toString());
  29             }
  30             catch(IllegalAccessException ex)
  31             {
  32                 throw new Ice.InitializationException(ex.toString());
  33             }
  34         }
  35
  36         public void
  37         destroy()
  38         {
  39         }
  40
  41         private Class _factoryClass;
  42     }
  43
  44     private java.util.Map<String, String>
  45     createTypeMap(String defaultFacetType)
  46     {
  47         java.util.Map<String, String> result = new java.util.HashMap<String, String>();
  48         result.put("", defaultFacetType);
  49         return result;
  50     }
  51
  52     public int
  53     run(String[] args)
  54     {
  55         if(args.length > 0)
  56         {
  57             System.err.println(appName() + ": too many arguments");
  58             return 1;
  59         }
  60
  61         Ice.Properties properties = communicator().getProperties();
  62
  63         _bankEdge = properties.getPropertyAsInt("Bank.Edge");
  64         if(_bankEdge < 1)
  65         {
  66             _bankEdge = 1;
  67         }
  68         System.out.println("Bank edge is " + _bankEdge);
  69
  70         //
  71         // Create an object adapter
  72         //
  73         Ice.ObjectAdapter adapter = communicator().createObjectAdapter("Casino");
  74
  75         //
  76         // Register factories
  77         //
  78         communicator().addObjectFactory(new ObjectFactory(BankI.class), CasinoStore.PersistentBank.ice_staticId());
  79         communicator().addObjectFactory(new ObjectFactory(PlayerI.class), CasinoStore.PersistentPlayer.ice_staticId());
  80         communicator().addObjectFactory(new ObjectFactory(BetI.class), CasinoStore.PersistentBet.ice_staticId());
  81
  82         //
  83         // Create evictors; each type gets its own type-specific evictor
  84         //
  85
  86         //
  87         // Bank evictor
  88         //
  89
  90         Freeze.ServantInitializer bankInitializer = new Freeze.ServantInitializer()
  91             {
  92                 public void
  93                 initialize(Ice.ObjectAdapter adapter, Ice.Identity identity, String facet, Ice.Object servant)
  94                 {
  95                     ((BankI)servant).init(_bankPrx, _bankEvictor, _playerEvictor, _betEvictor, _betResolver, _bankEdge);
  96                 }
  97             };
  98
  99         _bankEvictor =
 100             Freeze.Util.createTransactionalEvictor(adapter, _envName, "bank",
 101                                                    createTypeMap(CasinoStore.PersistentBank.ice_staticId()),
 102                                                    bankInitializer, null, true);
 103
 104         int size = properties.getPropertyAsInt("Bank.EvictorSize");
 105         if(size > 0)
 106         {
 107             _bankEvictor.setSize(size);
 108         }
 109
 110         adapter.addServantLocator(_bankEvictor, "bank");
 111
 112         //
 113         // Player evictor
 114         //
 115
 116         Freeze.ServantInitializer playerInitializer = new Freeze.ServantInitializer()
 117             {
 118                 public void
 119                 initialize(Ice.ObjectAdapter adapter, Ice.Identity identity, String facet, Ice.Object servant)
 120                 {
 121                     CasinoStore.PersistentPlayerPrx prx =
 122                         CasinoStore.PersistentPlayerPrxHelper.uncheckedCast(adapter.createProxy(identity));
 123                     ((PlayerI)servant).init(prx, _playerEvictor, _bankPrx);
 124                 }
 125             };
 126
 127         _playerEvictor =
 128             Freeze.Util.createTransactionalEvictor(adapter, _envName, "player",
 129                                                    createTypeMap(CasinoStore.PersistentPlayer.ice_staticId()),
 130                                                    playerInitializer, null, true);
 131
 132         size = properties.getPropertyAsInt("Player.EvictorSize");
 133         if(size > 0)
 134         {
 135             _playerEvictor.setSize(size);
 136         }
 137
 138         adapter.addServantLocator(_playerEvictor, "player");
 139
 140         //
 141         // Bet evictor
 142         //
 143
 144         Freeze.ServantInitializer betInitializer = new Freeze.ServantInitializer()
 145             {
 146                 public void
 147                 initialize(Ice.ObjectAdapter adapter, Ice.Identity identity, String facet, Ice.Object servant)
 148                 {
 149                     ((BetI)servant).init(_betEvictor, _bankEdge);
 150                 }
 151             };
 152
 153         _betEvictor =
 154             Freeze.Util.createTransactionalEvictor(adapter, _envName, "bet",
 155                                                    createTypeMap(CasinoStore.PersistentBet.ice_staticId()),
 156                                                    betInitializer, null, true);
 157         size = properties.getPropertyAsInt("Bet.EvictorSize");
 158         if(size > 0)
 159         {
 160             _betEvictor.setSize(size);
 161         }
 162
 163         adapter.addServantLocator(_betEvictor, "bet");
 164
 165         //
 166         // Prepare startup
 167         //
 168
 169         _betResolver = new BetResolver();
 170
 171         try
 172         {
 173             //
 174             // Retrieve / create the bank
 175             //
 176
 177             Ice.Identity bankId = Ice.Util.stringToIdentity("bank/Montecito");
 178             _bankPrx = CasinoStore.PersistentBankPrxHelper.uncheckedCast(adapter.createProxy(bankId));
 179
 180             if(!_bankEvictor.hasObject(bankId))
 181             {
 182                 _bankEvictor.add(
 183                     new BankI(_bankPrx, _bankEvictor, _playerEvictor, _betEvictor, _betResolver, _bankEdge),
 184                     bankId);
 185             }
 186
 187             //
 188             // reload existing bets into the bet resolver
 189             //
 190             _bankPrx.reloadBets();
 191
 192             //
 193             // Create players / recreate missing players using a transaction
 194             // (the transaction is not really necessary here, but a good demo)
 195             //
 196
 197             String[] players =
 198                 { "al", "bob", "charlie", "dave", "ed", "fred", "gene", "herb", "irvin", "joe", "ken", "lance" };
 199
 200
 201             Freeze.Connection connection = Freeze.Util.createConnection(communicator(), _envName);
 202             Freeze.Transaction tx = connection.beginTransaction();
 203
 204             _playerEvictor.setCurrentTransaction(tx);
 205
 206             for(String player : players)
 207             {
 208                 Ice.Identity ident = new Ice.Identity(player, "player");
 209                 if(!_playerEvictor.hasObject(ident))
 210                 {
 211                     _playerEvictor.add(new PlayerI(), ident);
 212                 }
 213             }
 214
 215             tx.commit();
 216             assert(_playerEvictor.getCurrentTransaction() == null);
 217             connection.close();
 218
 219
 220             //
 221             // Everything is ready, activate
 222             //
 223             adapter.activate();
 224
 225             shutdownOnInterrupt();
 226             communicator().waitForShutdown();
 227             defaultInterrupt();
 228         }
 229         finally
 230         {
 231             _betResolver.cancel();
 232         }
 233         return 0;
 234     }
 235
 236     Server(String envName)
 237     {
 238         _envName = envName;
 239     }
 240
 241     static public void
 242     main(String[] args)
 243     {
 244         Server app = new Server("db");
 245         app.main("demo.Freeze.casino.Server", args, "config.server");
 246     }
 247
 248     private String _envName;
 249
 250     private CasinoStore.PersistentBankPrx _bankPrx;
 251     private Freeze.TransactionalEvictor _bankEvictor;
 252     private Freeze.TransactionalEvictor _playerEvictor;
 253     private Freeze.TransactionalEvictor _betEvictor;
 254     private BetResolver _betResolver;
 255     private int _bankEdge;
 256 }