py/test/Ice/location/Server.py

   1 #!/usr/bin/env python
   2 # **********************************************************************
   3 #
   4 # Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   5 #
   6 # This copy of Ice is licensed to you under the terms described in the
   7 # ICE_LICENSE file included in this distribution.
   8 #
   9 # **********************************************************************
  10
  11 import os, sys, traceback
  12
  13 import Ice
  14 slice_dir = Ice.getSliceDir()
  15 if not slice_dir:
  16     print sys.argv[0] + ': Slice directory not found.'
  17     sys.exit(1)
  18
  19 Ice.loadSlice("'-I" + slice_dir + "' Test.ice")
  20 import Test
  21
  22 class ServerLocatorRegistry(Test.TestLocatorRegistry):
  23     def __init__(self):
  24         self._adapters = {}
  25         self._objects = {}
  26
  27     def setAdapterDirectProxy_async(self, cb, adapter, obj, current=None):
  28         if obj:
  29             self._adapters[adapter] = obj
  30         else:
  31             self._adapters.pop(adapter)
  32         cb.ice_response()
  33
  34     def setReplicatedAdapterDirectProxy_async(self, cb, adapter, replica, obj, current=None):
  35         if obj:
  36             self._adapters[adapter] = obj
  37             self._adapters[replica] = obj
  38         else:
  39             self._adapters.pop(adapter)
  40             self._adapters.pop(replica)
  41         cb.ice_response()
  42
  43     def setServerProcessProxy_async(self, id, proxy, current=None):
  44         cb.ice_response()
  45
  46     def addObject(self, obj, current=None):
  47         self._objects[obj.ice_getIdentity()] = obj
  48
  49     def getAdapter(self, adapter):
  50         if not self._adapters.has_key(adapter):
  51             raise Ice.AdapterNotFoundException()
  52         return self._adapters[adapter]
  53
  54     def getObject(self, id):
  55         if not self._objects.has_key(id):
  56             raise Ice.ObjectNotFoundException()
  57         return self._objects[id]
  58
  59 class ServerLocator(Test.TestLocator):
  60
  61     def __init__(self, registry, registryPrx):
  62         self._registry = registry
  63         self._registryPrx = registryPrx
  64         self._requestCount = 0
  65
  66     def findObjectById_async(self, response, id, current=None):
  67         self._requestCount += 1
  68         response.ice_response(self._registry.getObject(id))
  69
  70     def findAdapterById_async(self, response, id, current=None):
  71         self._requestCount += 1
  72         response.ice_response(self._registry.getAdapter(id))
  73
  74     def getRegistry(self, current=None):
  75         return self._registryPrx
  76
  77     def getRequestCount(self, current=None):
  78         return self._requestCount
  79
  80 class ServerManagerI(Test.ServerManager):
  81     def __init__(self, registry, initData):
  82         self._registry = registry
  83         self._communicators = []
  84         self._initData = initData
  85         self._initData.properties.setProperty("TestAdapter.Endpoints", "default")
  86         self._initData.properties.setProperty("TestAdapter.AdapterId", "TestAdapter")
  87         self._initData.properties.setProperty("TestAdapter.ReplicaGroupId", "ReplicatedAdapter")
  88         self._initData.properties.setProperty("TestAdapter2.Endpoints", "default")
  89         self._initData.properties.setProperty("TestAdapter2.AdapterId", "TestAdapter2")
  90
  91     def startServer(self, current=None):
  92
  93         #
  94         # Simulate a server: create a new communicator and object
  95         # adapter. The object adapter is started on a system allocated
  96         # port. The configuration used here contains the Ice.Locator
  97         # configuration variable. The new object adapter will register
  98         # its endpoints with the locator and create references containing
  99         # the adapter id instead of the endpoints.
 100         #
 101         serverCommunicator = Ice.initialize(data=initData)
 102         self._communicators.append(serverCommunicator)
 103         adapter = serverCommunicator.createObjectAdapter("TestAdapter")
 104
 105         adapter2 = serverCommunicator.createObjectAdapter("TestAdapter2")
 106
 107         locator = serverCommunicator.stringToProxy("locator:default -p 12010")
 108         adapter.setLocator(Ice.LocatorPrx.uncheckedCast(locator))
 109         adapter2.setLocator(Ice.LocatorPrx.uncheckedCast(locator))
 110
 111         object = TestI(adapter, adapter2, self._registry)
 112         self._registry.addObject(adapter.add(object, communicator.stringToIdentity("test")))
 113         self._registry.addObject(adapter.add(object, communicator.stringToIdentity("test2")))
 114         adapter.add(object, communicator.stringToIdentity("test3"))
 115
 116         adapter.activate()
 117         adapter2.activate()
 118
 119     def shutdown(self, current=None):
 120         for i in self._communicators:
 121             i.destroy()
 122         current.adapter.getCommunicator().shutdown()
 123
 124 class HelloI(Test.Hello):
 125     def sayHello(self, current=None):
 126         pass
 127
 128 class TestI(Test.TestIntf):
 129     def __init__(self, adapter, adapter2, registry):
 130         self._adapter1 = adapter
 131         self._adapter2 = adapter2
 132         self._registry = registry
 133         self._registry.addObject(self._adapter1.add(HelloI(), communicator.stringToIdentity("hello")))
 134
 135     def shutdown(self, current=None):
 136         self._adapter1.getCommunicator().shutdown()
 137
 138     def getHello(self, current=None):
 139         return Test.HelloPrx.uncheckedCast(self._adapter1.createIndirectProxy(communicator.stringToIdentity("hello")))
 140
 141     def getReplicatedHello(self, current=None):
 142         return Test.HelloPrx.uncheckedCast(self._adapter1.createProxy(communicator.stringToIdentity("hello")))
 143
 144     def migrateHello(self, current=None):
 145         id = communicator.stringToIdentity("hello")
 146         try:
 147             self._registry.addObject(self._adapter2.add(self._adapter1.remove(id), id))
 148         except Ice.NotRegisteredException:
 149             self._registry.addObject(self._adapter1.add(self._adapter2.remove(id), id))
 150
 151 def run(args, communicator, initData):
 152     #
 153     # Register the server manager. The server manager creates a new
 154     # 'server' (a server isn't a different process, it's just a new
 155     # communicator and object adapter).
 156     #
 157     properties = communicator.getProperties()
 158     properties.setProperty("Ice.ThreadPool.Server.Size", "2")
 159     properties.setProperty("ServerManager.Endpoints", "default -p 12010:udp")
 160
 161     adapter = communicator.createObjectAdapter("ServerManager")
 162
 163     #
 164     # We also register a sample server locator which implements the
 165     # locator interface, this locator is used by the clients and the
 166     # 'servers' created with the server manager interface.
 167     #
 168     registry = ServerLocatorRegistry()
 169     registry.addObject(adapter.createProxy(communicator.stringToIdentity("ServerManager")))
 170     object = ServerManagerI(registry, initData)
 171     adapter.add(object, communicator.stringToIdentity("ServerManager"))
 172
 173     registryPrx = Ice.LocatorRegistryPrx.uncheckedCast(adapter.add(registry, communicator.stringToIdentity("registry")))
 174
 175     locator = ServerLocator(registry, registryPrx)
 176     adapter.add(locator, communicator.stringToIdentity("locator"))
 177
 178     adapter.activate()
 179     communicator.waitForShutdown()
 180
 181     return True
 182
 183 try:
 184     initData = Ice.InitializationData()
 185     initData.properties = Ice.createProperties(sys.argv)
 186     communicator = Ice.initialize(sys.argv, initData)
 187     status = run(sys.argv, communicator, initData)
 188 except:
 189     traceback.print_exc()
 190     status = False
 191
 192 if communicator:
 193     try:
 194         communicator.destroy()
 195     except:
 196         traceback.print_exc()
 197         status = False
 198
 199 sys.exit(not status)