cpp/test/Ice/background/Server.cpp

   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 #include <IceUtil/DisableWarnings.h>
  11 #include <Ice/Ice.h>
  12 #include <TestI.h>
  13 #include <Configuration.h>
  14 #include <PluginI.h>
  15
  16 #include <Ice/Locator.h>
  17 #include <Ice/Router.h>
  18
  19 using namespace std;
  20
  21 class LocatorI : public Ice::Locator
  22 {
  23 public:
  24
  25     virtual void
  26     findAdapterById_async(const Ice::AMD_Locator_findAdapterByIdPtr& response, const string& adapter,
  27                           const Ice::Current& current) const
  28     {
  29         _controller->checkCallPause(current);
  30         Ice::CommunicatorPtr communicator = current.adapter->getCommunicator();
  31         response->ice_response(current.adapter->createDirectProxy(communicator->stringToIdentity("dummy")));
  32     }
  33
  34     virtual void
  35     findObjectById_async(const Ice::AMD_Locator_findObjectByIdPtr& response, const Ice::Identity& id,
  36                          const Ice::Current& current) const
  37     {
  38         _controller->checkCallPause(current);
  39         Ice::CommunicatorPtr communicator = current.adapter->getCommunicator();
  40         response->ice_response(current.adapter->createDirectProxy(id));
  41     }
  42
  43     virtual Ice::LocatorRegistryPrx
  44     getRegistry(const Ice::Current&) const
  45     {
  46         return 0;
  47     }
  48
  49     LocatorI(const BackgroundControllerIPtr& controller) : _controller(controller)
  50     {
  51     }
  52
  53 private:
  54
  55     BackgroundControllerIPtr _controller;
  56 };
  57
  58 class RouterI : public Ice::Router
  59 {
  60 public:
  61
  62     virtual Ice::ObjectPrx
  63     getClientProxy(const Ice::Current& current) const
  64     {
  65         _controller->checkCallPause(current);
  66         return 0;
  67     }
  68
  69     virtual Ice::ObjectPrx
  70     getServerProxy(const Ice::Current& current) const
  71     {
  72         _controller->checkCallPause(current);
  73         return 0;
  74     }
  75
  76     virtual void
  77     addProxy(const Ice::ObjectPrx&, const Ice::Current&)
  78     {
  79     }
  80
  81     virtual Ice::ObjectProxySeq
  82     addProxies(const Ice::ObjectProxySeq&, const Ice::Current&)
  83     {
  84         return Ice::ObjectProxySeq();
  85     }
  86
  87     RouterI(const BackgroundControllerIPtr& controller)
  88     {
  89         _controller = controller;
  90     }
  91
  92 private:
  93
  94     BackgroundControllerIPtr _controller;
  95 };
  96
  97
  98 int
  99 run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
 100 {
 101     communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -p 12010");
 102     communicator->getProperties()->setProperty("ControllerAdapter.Endpoints", "tcp -p 12011");
 103     communicator->getProperties()->setProperty("ControllerAdapter.ThreadPool.Size", "1");
 104
 105     Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
 106     Ice::ObjectAdapterPtr adapter2 = communicator->createObjectAdapter("ControllerAdapter");
 107
 108     PluginI* plugin = dynamic_cast<PluginI*>(communicator->getPluginManager()->getPlugin("Test").get());
 109     assert(plugin);
 110     ConfigurationPtr configuration = plugin->getConfiguration();
 111     BackgroundControllerIPtr backgroundController = new BackgroundControllerI(adapter, configuration);
 112
 113     adapter->add(new BackgroundI(backgroundController), communicator->stringToIdentity("background"));
 114     adapter->add(new LocatorI(backgroundController), communicator->stringToIdentity("locator"));
 115     adapter->add(new RouterI(backgroundController), communicator->stringToIdentity("router"));
 116     adapter->activate();
 117
 118     adapter2->add(backgroundController, communicator->stringToIdentity("backgroundController"));
 119     adapter2->activate();
 120
 121     communicator->waitForShutdown();
 122     return EXIT_SUCCESS;
 123 }
 124
 125 int
 126 main(int argc, char* argv[])
 127 {
 128     int status;
 129     Ice::CommunicatorPtr communicator;
 130
 131     try
 132     {
 133         Ice::InitializationData initData;
 134         initData.properties = Ice::createProperties(argc, argv);
 135
 136         //
 137         // This test kills connections, so we don't want warnings.
 138         //
 139         initData.properties->setProperty("Ice.Warn.Connections", "0");
 140
 141         //
 142         // Setup the test transport plug-in.
 143         //
 144         initData.properties->setProperty("Ice.Plugin.Test", "TestTransport:createTestTransport");
 145         string defaultProtocol = initData.properties->getPropertyWithDefault("Ice.Default.Protocol", "tcp");
 146         initData.properties->setProperty("Ice.Default.Protocol", "test-" + defaultProtocol);
 147
 148         communicator = Ice::initialize(argc, argv, initData);
 149         status = run(argc, argv, communicator);
 150     }
 151     catch(const Ice::Exception& ex)
 152     {
 153         cerr << ex << endl;
 154         status = EXIT_FAILURE;
 155     }
 156
 157     if(communicator)
 158     {
 159         try
 160         {
 161             communicator->destroy();
 162         }
 163         catch(const Ice::Exception& ex)
 164         {
 165             cerr << ex << endl;
 166             status = EXIT_FAILURE;
 167         }
 168     }
 169
 170     return status;
 171 }