CollocatedRequestHandler(Reference @ref, Ice.ObjectAdapter adapter)
{
_reference = @ref;
_adapter = adapter;
_logger = _reference.GetCommunicator().Logger; // Cached for better performance.
_traceLevels = _reference.GetCommunicator().TraceLevels; // Cached for better performance.
_requestId = 0;
}
public void start(string name, Communicator communicator, string[] args)
{
var config = Config.IceAdapterConfig.Config;
Console.WriteLine($"IceServer.endpoints = \"{config.endpoints}\"");
adapter = communicator.createObjectAdapterWithEndpoints(name, config.endpoints);
AddService(ref adapter);
adapter.activate();
}
///<summary>
/// Constructor
/// </summary>
/// <param name="factory">A BoxModuleFactoryPrx</param>
/// <param name="propertyClassIceId">A string</param>
/// <param name="propertyFunctionsIceIds">A string[]</param>
/// <param name="identifier">A string</param>
public PropertyBoxModuleI(BoxModuleFactoryPrx factory, string propertyClassIceId, string[] propertyFunctionsIceIds, Ice.ObjectAdapter adapter, Ice.Identity myIdentity, Modules.PropertyBoxModuleFactoryCreatorI.ValueFromPrx valueFromPrx, PropertyValue defaultValue)
{
this.factory = factory;
this.propertyClassIceId = propertyClassIceId;
this.propertyFunctionsIceIds = propertyFunctionsIceIds;
this.myProxy = BoxModulePrxHelper.uncheckedCast(adapter.add(this,myIdentity));
this.adapter = adapter;
this.valueFromPrx = valueFromPrx;
this.defaultValue = defaultValue;
this.setProperty("value",defaultValue);
}
public void AttachCollocatedObserver(Ice.ObjectAdapter adapter, int requestId)
{
Ice.Instrumentation.IInvocationObserver?observer = GetObserver();
if (observer != null)
{
int size = Os !.Size - Protocol.headerSize - 4;
ChildObserver = observer.GetCollocatedObserver(adapter, requestId, size);
if (ChildObserver != null)
{
ChildObserver.Attach();
}
}
}
public Ice.Instrumentation.CollocatedObserver getCollocatedObserver(Ice.ObjectAdapter adapter,
int requestId,
int size)
{
Ice.Instrumentation.CollocatedObserver del = null;
if (delegate_ != null)
{
del = delegate_.getCollocatedObserver(adapter, requestId, size);
}
return(getObserver <CollocatedMetrics, CollocatedObserverI,
Ice.Instrumentation.CollocatedObserver>("Collocated",
new CollocatedInvocationHelper(adapter, requestId, size),
del));
}
public async Task Connect(string[] args)
{
await Task.Yield();
communicator = Ice.Util.initialize(ref args);
Ice.Identity id = new Ice.Identity();
var proxy = communicator.stringToProxy("Server:default -h localhost -p 10000");
_server = ServerPrxHelper.checkedCast(proxy);
adapter = communicator.createObjectAdapterWithEndpoints("TreeDiagramClient", "default -p 10008");
adapter.activate();
serverEvent = ServerEventPrxHelper.uncheckedCast(
adapter.addWithUUID(
lib.Provider.serviceProvider.GetRequiredService <lib.IceBridge.ServerEvent>()));
_server.initEvent(uuid, serverEvent);
}
public override int run(string[] args)
{
Ice.ObjectAdapter adapter = communicator().createObjectAdapter("Face");
Ice.Object servant = new MyFace();
adapter.add(servant, communicator().stringToIdentity("myface"));
adapter.activate();
Console.Out.WriteLine("server start...");
var task = CloudAPI.MegviiCloud.Login();
if (task.Result)
{
var taskSatus = CloudAPI.MegviiCloud.GetAccountStatus();
var status = taskSatus.Result;
Console.Out.WriteLine("剩余调用次数:" + status.data.limitation.quota);
Console.Out.WriteLine("cloud compare service start...");
}
communicator().waitForShutdown();
Console.Out.WriteLine("ending...");
return(0);
}
public void RemoveAdapter(Ice.ObjectAdapter adapter)
{
lock (this)
{
if (_destroyed)
{
return;
}
foreach (ICollection <Connection> connectionList in _connections.Values)
{
foreach (Connection connection in connectionList)
{
if (connection.GetAdapter() == adapter)
{
connection.SetAdapter(null);
}
}
}
}
}
public override int run(string[] args)
{
Ice.Communicator ic = null;
try
{
ic = Ice.Util.initialize(ref args);
_registry = new HashRegistryImpl();
_registry.SetCommunicator(ic);
_adapter = ic.createObjectAdapterWithEndpoints("HashRegistry", args[0]);
_adapter.add(_registry, ic.stringToIdentity("HashRegistry"));
_adapter.activate();
Console.WriteLine("Wystartowalen HashRegistry");
ic.waitForShutdown();
if (interrupted())
Console.WriteLine ("Koniec");
} catch (System.Exception ex) {
Console.WriteLine(ex);
}
return 0;
}
public override void run(string[] args)
{
var properties = createTestProperties(ref args);
//
// This test kills connections, so we don't want warnings.
//
properties["Ice.Warn.Connections"] = "0";
properties["Ice.MessageSizeMax"] = "50000";
// This test relies on filling the TCP send/recv buffer, so
// we rely on a fixed value for these buffers.
properties["Ice.TCP.RcvSize"] = "50000";
//
// Setup the test transport plug-in.
//
string?protocol;
if (!properties.TryGetValue("Ice.Default.Protocol", out protocol))
{
protocol = "tcp";
}
properties["Ice.Default.Protocol"] = $"test-{protocol}";
using (var communicator = initialize(properties))
{
PluginI plugin = new PluginI(communicator);
plugin.initialize();
communicator.AddPlugin("Test", plugin);
//
// When running as a MIDlet the properties for the server may be
// overridden by configuration. If it isn't then we assume
// defaults.
//
if (communicator.GetProperty("TestAdapter.Endpoints") == null)
{
communicator.SetProperty("TestAdapter.Endpoints", getTestEndpoint(0));
}
if (communicator.GetProperty("ControllerAdapter.Endpoints") == null)
{
communicator.SetProperty("ControllerAdapter.Endpoints", getTestEndpoint(1, "tcp"));
communicator.SetProperty("ControllerAdapter.ThreadPool.Size", "1");
}
Ice.ObjectAdapter adapter = communicator.createObjectAdapter("TestAdapter");
Ice.ObjectAdapter adapter2 = communicator.createObjectAdapter("ControllerAdapter");
BackgroundControllerI backgroundController = new BackgroundControllerI(adapter);
BackgroundI backgroundI = new BackgroundI(backgroundController);
adapter.Add(backgroundI, "background");
LocatorI locatorI = new LocatorI(backgroundController);
adapter.Add(locatorI, "locator");
RouterI routerI = new RouterI(backgroundController);
adapter.Add(routerI, "router");
adapter.Activate();
adapter2.Add(backgroundController, "backgroundController");
adapter2.Activate();
communicator.waitForShutdown();
}
}
public static TestIntfPrx allTests(Test.TestHelper helper, bool collocated)
{
Ice.Communicator communicator = helper.communicator();
var output = helper.getWriter();
output.Write("testing stringToProxy... ");
output.Flush();
string @ref = "Test:" + helper.getTestEndpoint(0) + " -t 2000";
var @base = IObjectPrx.Parse(@ref, communicator);
test(@base != null);
output.WriteLine("ok");
output.Write("testing checked cast... ");
output.Flush();
TestIntfPrx testPrx = TestIntfPrx.CheckedCast(@base);
test(testPrx != null);
test(testPrx.Equals(@base));
output.WriteLine("ok");
output.Write("base... ");
output.Flush();
{
try
{
testPrx.baseAsBase();
test(false);
}
catch (Base b)
{
test(b.b.Equals("Base.b"));
test(b.GetType().FullName.Equals("Test.Base"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("base (AMI)... ");
output.Flush();
{
try
{
testPrx.baseAsBaseAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (Base b)
{
test(b.b.Equals("Base.b"));
test(b.GetType().Name.Equals("Base"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of unknown derived... ");
output.Flush();
{
try
{
testPrx.unknownDerivedAsBase();
test(false);
}
catch (Base b)
{
test(b.b.Equals("UnknownDerived.b"));
test(b.GetType().FullName.Equals("Test.Base"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("slicing of unknown derived (AMI)... ");
output.Flush();
{
try
{
testPrx.unknownDerivedAsBaseAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (Base b)
{
test(b.b.Equals("UnknownDerived.b"));
test(b.GetType().Name.Equals("Base"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("non-slicing of known derived as base... ");
output.Flush();
{
try
{
testPrx.knownDerivedAsBase();
test(false);
}
catch (KnownDerived k)
{
test(k.b.Equals("KnownDerived.b"));
test(k.kd.Equals("KnownDerived.kd"));
test(k.GetType().FullName.Equals("Test.KnownDerived"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("non-slicing of known derived as base (AMI)... ");
output.Flush();
{
try
{
testPrx.knownDerivedAsBaseAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (KnownDerived k)
{
test(k.b.Equals("KnownDerived.b"));
test(k.kd.Equals("KnownDerived.kd"));
test(k.GetType().Name.Equals("KnownDerived"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("non-slicing of known derived as derived... ");
output.Flush();
{
try
{
testPrx.knownDerivedAsKnownDerived();
test(false);
}
catch (KnownDerived k)
{
test(k.b.Equals("KnownDerived.b"));
test(k.kd.Equals("KnownDerived.kd"));
test(k.GetType().FullName.Equals("Test.KnownDerived"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("non-slicing of known derived as derived (AMI)... ");
output.Flush();
{
try
{
testPrx.knownDerivedAsKnownDerivedAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (KnownDerived k)
{
test(k.b.Equals("KnownDerived.b"));
test(k.kd.Equals("KnownDerived.kd"));
test(k.GetType().Name.Equals("KnownDerived"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of unknown intermediate as base... ");
output.Flush();
{
try
{
testPrx.unknownIntermediateAsBase();
test(false);
}
catch (Base b)
{
test(b.b.Equals("UnknownIntermediate.b"));
test(b.GetType().FullName.Equals("Test.Base"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("slicing of unknown intermediate as base (AMI)... ");
output.Flush();
{
try
{
testPrx.unknownIntermediateAsBaseAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (Base b)
{
test(b.b.Equals("UnknownIntermediate.b"));
test(b.GetType().Name.Equals("Base"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of known intermediate as base... ");
output.Flush();
{
try
{
testPrx.knownIntermediateAsBase();
test(false);
}
catch (KnownIntermediate ki)
{
test(ki.b.Equals("KnownIntermediate.b"));
test(ki.ki.Equals("KnownIntermediate.ki"));
test(ki.GetType().FullName.Equals("Test.KnownIntermediate"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("slicing of known intermediate as base (AMI)... ");
output.Flush();
{
try
{
testPrx.knownIntermediateAsBaseAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (KnownIntermediate ki)
{
test(ki.b.Equals("KnownIntermediate.b"));
test(ki.ki.Equals("KnownIntermediate.ki"));
test(ki.GetType().Name.Equals("KnownIntermediate"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of known most derived as base... ");
output.Flush();
{
try
{
testPrx.knownMostDerivedAsBase();
test(false);
}
catch (KnownMostDerived kmd)
{
test(kmd.b.Equals("KnownMostDerived.b"));
test(kmd.ki.Equals("KnownMostDerived.ki"));
test(kmd.kmd.Equals("KnownMostDerived.kmd"));
test(kmd.GetType().FullName.Equals("Test.KnownMostDerived"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("slicing of known most derived as base (AMI)... ");
output.Flush();
{
try
{
testPrx.knownMostDerivedAsBaseAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (KnownMostDerived kmd)
{
test(kmd.b.Equals("KnownMostDerived.b"));
test(kmd.ki.Equals("KnownMostDerived.ki"));
test(kmd.kmd.Equals("KnownMostDerived.kmd"));
test(kmd.GetType().Name.Equals("KnownMostDerived"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("non-slicing of known intermediate as intermediate... ");
output.Flush();
{
try
{
testPrx.knownIntermediateAsKnownIntermediate();
test(false);
}
catch (KnownIntermediate ki)
{
test(ki.b.Equals("KnownIntermediate.b"));
test(ki.ki.Equals("KnownIntermediate.ki"));
test(ki.GetType().FullName.Equals("Test.KnownIntermediate"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("non-slicing of known intermediate as intermediate (AMI)... ");
output.Flush();
{
try
{
testPrx.knownIntermediateAsKnownIntermediateAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (KnownIntermediate ki)
{
test(ki.b.Equals("KnownIntermediate.b"));
test(ki.ki.Equals("KnownIntermediate.ki"));
test(ki.GetType().Name.Equals("KnownIntermediate"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("non-slicing of known most derived as intermediate... ");
output.Flush();
{
try
{
testPrx.knownMostDerivedAsKnownIntermediate();
test(false);
}
catch (KnownMostDerived kmd)
{
test(kmd.b.Equals("KnownMostDerived.b"));
test(kmd.ki.Equals("KnownMostDerived.ki"));
test(kmd.kmd.Equals("KnownMostDerived.kmd"));
test(kmd.GetType().FullName.Equals("Test.KnownMostDerived"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("non-slicing of known most derived as intermediate (AMI)... ");
output.Flush();
{
try
{
testPrx.knownMostDerivedAsKnownIntermediateAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (KnownMostDerived kmd)
{
test(kmd.b.Equals("KnownMostDerived.b"));
test(kmd.ki.Equals("KnownMostDerived.ki"));
test(kmd.kmd.Equals("KnownMostDerived.kmd"));
test(kmd.GetType().Name.Equals("KnownMostDerived"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("non-slicing of known most derived as most derived... ");
output.Flush();
{
try
{
testPrx.knownMostDerivedAsKnownMostDerived();
test(false);
}
catch (KnownMostDerived kmd)
{
test(kmd.b.Equals("KnownMostDerived.b"));
test(kmd.ki.Equals("KnownMostDerived.ki"));
test(kmd.kmd.Equals("KnownMostDerived.kmd"));
test(kmd.GetType().FullName.Equals("Test.KnownMostDerived"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("non-slicing of known most derived as most derived (AMI)... ");
output.Flush();
{
try
{
testPrx.knownMostDerivedAsKnownMostDerivedAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (KnownMostDerived kmd)
{
test(kmd.b.Equals("KnownMostDerived.b"));
test(kmd.ki.Equals("KnownMostDerived.ki"));
test(kmd.kmd.Equals("KnownMostDerived.kmd"));
test(kmd.GetType().Name.Equals("KnownMostDerived"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of unknown most derived, known intermediate as base... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived1AsBase();
test(false);
}
catch (KnownIntermediate ki)
{
test(ki.b.Equals("UnknownMostDerived1.b"));
test(ki.ki.Equals("UnknownMostDerived1.ki"));
test(ki.GetType().FullName.Equals("Test.KnownIntermediate"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("slicing of unknown most derived, known intermediate as base (AMI)... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived1AsBaseAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (KnownIntermediate ki)
{
test(ki.b.Equals("UnknownMostDerived1.b"));
test(ki.ki.Equals("UnknownMostDerived1.ki"));
test(ki.GetType().Name.Equals("KnownIntermediate"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of unknown most derived, known intermediate as intermediate... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived1AsKnownIntermediate();
test(false);
}
catch (KnownIntermediate ki)
{
test(ki.b.Equals("UnknownMostDerived1.b"));
test(ki.ki.Equals("UnknownMostDerived1.ki"));
test(ki.GetType().FullName.Equals("Test.KnownIntermediate"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("slicing of unknown most derived, known intermediate as intermediate (AMI)... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived1AsKnownIntermediateAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (KnownIntermediate ki)
{
test(ki.b.Equals("UnknownMostDerived1.b"));
test(ki.ki.Equals("UnknownMostDerived1.ki"));
test(ki.GetType().Name.Equals("KnownIntermediate"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("slicing of unknown most derived, unknown intermediate thrown as base... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived2AsBase();
test(false);
}
catch (Base b)
{
test(b.b.Equals("UnknownMostDerived2.b"));
test(b.GetType().FullName.Equals("Test.Base"));
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("slicing of unknown most derived, unknown intermediate thrown as base (AMI)... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived2AsBaseAsync().Wait();
test(false);
}
catch (AggregateException ae)
{
try
{
throw ae.InnerException;
}
catch (Base b)
{
test(b.b.Equals("UnknownMostDerived2.b"));
test(b.GetType().Name.Equals("Base"));
}
catch (System.Exception)
{
test(false);
}
}
}
output.WriteLine("ok");
output.Write("unknown most derived in compact format... ");
output.Flush();
{
try
{
testPrx.unknownMostDerived2AsBaseCompact();
test(false);
}
catch (Base)
{
//
// For the 1.0 encoding, the unknown exception is sliced to Base.
//
test(testPrx.EncodingVersion.Equals(Ice.Util.Encoding_1_0));
}
catch (Ice.UnknownUserException)
{
//
// A MarshalException is raised for the compact format because the
// most-derived type is unknown and the exception cannot be sliced.
//
test(!testPrx.EncodingVersion.Equals(Ice.Util.Encoding_1_0));
}
catch (Ice.OperationNotExistException)
{
}
catch (System.Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("preserved exceptions... ");
output.Flush();
{
try
{
testPrx.unknownPreservedAsBase();
test(false);
}
catch (Base ex)
{
if (testPrx.EncodingVersion.Equals(Ice.Util.Encoding_1_0))
{
test(ex.ice_getSlicedData() == null);
}
else
{
Ice.SlicedData slicedData = ex.ice_getSlicedData();
test(slicedData != null);
test(slicedData.slices.Length == 2);
test(slicedData.slices[1].typeId.Equals("::Test::SPreserved1"));
test(slicedData.slices[0].typeId.Equals("::Test::SPreserved2"));
}
}
try
{
testPrx.unknownPreservedAsKnownPreserved();
test(false);
}
catch (KnownPreserved ex)
{
test(ex.kp.Equals("preserved"));
if (testPrx.EncodingVersion.Equals(Ice.Util.Encoding_1_0))
{
test(ex.ice_getSlicedData() == null);
}
else
{
Ice.SlicedData slicedData = ex.ice_getSlicedData();
test(slicedData != null);
test(slicedData.slices.Length == 2);
test(slicedData.slices[1].typeId.Equals("::Test::SPreserved1"));
test(slicedData.slices[0].typeId.Equals("::Test::SPreserved2"));
}
}
Ice.ObjectAdapter adapter = communicator.createObjectAdapter("");
RelayPrx relay = adapter.Add(new RelayI());
adapter.Activate();
testPrx.GetConnection().setAdapter(adapter);
try
{
testPrx.relayKnownPreservedAsBase(relay);
test(false);
}
catch (KnownPreservedDerived ex)
{
test(ex.b.Equals("base"));
test(ex.kp.Equals("preserved"));
test(ex.kpd.Equals("derived"));
}
catch (Ice.OperationNotExistException)
{
}
catch (System.Exception)
{
test(false);
}
try
{
testPrx.relayKnownPreservedAsKnownPreserved(relay);
test(false);
}
catch (KnownPreservedDerived ex)
{
test(ex.b.Equals("base"));
test(ex.kp.Equals("preserved"));
test(ex.kpd.Equals("derived"));
}
catch (Ice.OperationNotExistException)
{
}
catch (System.Exception)
{
test(false);
}
try
{
testPrx.relayUnknownPreservedAsBase(relay);
test(false);
}
catch (Preserved2 ex)
{
test(ex.b.Equals("base"));
test(ex.kp.Equals("preserved"));
test(ex.kpd.Equals("derived"));
test(ex.p1.ice_id().Equals(PreservedClass.ice_staticId()));
PreservedClass pc = ex.p1 as PreservedClass;
test(pc.bc.Equals("bc"));
test(pc.pc.Equals("pc"));
test(ex.p2 == ex.p1);
}
catch (KnownPreservedDerived ex)
{
//
// For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
//
test(testPrx.EncodingVersion.Equals(Ice.Util.Encoding_1_0));
test(ex.b.Equals("base"));
test(ex.kp.Equals("preserved"));
test(ex.kpd.Equals("derived"));
}
catch (Ice.OperationNotExistException)
{
}
catch (System.Exception)
{
test(false);
}
try
{
testPrx.relayUnknownPreservedAsKnownPreserved(relay);
test(false);
}
catch (Preserved2 ex)
{
test(ex.b.Equals("base"));
test(ex.kp.Equals("preserved"));
test(ex.kpd.Equals("derived"));
test(ex.p1.ice_id().Equals(PreservedClass.ice_staticId()));
PreservedClass pc = ex.p1 as PreservedClass;
test(pc.bc.Equals("bc"));
test(pc.pc.Equals("pc"));
test(ex.p2 == ex.p1);
}
catch (KnownPreservedDerived ex)
{
//
// For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
//
test(testPrx.EncodingVersion.Equals(Ice.Util.Encoding_1_0));
test(ex.b.Equals("base"));
test(ex.kp.Equals("preserved"));
test(ex.kpd.Equals("derived"));
}
catch (Ice.OperationNotExistException)
{
}
catch (System.Exception)
{
test(false);
}
adapter.Destroy();
}
output.WriteLine("ok");
return(testPrx);
}
public static void allTests(TestHelper helper)
{
Communicator communicator = helper.communicator();
Console.Out.Write("testing stringToProxy... ");
Console.Out.Flush();
string rf = "test @ TestAdapter";
var @base = IObjectPrx.Parse(rf, communicator);
Console.Out.WriteLine("ok");
Console.Out.Write("testing IceGrid.Locator is present... ");
IceGrid.ILocatorPrx locator = IceGrid.ILocatorPrx.UncheckedCast(@base);
Console.Out.WriteLine("ok");
Console.Out.Write("testing checked cast... ");
Console.Out.Flush();
ITestIntfPrx obj = ITestIntfPrx.CheckedCast(@base);
test(obj.Equals(@base));
Console.Out.WriteLine("ok");
Console.Out.Write("pinging server... ");
Console.Out.Flush();
obj.IcePing();
Console.Out.WriteLine("ok");
Console.Out.Write("testing locator finder... ");
Identity finderId = new Identity("LocatorFinder", "Ice");
ILocatorFinderPrx finder = ILocatorFinderPrx.CheckedCast(communicator.GetDefaultLocator().Clone(finderId));
test(finder.GetLocator() != null);
Console.Out.WriteLine("ok");
Console.Out.Write("testing discovery... ");
{
// Add test well-known object
IceGrid.IRegistryPrx registry = IceGrid.IRegistryPrx.Parse(
communicator.GetDefaultLocator().Identity.Category + "/Registry", communicator);
IceGrid.IAdminSessionPrx session = registry.CreateAdminSession("foo", "bar");
session.GetAdmin().AddObjectWithType(@base, "::Test");
session.Destroy();
//
// Ensure the IceGrid discovery locator can discover the
// registries and make sure locator requests are forwarded.
//
var properties = communicator.GetProperties();
properties.Remove("Ice.Default.Locator");
properties["Ice.Plugin.IceLocatorDiscovery"] = "IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory";
properties["IceLocatorDiscovery.Port"] = helper.getTestPort(99).ToString();
properties["AdapterForDiscoveryTest.AdapterId"] = "discoveryAdapter";
properties["AdapterForDiscoveryTest.Endpoints"] = "default";
Communicator com = new Communicator(properties);
test(com.GetDefaultLocator() != null);
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
IObjectPrx.Parse("test", com).IcePing();
test(com.GetDefaultLocator().GetRegistry() != null);
test(IceGrid.ILocatorPrx.UncheckedCast(com.GetDefaultLocator()).GetLocalRegistry() != null);
test(IceGrid.ILocatorPrx.UncheckedCast(com.GetDefaultLocator()).GetLocalQuery() != null);
Ice.ObjectAdapter adapter = com.CreateObjectAdapter("AdapterForDiscoveryTest");
adapter.Activate();
adapter.Deactivate();
com.Destroy();
//
// Now, ensure that the IceGrid discovery locator correctly
// handles failure to find a locator.
//
properties["IceLocatorDiscovery.InstanceName"] = "unknown";
properties["IceLocatorDiscovery.RetryCount"] = "1";
properties["IceLocatorDiscovery.Timeout"] = "100";
com = new Communicator(properties);
test(com.GetDefaultLocator() != null);
try
{
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
}
catch (NoEndpointException)
{
}
try
{
IObjectPrx.Parse("test", com).IcePing();
}
catch (NoEndpointException)
{
}
test(com.GetDefaultLocator().GetRegistry() == null);
test(IceGrid.ILocatorPrx.CheckedCast(com.GetDefaultLocator()) == null);
try
{
IceGrid.ILocatorPrx.UncheckedCast(com.GetDefaultLocator()).GetLocalRegistry();
}
catch (Ice.OperationNotExistException)
{
}
adapter = com.CreateObjectAdapter("AdapterForDiscoveryTest");
adapter.Activate();
adapter.Deactivate();
com.Destroy();
string multicast;
if (communicator.GetProperty("Ice.IPv6") == "1")
{
multicast = "\"ff15::1\"";
}
else
{
multicast = "239.255.0.1";
}
//
// Test invalid lookup endpoints
//
properties = communicator.GetProperties();
properties.Remove("Ice.Default.Locator");
properties["Ice.Plugin.IceLocatorDiscovery"] = "IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory";
properties["IceLocatorDiscovery.Lookup"] = $"udp -h {multicast} --interface unknown";
com = new Communicator(properties);
test(com.GetDefaultLocator() != null);
try
{
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
test(false);
}
catch (NoEndpointException)
{
}
com.Destroy();
properties = communicator.GetProperties();
properties.Remove("Ice.Default.Locator");
properties["IceLocatorDiscovery.RetryCount"] = "0";
properties["Ice.Plugin.IceLocatorDiscovery"] = "IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory";
properties["IceLocatorDiscovery.Lookup"] = $"udp -h {multicast} --interface unknown";
com = new Communicator(properties);
test(com.GetDefaultLocator() != null);
try
{
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
test(false);
}
catch (NoEndpointException)
{
}
com.Destroy();
properties = communicator.GetProperties();
properties.Remove("Ice.Default.Locator");
properties["IceLocatorDiscovery.RetryCount"] = "1";
properties["Ice.Plugin.IceLocatorDiscovery"] = "IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory";
{
string intf = communicator.GetProperty("IceLocatorDiscovery.Interface") ?? "";
if (intf != "")
{
intf = $" --interface \"{intf}\"";
}
string port = helper.getTestPort(99).ToString();
properties["IceLocatorDiscovery.Lookup"] =
$"udp -h {multicast} --interface unknown:udp -h {multicast} -p {port}{intf}";
}
com = new Communicator(properties);
test(com.GetDefaultLocator() != null);
try
{
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
}
catch (NoEndpointException)
{
test(false);
}
com.Destroy();
}
Console.Out.WriteLine("ok");
Console.Out.Write("shutting down server... ");
Console.Out.Flush();
obj.shutdown();
Console.Out.WriteLine("ok");
}
public override int run(string []args)
{
HashModuleImpl srvHashModule = new HashModuleImpl();
try
{
string endpoint = args[0];
Ice.Communicator ic = Ice.Util.initialize(ref args);
if (args.Length > 0)
{
Console.WriteLine("service id: " + endpoint);
//srvHashModule.ID = Int32.Parse(args[0]);
}
/*
Client cln = new Client(ic);
_clientThread = new Thread(new ThreadStart(cln.Run));
_clientThread.Start();
*/
//polacz sie z registry
//TODO: zweryfikować nazwę registry
Ice.ObjectPrx obj = ic.stringToProxy (@"HashRegistry: tcp -h localhost -p 1231");
Console.WriteLine("Registry proxy created");
if (obj == null)
{
Console.WriteLine("Created proxy is null");
return -1;
}
HashRegisterPrx registryModule = HashRegisterPrxHelper.checkedCast(obj.ice_twoway());
if(registryModule == null)
{
Console.WriteLine("Invalid proxy");
return -2;
}
//poproś o nadanie nazwy od naszego rejestru
_hashNodeId = registryModule.getHashId(endpoint);
srvHashModule.ID = _hashNodeId;
//zarejestruj usługę w registry o otrzymanej nazwie:
//_adapter.add(srvHashModule, Ice.Util.stringToIdentity(_myName));
_adapter = ic.createObjectAdapterWithEndpoints("IceHash", endpoint);
_adapter.add(srvHashModule, ic.stringToIdentity("IceHash"));
_adapter.activate();
Console.WriteLine("Wystartowalem serwer " + _hashNodeId);
HashPrx local = HashPrxHelper.uncheckedCast(ic.stringToProxy(@"IceHash:" + endpoint));
srvHashModule.SetOwnProxy(local);
//sleep
//Thread.Sleep(5 * 1000);
//poproś o ileś nazw innych węzłów żeby pobrać dane
int count = registryModule.getIceHashNodesCount();
NodeInfo[] nodesInfo = registryModule.getIceHashNodesInfo(_hashNodeId, (int)((double)count * 0.5));
Ice.ObjectPrx hashObj;
if (nodesInfo.Length > 0)
{
foreach(NodeInfo node in nodesInfo)
{
hashObj = ic.stringToProxy (@"IceHash:" + node.endpoint);
if (hashObj == null)
{
Console.WriteLine("IceHash proxy with endpoint {0} is null", node.endpoint);
return -1;
}
HashPrx hashModule = HashPrxHelper.checkedCast(hashObj.ice_twoway());
if(hashModule == null)
{
Console.WriteLine("Invalid proxy");
return -2;
}
Console.WriteLine("Utworzono proxy do IceHash:{0}", node.endpoint);
if (node.type == NodeType.Predecessor)
{
srvHashModule.SetPredecessor(hashModule);
HashPrx predecessor = srvHashModule.GetPredecessor();
RegisterResponse response = predecessor.SrvRegister(_hashNodeId, local);
srvHashModule.SetValues(response.values);
srvHashModule.SetRange(response.keysRange);
Console.WriteLine("Ustawiam lokalny range ({0}, {1})",
response.keysRange.startRange, response.keysRange.endRange);
srvHashModule.AddDirectNeighbors(node.id, hashModule);
}
else if (node.id != _hashNodeId)
{
Console.WriteLine("Dodaje hashProxy dla node {0}", node.id);
srvHashModule.AddDirectNeighbors(node.id, hashModule);
}
}
}
else
{
//pierwszy wezel
}
if (srvHashModule.SrvGetRange().endRange == Int32.MaxValue)
{
try
{
HashPrx prx = srvHashModule.SrvLookup(0);
if (prx == null)
Console.WriteLine("Lookup zwrocil null'a");
int nodeId = prx.SrvGetNodeId();
if (nodeId != _hashNodeId)
srvHashModule.AddDirectNeighbors(prx.SrvGetNodeId(), prx);
} catch (System.Exception) {
Console.WriteLine("Nie udalo sie dodac wezla 0");
}
}
srvHashModule.SetInitialized(true);
ic.waitForShutdown();
} catch (System.Exception ex) {
Console.WriteLine(ex);
}
return 0;
}
public static void allTests(Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
Console.Out.Write("testing stringToProxy... ");
Console.Out.Flush();
string rf = "test @ TestAdapter";
var @base = IObjectPrx.Parse(rf, communicator);
Console.Out.WriteLine("ok");
Console.Out.Write("testing IceGrid.Locator is present... ");
IceGrid.LocatorPrx locator = IceGrid.LocatorPrx.UncheckedCast(@base);
Console.Out.WriteLine("ok");
Console.Out.Write("testing checked cast... ");
Console.Out.Flush();
TestIntfPrx obj = TestIntfPrx.CheckedCast(@base);
test(obj.Equals(@base));
Console.Out.WriteLine("ok");
Console.Out.Write("pinging server... ");
Console.Out.Flush();
obj.IcePing();
Console.Out.WriteLine("ok");
Console.Out.Write("testing locator finder... ");
Ice.Identity finderId = new Ice.Identity();
finderId.category = "Ice";
finderId.name = "LocatorFinder";
Ice.LocatorFinderPrx finder = Ice.LocatorFinderPrx.CheckedCast(communicator.getDefaultLocator().Clone(finderId));
test(finder.getLocator() != null);
Console.Out.WriteLine("ok");
Console.Out.Write("testing discovery... ");
{
// Add test well-known object
IceGrid.RegistryPrx registry = IceGrid.RegistryPrx.Parse(
communicator.getDefaultLocator().Identity.category + "/Registry", communicator);
IceGrid.AdminSessionPrx session = registry.createAdminSession("foo", "bar");
session.getAdmin().addObjectWithType(@base, "::Test");
session.destroy();
//
// Ensure the IceGrid discovery locator can discover the
// registries and make sure locator requests are forwarded.
//
Ice.InitializationData initData = new Ice.InitializationData();
initData.properties = communicator.Properties.Clone();
initData.properties.setProperty("Ice.Default.Locator", "");
initData.properties.setProperty("Ice.Plugin.IceLocatorDiscovery",
"IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory");
initData.properties.setProperty("IceLocatorDiscovery.Port", helper.getTestPort(99).ToString());
initData.properties.setProperty("AdapterForDiscoveryTest.AdapterId", "discoveryAdapter");
initData.properties.setProperty("AdapterForDiscoveryTest.Endpoints", "default");
Ice.Communicator com = Ice.Util.initialize(initData);
test(com.getDefaultLocator() != null);
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
IObjectPrx.Parse("test", com).IcePing();
test(com.getDefaultLocator().getRegistry() != null);
test(IceGrid.LocatorPrx.UncheckedCast(com.getDefaultLocator()).getLocalRegistry() != null);
test(IceGrid.LocatorPrx.UncheckedCast(com.getDefaultLocator()).getLocalQuery() != null);
Ice.ObjectAdapter adapter = com.createObjectAdapter("AdapterForDiscoveryTest");
adapter.Activate();
adapter.Deactivate();
com.destroy();
//
// Now, ensure that the IceGrid discovery locator correctly
// handles failure to find a locator.
//
initData.properties.setProperty("IceLocatorDiscovery.InstanceName", "unknown");
initData.properties.setProperty("IceLocatorDiscovery.RetryCount", "1");
initData.properties.setProperty("IceLocatorDiscovery.Timeout", "100");
com = Ice.Util.initialize(initData);
test(com.getDefaultLocator() != null);
try
{
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
}
catch (Ice.NoEndpointException)
{
}
try
{
IObjectPrx.Parse("test", com).IcePing();
}
catch (Ice.NoEndpointException)
{
}
test(com.getDefaultLocator().getRegistry() == null);
test(IceGrid.LocatorPrx.CheckedCast(com.getDefaultLocator()) == null);
try
{
IceGrid.LocatorPrx.UncheckedCast(com.getDefaultLocator()).getLocalRegistry();
}
catch (Ice.OperationNotExistException)
{
}
adapter = com.createObjectAdapter("AdapterForDiscoveryTest");
adapter.Activate();
adapter.Deactivate();
com.destroy();
string multicast;
if (communicator.Properties.getProperty("Ice.IPv6").Equals("1"))
{
multicast = "\"ff15::1\"";
}
else
{
multicast = "239.255.0.1";
}
//
// Test invalid lookup endpoints
//
initData.properties = communicator.Properties.Clone();
initData.properties.setProperty("Ice.Default.Locator", "");
initData.properties.setProperty("Ice.Plugin.IceLocatorDiscovery",
"IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory");
initData.properties.setProperty("IceLocatorDiscovery.Lookup",
$"udp -h {multicast} --interface unknown");
com = Ice.Util.initialize(initData);
test(com.getDefaultLocator() != null);
try
{
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
test(false);
}
catch (NoEndpointException)
{
}
com.destroy();
initData.properties = communicator.Properties.Clone();
initData.properties.setProperty("Ice.Default.Locator", "");
initData.properties.setProperty("IceLocatorDiscovery.RetryCount", "0");
initData.properties.setProperty("Ice.Plugin.IceLocatorDiscovery",
"IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory");
initData.properties.setProperty("IceLocatorDiscovery.Lookup",
"udp -h " + multicast + " --interface unknown");
com = Util.initialize(initData);
test(com.getDefaultLocator() != null);
try
{
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
test(false);
}
catch (NoEndpointException)
{
}
com.destroy();
initData.properties = communicator.Properties.Clone();
initData.properties.setProperty("Ice.Default.Locator", "");
initData.properties.setProperty("IceLocatorDiscovery.RetryCount", "1");
initData.properties.setProperty("Ice.Plugin.IceLocatorDiscovery",
"IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory");
{
string intf = initData.properties.getProperty("IceLocatorDiscovery.Interface");
if (!intf.Equals(""))
{
intf = " --interface \"" + intf + "\"";
}
string port = helper.getTestPort(99).ToString();
initData.properties.setProperty("IceLocatorDiscovery.Lookup",
"udp -h " + multicast + " --interface unknown:" +
"udp -h " + multicast + " -p " + port + intf);
}
com = Ice.Util.initialize(initData);
test(com.getDefaultLocator() != null);
try
{
IObjectPrx.Parse("test @ TestAdapter", com).IcePing();
}
catch (NoEndpointException)
{
test(false);
}
com.destroy();
}
Console.Out.WriteLine("ok");
Console.Out.Write("shutting down server... ");
Console.Out.Flush();
obj.shutdown();
Console.Out.WriteLine("ok");
}
private void AddService(ref Ice.ObjectAdapter adapter)
{
var provider = lib.Provider.serviceProvider;
adapter.add(provider.GetRequiredService <lib.IceBridge.Server>(), Ice.Util.stringToIdentity("Server"));
}
public IncomingConnectionFactory(Ice.ObjectAdapter adapter, Endpoint endpoint, Endpoint?publish,
ACMConfig acmConfig)
{
_communicator = adapter.Communicator;
_endpoint = endpoint;
_publishedEndpoint = publish;
_adapter = adapter;
_warn = _communicator.GetPropertyAsBool("Ice.Warn.Connections") ?? false;
_state = State.Uninitialized;
_monitor = new FactoryACMMonitor(_communicator, acmConfig);
if (_communicator.OverrideTimeout != null)
{
_endpoint = _endpoint.NewTimeout(_communicator.OverrideTimeout.Value);
}
if (_communicator.OverrideCompress != null)
{
_endpoint = _endpoint.NewCompressionFlag(_communicator.OverrideCompress.Value);
}
try
{
_transceiver = _endpoint.GetTransceiver();
if (_transceiver != null)
{
if (_communicator.TraceLevels.Network >= 2)
{
_communicator.Logger.Trace(_communicator.TraceLevels.NetworkCat,
$"attempting to bind to {_endpoint.Name} socket\n{_transceiver}");
}
_endpoint = _transceiver.Bind();
var connection = new Connection(_communicator, null, _transceiver, null, _endpoint, _adapter);
connection.StartAndWait();
_connections.Add(connection);
}
else
{
_acceptor = _endpoint.GetAcceptor(_adapter !.Name);
if (_communicator.TraceLevels.Network >= 2)
{
_communicator.Logger.Trace(_communicator.TraceLevels.NetworkCat,
$"attempting to bind to {_endpoint.Name} socket {_acceptor}");
}
_endpoint = _acceptor !.Listen();
if (_communicator.TraceLevels.Network >= 1)
{
_communicator.Logger.Trace(_communicator.TraceLevels.NetworkCat,
$"listening for {_endpoint.Name} connections\n{_acceptor!.ToDetailedString()}");
}
_adapter.ThreadPool.Initialize(this);
}
}
catch (System.Exception)
{
//
// Clean up.
//
try
{
_transceiver?.Close();
_acceptor?.Close();
}
catch (System.Exception)
{
// Ignore
}
_monitor.Destroy();
_connections.Clear();
throw;
}
}