cs/test/Ice/background/Server.cs

   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 using System;
  11 using System.IO;
  12 using System.Diagnostics;
  13 using System.Reflection;
  14
  15 [assembly: CLSCompliant(true)]
  16
  17 [assembly: AssemblyTitle("IceTest")]
  18 [assembly: AssemblyDescription("Ice test")]
  19 [assembly: AssemblyCompany("ZeroC, Inc.")]
  20
  21 public class Server
  22 {
  23     internal class LocatorI : Ice.LocatorDisp_
  24     {
  25         public override void findAdapterById_async(Ice.AMD_Locator_findAdapterById response, string adapter,
  26                                                    Ice.Current current)
  27         {
  28             _controller.checkCallPause(current);
  29             Ice.Communicator communicator = current.adapter.getCommunicator();
  30             response.ice_response(current.adapter.createDirectProxy(communicator.stringToIdentity("dummy")));
  31         }
  32
  33         public override void findObjectById_async(Ice.AMD_Locator_findObjectById response, Ice.Identity id,
  34                                                   Ice.Current current)
  35         {
  36             _controller.checkCallPause(current);
  37             response.ice_response(current.adapter.createDirectProxy(id));
  38         }
  39
  40         public override Ice.LocatorRegistryPrx getRegistry(Ice.Current current)
  41         {
  42             return null;
  43         }
  44
  45         internal LocatorI(BackgroundControllerI controller)
  46         {
  47             _controller = controller;
  48         }
  49
  50         private BackgroundControllerI _controller;
  51     }
  52
  53     internal class RouterI : Ice.RouterDisp_
  54     {
  55         public override Ice.ObjectPrx getClientProxy(Ice.Current current)
  56         {
  57             _controller.checkCallPause(current);
  58             return null;
  59         }
  60
  61         public override Ice.ObjectPrx getServerProxy(Ice.Current current)
  62         {
  63             _controller.checkCallPause(current);
  64             return null;
  65         }
  66
  67         public override void addProxy(Ice.ObjectPrx proxy, Ice.Current current)
  68         {
  69         }
  70
  71         public override Ice.ObjectPrx[] addProxies(Ice.ObjectPrx[] proxies, Ice.Current current)
  72         {
  73             return new Ice.ObjectPrx[0];
  74         }
  75
  76         internal RouterI(BackgroundControllerI controller)
  77         {
  78             _controller = controller;
  79         }
  80
  81         private BackgroundControllerI _controller;
  82     }
  83
  84     public static int run(string[] args, Ice.Communicator communicator, TextWriter @out)
  85     {
  86         //
  87         // When running as a MIDlet the properties for the server may be
  88         // overridden by configuration. If it isn't then we assume
  89         // defaults.
  90         //
  91         if(communicator.getProperties().getProperty("TestAdapter.Endpoints").Length == 0)
  92         {
  93             communicator.getProperties().setProperty("TestAdapter.Endpoints", "default -p 12010");
  94         }
  95         if(communicator.getProperties().getProperty("ControllerAdapter.Endpoints").Length == 0)
  96         {
  97             communicator.getProperties().setProperty("ControllerAdapter.Endpoints", "tcp -p 12011");
  98             communicator.getProperties().setProperty("ControllerAdapter.ThreadPool.Size", "1");
  99         }
 100
 101         Ice.ObjectAdapter adapter = communicator.createObjectAdapter("TestAdapter");
 102         Ice.ObjectAdapter adapter2 = communicator.createObjectAdapter("ControllerAdapter");
 103
 104         BackgroundControllerI backgroundController = new BackgroundControllerI(adapter);
 105
 106         adapter.add(new BackgroundI(backgroundController), communicator.stringToIdentity("background"));
 107         adapter.add(new LocatorI(backgroundController), communicator.stringToIdentity("locator"));
 108         adapter.add(new RouterI(backgroundController), communicator.stringToIdentity("router"));
 109         adapter.activate();
 110
 111         adapter2.add(backgroundController, communicator.stringToIdentity("backgroundController"));
 112         adapter2.activate();
 113
 114         communicator.waitForShutdown();
 115         return 0;
 116     }
 117
 118     public static int Main(string[] args)
 119     {
 120         int status = 0;
 121         Ice.Communicator communicator = null;
 122
 123 #if !COMPACT
 124         Debug.Listeners.Add(new ConsoleTraceListener());
 125 #endif
 126
 127         try
 128         {
 129             Ice.InitializationData initData = new Ice.InitializationData();
 130             initData.properties = Ice.Util.createProperties(ref args);
 131
 132             //
 133             // This test kills connections, so we don't want warnings.
 134             //
 135             initData.properties.setProperty("Ice.Warn.Connections", "0");
 136
 137             //
 138             // Setup the test transport plug-in.
 139             //
 140             string defaultProtocol = initData.properties.getPropertyWithDefault("Ice.Default.Protocol", "tcp");
 141             initData.properties.setProperty("Ice.Default.Protocol", "test-" + defaultProtocol);
 142
 143             communicator = Ice.Util.initialize(ref args, initData);
 144             PluginI plugin = new PluginI(communicator);
 145             plugin.initialize();
 146             communicator.getPluginManager().addPlugin("Test", plugin);
 147
 148             status = run(args, communicator, Console.Out);
 149         }
 150         catch(System.Exception ex)
 151         {
 152             Console.Error.WriteLine(ex);
 153             status = 1;
 154         }
 155
 156         if(communicator != null)
 157         {
 158             try
 159             {
 160                 communicator.destroy();
 161             }
 162             catch(Ice.LocalException ex)
 163             {
 164                 Console.Error.WriteLine(ex);
 165                 status = 1;
 166             }
 167         }
 168
 169         return status;
 170     }
 171 }