public Ice.ObjectPrx streamToProxy(BasicStream s)
{
Ice.Identity ident = new Ice.Identity();
ident.read__(s);
Reference r = instance_.referenceFactory().create(ident, s);
return referenceToProxy(r);
}
public Proxy (Type rootType,
string url)
: base (rootType)
{
string host;
int port;
string rest;
IceChannelUtils.ParseIceURL (url, out host, out port, out rest);
_url = url;
_identity = new Ice.Identity (rest);
_facetPath = new string[0];
_secure = false;
_typeIds = null;
_realObject = null;
FindChannel();
}
public Reference create(Ice.Identity ident, Ice.InputStream s)
{
//
// Don't read the identity here. Operations calling this
// constructor read the identity, and pass it as a parameter.
//
if (ident.name.Length == 0 && ident.category.Length == 0)
{
return(null);
}
//
// For compatibility with the old FacetPath.
//
string[] facetPath = s.readStringSeq();
string facet;
if (facetPath.Length > 0)
{
if (facetPath.Length > 1)
{
throw new Ice.ProxyUnmarshalException();
}
facet = facetPath[0];
}
else
{
facet = "";
}
int mode = s.readByte();
if (mode < 0 || mode > (int)Reference.Mode.ModeLast)
{
throw new Ice.ProxyUnmarshalException();
}
bool secure = s.readBool();
Ice.ProtocolVersion protocol;
Ice.EncodingVersion encoding;
if (!s.getEncoding().Equals(Ice.Util.Encoding_1_0))
{
protocol = new Ice.ProtocolVersion();
protocol.ice_readMembers(s);
encoding = new Ice.EncodingVersion();
encoding.ice_readMembers(s);
}
else
{
protocol = Ice.Util.Protocol_1_0;
encoding = Ice.Util.Encoding_1_0;
}
EndpointI[] endpoints = null;
string adapterId = "";
int sz = s.readSize();
if (sz > 0)
{
endpoints = new EndpointI[sz];
for (int i = 0; i < sz; i++)
{
endpoints[i] = _instance.endpointFactoryManager().read(s);
}
}
else
{
adapterId = s.readString();
}
return(create(ident, facet, (Reference.Mode)mode, secure, protocol, encoding, endpoints, adapterId, null));
}
public static Test.ThrowerPrx allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
var output = helper.getWriter();
{
output.Write("testing object adapter registration exceptions... ");
Ice.ObjectAdapter first;
try
{
first = communicator.createObjectAdapter("TestAdapter0");
}
catch (Ice.InitializationException)
{
// Expected
}
communicator.getProperties().setProperty("TestAdapter0.Endpoints", "tcp -h *");
first = communicator.createObjectAdapter("TestAdapter0");
try
{
communicator.createObjectAdapter("TestAdapter0");
test(false);
}
catch (Ice.AlreadyRegisteredException)
{
// Expected.
}
try
{
Ice.ObjectAdapter second =
communicator.createObjectAdapterWithEndpoints("TestAdapter0", "ssl -h foo -p 12011");
test(false);
//
// Quell mono error that variable second isn't used.
//
second.deactivate();
}
catch (Ice.AlreadyRegisteredException)
{
// Expected
}
first.deactivate();
output.WriteLine("ok");
}
{
output.Write("testing servant registration exceptions... ");
communicator.getProperties().setProperty("TestAdapter1.Endpoints", "tcp -h *");
Ice.ObjectAdapter adapter = communicator.createObjectAdapter("TestAdapter1");
Ice.Object obj = new EmptyI();
adapter.add(obj, Ice.Util.stringToIdentity("x"));
try
{
adapter.add(obj, Ice.Util.stringToIdentity("x"));
test(false);
}
catch (Ice.AlreadyRegisteredException)
{
}
try
{
adapter.add(obj, Ice.Util.stringToIdentity(""));
test(false);
}
catch (Ice.IllegalIdentityException e)
{
test(e.id.name.Equals(""));
}
try
{
adapter.add(null, Ice.Util.stringToIdentity("x"));
test(false);
}
catch (Ice.IllegalServantException)
{
}
adapter.remove(Ice.Util.stringToIdentity("x"));
try
{
adapter.remove(Ice.Util.stringToIdentity("x"));
test(false);
}
catch (Ice.NotRegisteredException)
{
}
adapter.deactivate();
output.WriteLine("ok");
}
{
output.Write("testing servant locator registration exceptions... ");
communicator.getProperties().setProperty("TestAdapter2.Endpoints", "tcp -h *");
Ice.ObjectAdapter adapter = communicator.createObjectAdapter("TestAdapter2");
Ice.ServantLocator loc = new ServantLocatorI();
adapter.addServantLocator(loc, "x");
try
{
adapter.addServantLocator(loc, "x");
test(false);
}
catch (Ice.AlreadyRegisteredException)
{
}
adapter.deactivate();
output.WriteLine("ok");
}
{
output.Write("testing object factory registration exception... ");
communicator.getValueFactoryManager().add(_ => { return(null); }, "::x");
try
{
communicator.getValueFactoryManager().add(_ => { return(null); }, "::x");
test(false);
}
catch (Ice.AlreadyRegisteredException)
{
}
output.WriteLine("ok");
}
output.Write("testing stringToProxy... ");
output.Flush();
String @ref = "thrower:" + helper.getTestEndpoint(0);
Ice.ObjectPrx @base = communicator.stringToProxy(@ref);
test(@base != null);
output.WriteLine("ok");
output.Write("testing checked cast... ");
output.Flush();
var thrower = Test.ThrowerPrxHelper.checkedCast(@base);
test(thrower != null);
test(thrower.Equals(@base));
output.WriteLine("ok");
output.Write("catching exact types... ");
output.Flush();
try
{
thrower.throwAasA(1);
test(false);
}
catch (Test.A ex)
{
test(ex.aMem == 1);
}
catch (Exception ex)
{
Console.WriteLine(ex);
test(false);
}
try
{
thrower.throwAorDasAorD(1);
test(false);
}
catch (Test.A ex)
{
test(ex.aMem == 1);
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwAorDasAorD(-1);
test(false);
}
catch (Test.D ex)
{
test(ex.dMem == -1);
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwBasB(1, 2);
test(false);
}
catch (Test.B ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwCasC(1, 2, 3);
test(false);
}
catch (Test.C ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("catching base types... ");
output.Flush();
try
{
thrower.throwBasB(1, 2);
test(false);
}
catch (Test.A ex)
{
test(ex.aMem == 1);
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwCasC(1, 2, 3);
test(false);
}
catch (Test.B ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("catching derived types... ");
output.Flush();
try
{
thrower.throwBasA(1, 2);
test(false);
}
catch (Test.B ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwCasA(1, 2, 3);
test(false);
}
catch (Test.C ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwCasB(1, 2, 3);
test(false);
}
catch (Test.C ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
if (thrower.supportsUndeclaredExceptions())
{
output.Write("catching unknown user exception... ");
output.Flush();
try
{
thrower.throwUndeclaredA(1);
test(false);
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwUndeclaredB(1, 2);
test(false);
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwUndeclaredC(1, 2, 3);
test(false);
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
}
if (thrower.ice_getConnection() != null)
{
output.Write("testing memory limit marshal exception...");
output.Flush();
try
{
thrower.throwMemoryLimitException(null);
test(false);
}
catch (Ice.MemoryLimitException)
{
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwMemoryLimitException(new byte[20 * 1024]); // 20KB
test(false);
}
catch (Ice.ConnectionLostException)
{
}
catch (Ice.UnknownLocalException)
{
// Expected with JS bidir server
}
catch (Exception)
{
test(false);
}
try
{
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(
communicator.stringToProxy("thrower:" + helper.getTestEndpoint(1)));
try
{
thrower2.throwMemoryLimitException(new byte[2 * 1024 * 1024]); // 2MB(no limits)
}
catch (Ice.MemoryLimitException)
{
}
var thrower3 = Test.ThrowerPrxHelper.uncheckedCast(
communicator.stringToProxy("thrower:" + helper.getTestEndpoint(2)));
try
{
thrower3.throwMemoryLimitException(new byte[1024]); // 1KB limit
test(false);
}
catch (Ice.ConnectionLostException)
{
}
}
catch (Ice.ConnectionRefusedException)
{
// Expected with JS bidir server
}
output.WriteLine("ok");
}
output.Write("catching object not exist exception... ");
output.Flush();
{
Ice.Identity id = Ice.Util.stringToIdentity("does not exist");
try
{
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(thrower.ice_identity(id));
thrower2.ice_ping();
test(false);
}
catch (Ice.ObjectNotExistException ex)
{
test(ex.id.Equals(id));
}
catch (Exception)
{
test(false);
}
}
output.WriteLine("ok");
output.Write("catching facet not exist exception... ");
output.Flush();
try
{
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(thrower, "no such facet");
try
{
thrower2.ice_ping();
test(false);
}
catch (Ice.FacetNotExistException ex)
{
test(ex.facet.Equals("no such facet"));
}
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("catching operation not exist exception... ");
output.Flush();
try
{
var thrower2 = Test.WrongOperationPrxHelper.uncheckedCast(thrower);
thrower2.noSuchOperation();
test(false);
}
catch (Ice.OperationNotExistException ex)
{
test(ex.operation.Equals("noSuchOperation"));
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("catching unknown local exception... ");
output.Flush();
try
{
thrower.throwLocalException();
test(false);
}
catch (Ice.UnknownLocalException)
{
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwLocalExceptionIdempotent();
test(false);
}
catch (Ice.UnknownLocalException)
{
}
catch (Ice.OperationNotExistException)
{
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("catching unknown non-Ice exception... ");
output.Flush();
try
{
thrower.throwNonIceException();
test(false);
}
catch (Ice.UnknownException)
{
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("testing asynchronous exceptions... ");
output.Flush();
try
{
thrower.throwAfterResponse();
}
catch (Exception)
{
test(false);
}
try
{
thrower.throwAfterException();
test(false);
}
catch (Test.A)
{
}
catch (Exception)
{
test(false);
}
output.WriteLine("ok");
output.Write("catching exact types with AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwAasA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
test(exc is Test.A);
var ex = exc as Test.A;
test(ex.aMem == 1);
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwAorDasAorD(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.A ex)
{
test(ex.aMem == 1);
}
catch (Test.D ex)
{
test(ex.dMem == -1);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwAorDasAorD(-1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.A ex)
{
test(ex.aMem == 1);
}
catch (Test.D ex)
{
test(ex.dMem == -1);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwBasB(1, 2).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.B ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwCasC(1, 2, 3).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.C ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching derived types with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwBasA(1, 2).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.B ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwCasA(1, 2, 3).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.C ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwCasB(1, 2, 3).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Test.C ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
if (thrower.supportsUndeclaredExceptions())
{
output.Write("catching unknown user exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwUndeclaredA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwUndeclaredB(1, 2).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwUndeclaredC(1, 2, 3).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
}
output.Write("catching object not exist exception with new AMI mapping... ");
output.Flush();
{
Ice.Identity id = Ice.Util.stringToIdentity("does not exist");
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(thrower.ice_identity(id));
Callback cb = new Callback();
thrower2.begin_throwAasA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.ObjectNotExistException ex)
{
test(ex.id.Equals(id));
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching facet not exist exception with new AMI mapping... ");
output.Flush();
{
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(thrower, "no such facet");
Callback cb = new Callback();
thrower2.begin_throwAasA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.FacetNotExistException ex)
{
test(ex.facet.Equals("no such facet"));
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching operation not exist exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
var thrower4 = Test.WrongOperationPrxHelper.uncheckedCast(thrower);
thrower4.begin_noSuchOperation().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.OperationNotExistException ex)
{
test(ex.operation.Equals("noSuchOperation"));
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching unknown local exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwLocalException().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownLocalException)
{
}
catch (Ice.OperationNotExistException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwLocalExceptionIdempotent().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownLocalException)
{
}
catch (Ice.OperationNotExistException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching unknown non-Ice exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwNonIceException().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
if (thrower.supportsUndeclaredExceptions())
{
output.Write("catching unknown user exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwUndeclaredA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwUndeclaredB(1, 2).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwUndeclaredC(1, 2, 3).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownUserException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
}
output.Write("catching object not exist exception with new AMI mapping... ");
output.Flush();
{
Ice.Identity id = Ice.Util.stringToIdentity("does not exist");
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(thrower.ice_identity(id));
Callback cb = new Callback();
thrower2.begin_throwAasA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.ObjectNotExistException ex)
{
test(ex.id.Equals(id));
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching facet not exist exception with new AMI mapping... ");
output.Flush();
{
var thrower2 = Test.ThrowerPrxHelper.uncheckedCast(thrower, "no such facet");
Callback cb = new Callback();
thrower2.begin_throwAasA(1).whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.FacetNotExistException ex)
{
test(ex.facet.Equals("no such facet"));
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching operation not exist exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
var thrower4 = Test.WrongOperationPrxHelper.uncheckedCast(thrower);
thrower4.begin_noSuchOperation().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.OperationNotExistException ex)
{
test(ex.operation.Equals("noSuchOperation"));
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching unknown local exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwLocalException().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownLocalException)
{
}
catch (Ice.OperationNotExistException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
{
Callback cb = new Callback();
thrower.begin_throwLocalExceptionIdempotent().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownLocalException)
{
}
catch (Ice.OperationNotExistException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
output.Write("catching unknown non-Ice exception with new AMI mapping... ");
output.Flush();
{
Callback cb = new Callback();
thrower.begin_throwNonIceException().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception exc) =>
{
try
{
throw exc;
}
catch (Ice.UnknownException)
{
}
catch (Exception)
{
test(false);
}
cb.called();
});
cb.check();
}
output.WriteLine("ok");
return(thrower);
}
findObjectByIdAsync(Ice.Identity id, Ice.Current current)
{
return(null);
}
public int run()
{
try
{
Ice.Properties properties = _communicator.getProperties();
//
// Create an object adapter. Services probably should NOT share
// this object adapter, as the endpoint(s) for this object adapter
// will most likely need to be firewalled for security reasons.
//
Ice.ObjectAdapter adapter = null;
if(properties.getProperty("IceBox.ServiceManager.Endpoints").Length != 0)
{
adapter = _communicator.createObjectAdapter("IceBox.ServiceManager");
Ice.Identity identity = new Ice.Identity();
identity.category = properties.getPropertyWithDefault("IceBox.InstanceName", "IceBox");
identity.name = "ServiceManager";
adapter.add(this, identity);
}
//
// Parse the property set with the prefix "IceBox.Service.". These
// properties should have the following format:
//
// IceBox.Service.Foo=Package.Foo [args]
//
// We parse the service properties specified in IceBox.LoadOrder
// first, then the ones from remaining services.
//
string prefix = "IceBox.Service.";
Dictionary<string, string> services = properties.getPropertiesForPrefix(prefix);
string[] loadOrder = properties.getPropertyAsList("IceBox.LoadOrder");
List<StartServiceInfo> servicesInfo = new List<StartServiceInfo>();
for(int i = 0; i < loadOrder.Length; ++i)
{
if(loadOrder[i].Length > 0)
{
string key = prefix + loadOrder[i];
string value = services[key];
if(value == null)
{
FailureException ex = new FailureException();
ex.reason = "ServiceManager: no service definition for `" + loadOrder[i] + "'";
throw ex;
}
servicesInfo.Add(new StartServiceInfo(loadOrder[i], value, _argv));
services.Remove(key);
}
}
foreach(KeyValuePair<string, string> entry in services)
{
string name = entry.Key.Substring(prefix.Length);
string value = entry.Value;
servicesInfo.Add(new StartServiceInfo(name, value, _argv));
}
//
// Check if some services are using the shared communicator in which
// case we create the shared communicator now with a property set which
// is the union of all the service properties (services which are using
// the shared communicator).
//
if(properties.getPropertiesForPrefix("IceBox.UseSharedCommunicator.").Count > 0)
{
Ice.InitializationData initData = new Ice.InitializationData();
initData.properties = createServiceProperties("SharedCommunicator");
foreach(StartServiceInfo service in servicesInfo)
{
if(properties.getPropertyAsInt("IceBox.UseSharedCommunicator." + service.name) <= 0)
{
continue;
}
//
// Load the service properties using the shared communicator properties as
// the default properties.
//
Ice.Properties svcProperties = Ice.Util.createProperties(ref service.args, initData.properties);
//
// Erase properties from the shared communicator which don't exist in the
// service properties (which include the shared communicator properties
// overriden by the service properties).
//
Dictionary<string, string> allProps = initData.properties.getPropertiesForPrefix("");
foreach(string key in allProps.Keys)
{
if(svcProperties.getProperty(key).Length == 0)
{
initData.properties.setProperty(key, "");
}
}
//
// Add the service properties to the shared communicator properties.
//
foreach(KeyValuePair<string, string> entry in svcProperties.getPropertiesForPrefix(""))
{
initData.properties.setProperty(entry.Key, entry.Value);
}
//
// Parse <service>.* command line options (the Ice command line options
// were parsed by the createProperties above)
//
service.args = initData.properties.parseCommandLineOptions(service.name, service.args);
}
_sharedCommunicator = Ice.Util.initialize(initData);
}
foreach(StartServiceInfo s in servicesInfo)
{
startService(s.name, s.entryPoint, s.args);
}
//
// We may want to notify external scripts that the services
// have started. This is done by defining the property:
//
// PrintServicesReady=bundleName
//
// Where bundleName is whatever you choose to call this set of
// services. It will be echoed back as "bundleName ready".
//
// This must be done after start() has been invoked on the
// services.
//
string bundleName = properties.getProperty("IceBox.PrintServicesReady");
if(bundleName.Length > 0)
{
Console.Out.WriteLine(bundleName + " ready");
}
//
// Don't move after the adapter activation. This allows
// applications to wait for the service manager to be
// reachable before sending a signal to shutdown the
//
//
Ice.Application.shutdownOnInterrupt();
//
// Register "this" as a facet to the Admin object and create Admin object
//
try
{
_communicator.addAdminFacet(this, "IceBox.ServiceManager");
//
// Add a Properties facet for each service
//
foreach(ServiceInfo info in _services)
{
Ice.Communicator communicator = info.communicator != null ? info.communicator : _sharedCommunicator;
_communicator.addAdminFacet(new PropertiesAdminI(communicator.getProperties()),
"IceBox.Service." + info.name + ".Properties");
}
_communicator.getAdmin();
}
catch(Ice.ObjectAdapterDeactivatedException)
{
//
// Expected if the communicator has been shutdown.
//
}
//
// Start request dispatching after we've started the services.
//
if(adapter != null)
{
try
{
adapter.activate();
}
catch(Ice.ObjectAdapterDeactivatedException)
{
//
// Expected if the communicator has been shutdown.
//
}
}
_communicator.waitForShutdown();
// XXX:
//Ice.Application.defaultInterrupt();
//
// Invoke stop() on the services.
//
stopAll();
}
catch(FailureException ex)
{
_logger.error(ex.ToString());
stopAll();
return 1;
}
catch(Exception ex)
{
_logger.error("ServiceManager: caught exception:\n" + ex.ToString());
stopAll();
return 1;
}
return 0;
}
initialize()
{
Ice.Properties properties = _communicator.getProperties();
bool ipv4 = properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
bool preferIPv6 = properties.getPropertyAsInt("Ice.PreferIPv6Address") > 0;
string address;
if (ipv4 && !preferIPv6)
{
address = properties.getPropertyWithDefault(_name + ".Address", "239.255.0.1");
}
else
{
address = properties.getPropertyWithDefault(_name + ".Address", "ff15::1");
}
int port = properties.getPropertyAsIntWithDefault(_name + ".Port", 4061);
string intf = properties.getProperty(_name + ".Interface");
string lookupEndpoints = properties.getProperty(_name + ".Lookup");
if (lookupEndpoints.Length == 0)
{
int protocol = ipv4 && !preferIPv6 ? IceInternal.Network.EnableIPv4 : IceInternal.Network.EnableIPv6;
var interfaces = IceInternal.Network.getInterfacesForMulticast(intf, protocol);
foreach (string p in interfaces)
{
if (p != interfaces[0])
{
lookupEndpoints += ":";
}
lookupEndpoints += "udp -h \"" + address + "\" -p " + port + " --interface \"" + p + "\"";
}
}
if (properties.getProperty(_name + ".Reply.Endpoints").Length == 0)
{
properties.setProperty(_name + ".Reply.Endpoints",
"udp -h " + (intf.Length == 0 ? "*" : "\"" + intf + "\""));
}
if (properties.getProperty(_name + ".Locator.Endpoints").Length == 0)
{
properties.setProperty(_name + ".Locator.AdapterId", Guid.NewGuid().ToString());
}
_replyAdapter = _communicator.createObjectAdapter(_name + ".Reply");
_locatorAdapter = _communicator.createObjectAdapter(_name + ".Locator");
// We don't want those adapters to be registered with the locator so clear their locator.
_replyAdapter.setLocator(null);
_locatorAdapter.setLocator(null);
Ice.ObjectPrx lookupPrx = _communicator.stringToProxy("IceLocatorDiscovery/Lookup -d:" + lookupEndpoints);
// No colloc optimization or router for the multicast proxy!
lookupPrx = lookupPrx.ice_collocationOptimized(false).ice_router(null);
Ice.LocatorPrx voidLo = Ice.LocatorPrxHelper.uncheckedCast(_locatorAdapter.addWithUUID(new VoidLocatorI()));
string instanceName = properties.getProperty(_name + ".InstanceName");
Ice.Identity id = new Ice.Identity();
id.name = "Locator";
id.category = instanceName.Length > 0 ? instanceName : Guid.NewGuid().ToString();
_defaultLocator = _communicator.getDefaultLocator();
_locator = new LocatorI(_name, LookupPrxHelper.uncheckedCast(lookupPrx), properties, instanceName, voidLo);
_locatorPrx = Ice.LocatorPrxHelper.uncheckedCast(_locatorAdapter.add(_locator, id));
_communicator.setDefaultLocator(_locatorPrx);
Ice.ObjectPrx lookupReply = _replyAdapter.addWithUUID(new LookupReplyI(_locator)).ice_datagram();
_locator.setLookupReply(LookupReplyPrxHelper.uncheckedCast(lookupReply));
_replyAdapter.activate();
_locatorAdapter.activate();
}
public void activate()
{
IceInternal.LocatorInfo locatorInfo = null;
bool registerProcess = false;
bool printAdapterReady = false;
_m.Lock();
try
{
checkForDeactivation();
//
// If some threads are waiting on waitForHold(), we set this
// flag to ensure the threads will start again the wait for
// all the incoming connection factories.
//
_waitForHoldRetry = _waitForHold > 0;
//
// If the one off initializations of the adapter are already
// done, we just need to activate the incoming connection
// factories and we're done.
//
if(_activateOneOffDone)
{
foreach(IceInternal.IncomingConnectionFactory icf in _incomingConnectionFactories)
{
icf.activate();
}
return;
}
//
// One off initializations of the adapter: update the locator
// registry and print the "adapter ready" message. We set the
// _waitForActivate flag to prevent deactivation from other
// threads while these one off initializations are done.
//
_waitForActivate = true;
locatorInfo = _locatorInfo;
if(!_noConfig)
{
Properties properties = instance_.initializationData().properties;
registerProcess = properties.getPropertyAsInt(_name + ".RegisterProcess") > 0;
printAdapterReady = properties.getPropertyAsInt("Ice.PrintAdapterReady") > 0;
}
}
finally
{
_m.Unlock();
}
try
{
Ice.Identity dummy = new Ice.Identity();
dummy.name = "dummy";
updateLocatorRegistry(locatorInfo, createDirectProxy(dummy), registerProcess);
}
catch(Ice.LocalException)
{
//
// If we couldn't update the locator registry, we let the
// exception go through and don't activate the adapter to
// allow to user code to retry activating the adapter
// later.
//
_m.Lock();
try
{
_waitForActivate = false;
_m.NotifyAll();
}
finally
{
_m.Unlock();
}
throw;
}
if(printAdapterReady)
{
System.Console.Out.WriteLine(_name + " ready");
}
_m.Lock();
try
{
Debug.Assert(!_deactivated); // Not possible if _waitForActivate = true;
//
// Signal threads waiting for the activation.
//
_waitForActivate = false;
_m.NotifyAll();
_activateOneOffDone = true;
foreach(IceInternal.IncomingConnectionFactory icf in _incomingConnectionFactories)
{
icf.activate();
}
}
finally
{
_m.Unlock();
}
}
private static void printIdentityFacetOperation(System.IO.StringWriter s, Ice.InputStream str)
{
try
{
Ice.Identity identity = new Ice.Identity();
identity.read__(str);
s.Write("\nidentity = " + str.instance().identityToString(identity));
string[] facet = str.readStringSeq();
s.Write("\nfacet = ");
if(facet.Length > 0)
{
s.Write(IceUtilInternal.StringUtil.escapeString(facet[0], ""));
}
string operation = str.readString();
s.Write("\noperation = " + operation);
}
catch(System.IO.IOException)
{
Debug.Assert(false);
}
}
allTests(global::Test.TestHelper helper)
{
var output = helper.getWriter();
Ice.Communicator communicator = helper.communicator();
Ice.ObjectAdapter oa = communicator.createObjectAdapterWithEndpoints("MyOA", "tcp -h localhost");
oa.activate();
Ice.Object servant = new MyObjectI();
//
// Register default servant with category "foo"
//
oa.addDefaultServant(servant, "foo");
//
// Start test
//
output.Write("testing single category... ");
output.Flush();
Ice.Object r = oa.findDefaultServant("foo");
test(r == servant);
r = oa.findDefaultServant("bar");
test(r == null);
Ice.Identity identity = new Ice.Identity();
identity.category = "foo";
string[] names = new string[] { "foo", "bar", "x", "y", "abcdefg" };
Test.MyObjectPrx prx = null;
for (int idx = 0; idx < 5; ++idx)
{
identity.name = names[idx];
prx = Test.MyObjectPrxHelper.uncheckedCast(oa.createProxy(identity));
prx.ice_ping();
test(prx.getName() == names[idx]);
}
identity.name = "ObjectNotExist";
prx = Test.MyObjectPrxHelper.uncheckedCast(oa.createProxy(identity));
try
{
prx.ice_ping();
test(false);
}
catch (Ice.ObjectNotExistException)
{
// Expected
}
try
{
prx.getName();
test(false);
}
catch (Ice.ObjectNotExistException)
{
// Expected
}
identity.name = "FacetNotExist";
prx = Test.MyObjectPrxHelper.uncheckedCast(oa.createProxy(identity));
try
{
prx.ice_ping();
test(false);
}
catch (Ice.FacetNotExistException)
{
// Expected
}
try
{
prx.getName();
test(false);
}
catch (Ice.FacetNotExistException)
{
// Expected
}
identity.category = "bar";
for (int idx = 0; idx < 5; idx++)
{
identity.name = names[idx];
prx = Test.MyObjectPrxHelper.uncheckedCast(oa.createProxy(identity));
try
{
prx.ice_ping();
test(false);
}
catch (Ice.ObjectNotExistException)
{
// Expected
}
try
{
prx.getName();
test(false);
}
catch (Ice.ObjectNotExistException)
{
// Expected
}
}
oa.removeDefaultServant("foo");
identity.category = "foo";
prx = Test.MyObjectPrxHelper.uncheckedCast(oa.createProxy(identity));
try
{
prx.ice_ping();
}
catch (Ice.ObjectNotExistException)
{
// Expected
}
output.WriteLine("ok");
output.Write("testing default category... ");
output.Flush();
oa.addDefaultServant(servant, "");
r = oa.findDefaultServant("bar");
test(r == null);
r = oa.findDefaultServant("");
test(r == servant);
for (int idx = 0; idx < 5; ++idx)
{
identity.name = names[idx];
prx = Test.MyObjectPrxHelper.uncheckedCast(oa.createProxy(identity));
prx.ice_ping();
test(prx.getName() == names[idx]);
}
output.WriteLine("ok");
}
public void activate()
{
LocatorInfo locatorInfo = null;
bool printAdapterReady = false;
lock (this)
{
checkForDeactivation();
//
// If we've previously been initialized we just need to activate the
// incoming connection factories and we're done.
//
if (_state != StateUninitialized)
{
foreach (IncomingConnectionFactory icf in _incomingConnectionFactories)
{
icf.activate();
}
return;
}
//
// One off initializations of the adapter: update the
// locator registry and print the "adapter ready"
// message. We set set state to StateActivating to prevent
// deactivation from other threads while these one off
// initializations are done.
//
_state = StateActivating;
locatorInfo = _locatorInfo;
if (!_noConfig)
{
Properties properties = _instance.initializationData().properties;
printAdapterReady = properties.getPropertyAsInt("Ice.PrintAdapterReady") > 0;
}
}
try
{
Ice.Identity dummy = new Ice.Identity();
dummy.name = "dummy";
updateLocatorRegistry(locatorInfo, createDirectProxy(dummy));
}
catch (Ice.LocalException)
{
//
// If we couldn't update the locator registry, we let the
// exception go through and don't activate the adapter to
// allow to user code to retry activating the adapter
// later.
//
lock (this)
{
_state = StateUninitialized;
System.Threading.Monitor.PulseAll(this);
}
throw;
}
if (printAdapterReady)
{
Console.Out.WriteLine(_name + " ready");
}
lock (this)
{
Debug.Assert(_state == StateActivating);
foreach (IncomingConnectionFactory icf in _incomingConnectionFactories)
{
icf.activate();
}
_state = StateActive;
System.Threading.Monitor.PulseAll(this);
}
}
allTests(global::Test.TestHelper helper)
{
var output = helper.getWriter();
Communicator communicator = helper.communicator();
ObjectAdapter oa = communicator.createObjectAdapterWithEndpoints("MyOA", "tcp -h localhost");
oa.Activate();
var servantI = new MyObjectI();
var servantT = default(MyObjectTraits);
Disp servantD = (incoming, current) => servantT.Dispatch(servantI, incoming, current);
//
// Register default servant with category "foo"
//
oa.AddDefaultServant(servantD, "foo");
//
// Start test
//
output.Write("testing single category... ");
output.Flush();
Disp r = oa.FindDefaultServant("foo");
test(r == servantD);
r = oa.FindDefaultServant("bar");
test(r == null);
Ice.Identity identity = new Ice.Identity();
identity.category = "foo";
string[] names = new string[] { "foo", "bar", "x", "y", "abcdefg" };
MyObjectPrx prx = null;
for (int idx = 0; idx < 5; ++idx)
{
identity.name = names[idx];
prx = MyObjectPrx.UncheckedCast(oa.CreateProxy(identity));
prx.IcePing();
test(prx.getName() == names[idx]);
}
identity.name = "ObjectNotExist";
prx = MyObjectPrx.UncheckedCast(oa.CreateProxy(identity));
try
{
prx.IcePing();
test(false);
}
catch (ObjectNotExistException)
{
// Expected
}
try
{
prx.getName();
test(false);
}
catch (ObjectNotExistException)
{
// Expected
}
identity.name = "FacetNotExist";
prx = MyObjectPrx.UncheckedCast(oa.CreateProxy(identity));
try
{
prx.IcePing();
test(false);
}
catch (FacetNotExistException)
{
// Expected
}
try
{
prx.getName();
test(false);
}
catch (FacetNotExistException)
{
// Expected
}
identity.category = "bar";
for (int idx = 0; idx < 5; idx++)
{
identity.name = names[idx];
prx = Test.MyObjectPrx.UncheckedCast(oa.CreateProxy(identity));
try
{
prx.IcePing();
test(false);
}
catch (Ice.ObjectNotExistException)
{
// Expected
}
try
{
prx.getName();
test(false);
}
catch (Ice.ObjectNotExistException)
{
// Expected
}
}
oa.RemoveDefaultServant("foo");
identity.category = "foo";
prx = Test.MyObjectPrx.UncheckedCast(oa.CreateProxy(identity));
try
{
prx.IcePing();
}
catch (Ice.ObjectNotExistException)
{
// Expected
}
output.WriteLine("ok");
output.Write("testing default category... ");
output.Flush();
oa.AddDefaultServant(servantD, "");
r = oa.FindDefaultServant("bar");
test(r == null);
r = oa.FindDefaultServant("");
test(r == servantD);
for (int idx = 0; idx < 5; ++idx)
{
identity.name = names[idx];
prx = Test.MyObjectPrx.UncheckedCast(oa.CreateProxy(identity));
prx.IcePing();
test(prx.getName() == names[idx]);
}
output.WriteLine("ok");
}
public void initialize()
{
Ice.Properties properties = _communicator.getProperties();
bool ipv4 = properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
bool preferIPv6 = properties.getPropertyAsInt("Ice.PreferIPv6Address") > 0;
string address;
if (ipv4 && !preferIPv6)
{
address = properties.getPropertyWithDefault("IceDiscovery.Address", "239.255.0.1");
}
else
{
address = properties.getPropertyWithDefault("IceDiscovery.Address", "ff15::1");
}
int port = properties.getPropertyAsIntWithDefault("IceDiscovery.Port", 4061);
string intf = properties.getProperty("IceDiscovery.Interface");
if (properties.getProperty("IceDiscovery.Multicast.Endpoints").Length == 0)
{
StringBuilder s = new StringBuilder();
s.Append("udp -h \"").Append(address).Append("\" -p ").Append(port);
if (intf.Length != 0)
{
s.Append(" --interface \"").Append(intf).Append("\"");
}
properties.setProperty("IceDiscovery.Multicast.Endpoints", s.ToString());
}
string lookupEndpoints = properties.getProperty("IceDiscovery.Lookup");
if (lookupEndpoints.Length == 0)
{
int protocol = ipv4 && !preferIPv6 ? IceInternal.Network.EnableIPv4 : IceInternal.Network.EnableIPv6;
var interfaces = IceInternal.Network.getInterfacesForMulticast(intf, protocol);
foreach (string p in interfaces)
{
if (p != interfaces[0])
{
lookupEndpoints += ":";
}
lookupEndpoints += "udp -h \"" + address + "\" -p " + port + " --interface \"" + p + "\"";
}
}
if (properties.getProperty("IceDiscovery.Reply.Endpoints").Length == 0)
{
properties.setProperty("IceDiscovery.Reply.Endpoints",
"udp -h " + (intf.Length == 0 ? "*" : "\"" + intf + "\""));
}
if (properties.getProperty("IceDiscovery.Locator.Endpoints").Length == 0)
{
properties.setProperty("IceDiscovery.Locator.AdapterId", Guid.NewGuid().ToString());
}
_multicastAdapter = _communicator.createObjectAdapter("IceDiscovery.Multicast");
_replyAdapter = _communicator.createObjectAdapter("IceDiscovery.Reply");
_locatorAdapter = _communicator.createObjectAdapter("IceDiscovery.Locator");
//
// Setup locatory registry.
//
LocatorRegistryI locatorRegistry = new LocatorRegistryI(_communicator);
Ice.LocatorRegistryPrx locatorRegistryPrx = Ice.LocatorRegistryPrxHelper.uncheckedCast(
_locatorAdapter.addWithUUID(locatorRegistry));
Ice.ObjectPrx lookupPrx = _communicator.stringToProxy("IceDiscovery/Lookup -d:" + lookupEndpoints);
// No colloc optimization or router for the multicast proxy!
lookupPrx = lookupPrx.ice_collocationOptimized(false).ice_router(null);
//
// Add lookup and lookup reply Ice objects
//
LookupI lookup = new LookupI(locatorRegistry, LookupPrxHelper.uncheckedCast(lookupPrx), properties);
_multicastAdapter.add(lookup, Ice.Util.stringToIdentity("IceDiscovery/Lookup"));
_replyAdapter.addDefaultServant(new LookupReplyI(lookup), "");
Ice.Identity id = new Ice.Identity("dummy", "");
lookup.setLookupReply(LookupReplyPrxHelper.uncheckedCast(_replyAdapter.createProxy(id).ice_datagram()));
//
// Setup locator on the communicator.
//
Ice.ObjectPrx loc;
loc = _locatorAdapter.addWithUUID(
new LocatorI(lookup, Ice.LocatorRegistryPrxHelper.uncheckedCast(locatorRegistryPrx)));
_defaultLocator = _communicator.getDefaultLocator();
_locator = Ice.LocatorPrxHelper.uncheckedCast(loc);
_communicator.setDefaultLocator(_locator);
_multicastAdapter.activate();
_replyAdapter.activate();
_locatorAdapter.activate();
}
public void Invoke(Ice.InputStream stream)
{
_is = stream;
int start = _is.Pos;
//
// Read the current.
//
var id = new Ice.Identity(_is);
//
// For compatibility with the old FacetPath.
//
string[] facetPath = _is.ReadStringArray();
string facet;
if (facetPath.Length > 0)
{
if (facetPath.Length > 1)
{
throw new Ice.MarshalException();
}
facet = facetPath[0];
}
else
{
facet = "";
}
string operation = _is.ReadString();
byte mode = _is.ReadByte();
var context = new Dictionary <string, string>();
int sz = _is.ReadSize();
while (sz-- > 0)
{
string first = _is.ReadString();
string second = _is.ReadString();
context[first] = second;
}
_current = new Ice.Current(_adapter, id, facet, operation, (Ice.OperationMode)mode, context, _requestId, _connection);
Ice.Instrumentation.ICommunicatorObserver?obsv = _communicator.Observer;
if (obsv != null)
{
// Read the encapsulation size.
int size = _is.ReadInt();
_is.Pos -= 4;
_observer = obsv.GetDispatchObserver(_current, _is.Pos - start + size);
if (_observer != null)
{
_observer.Attach();
}
}
//
// Don't put the code above into the try block below. Exceptions
// in the code above are considered fatal, and must propagate to
// the caller of this operation.
//
_servant = _adapter.Find(_current.Id, _current.Facet);
if (_servant == null)
{
try
{
throw new Ice.ObjectNotExistException(_current.Id, _current.Facet, _current.Operation);
}
catch (Exception ex)
{
SkipReadParams(); // Required for batch requests
HandleException(ex, false);
return;
}
}
try
{
Task <Ice.OutputStream?>?task = _servant.Dispatch(this, _current);
if (task == null)
{
Completed(null, false);
}
else
{
if (task.IsCompleted)
{
_os = task.GetAwaiter().GetResult(); // Get the response
Completed(null, false);
}
else
{
task.ContinueWith((Task <Ice.OutputStream> t) =>
{
try
{
_os = t.GetAwaiter().GetResult();
Completed(null, true); // true = asynchronous
}
catch (Exception ex)
{
Completed(ex, true); // true = asynchronous
}
},
CancellationToken.None,
TaskContinuationOptions.ExecuteSynchronously,
scheduler: TaskScheduler.Current);
}
}
}
catch (Exception ex)
{
Completed(ex, false);
}
}
public override void findObjectById_async(Ice.AMD_Locator_findObjectById cb, Ice.Identity id, Ice.Current c)
{
_lookup.findObject(cb, id);
}
public static Test.TestIntfPrx allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
var output = helper.getWriter();
output.Write("testing stringToProxy... ");
output.Flush();
string @ref = "test:" + helper.getTestEndpoint(0);
Ice.ObjectPrx @base = communicator.stringToProxy(@ref);
test(@base != null);
output.WriteLine("ok");
output.Write("testing checked cast... ");
output.Flush();
var obj = Test.TestIntfPrxHelper.checkedCast(@base);
test(obj != null);
test(obj.Equals(@base));
output.WriteLine("ok");
{
output.Write("creating/destroying/recreating object adapter... ");
output.Flush();
Ice.ObjectAdapter adapter =
communicator.createObjectAdapterWithEndpoints("TransientTestAdapter", "default");
try
{
communicator.createObjectAdapterWithEndpoints("TransientTestAdapter", "default");
test(false);
}
catch (Ice.AlreadyRegisteredException)
{
}
adapter.destroy();
//
// Use a different port than the first adapter to avoid an "address already in use" error.
//
adapter = communicator.createObjectAdapterWithEndpoints("TransientTestAdapter", "default");
adapter.destroy();
output.WriteLine("ok");
}
output.Write("creating/activating/deactivating object adapter in one operation... ");
output.Flush();
obj.transient();
obj.end_transient(obj.begin_transient());
output.WriteLine("ok");
{
output.Write("testing connection closure... ");
output.Flush();
for (int i = 0; i < 10; ++i)
{
Ice.InitializationData initData = new Ice.InitializationData();
initData.properties = communicator.getProperties().ice_clone_();
Ice.Communicator comm = Ice.Util.initialize(initData);
comm.stringToProxy("test:" + helper.getTestEndpoint(0)).begin_ice_ping();
comm.destroy();
}
output.WriteLine("ok");
}
output.Write("testing object adapter published endpoints... ");
output.Flush();
{
communicator.getProperties().setProperty("PAdapter.PublishedEndpoints", "tcp -h localhost -p 12345 -t 30000");
Ice.ObjectAdapter adapter = communicator.createObjectAdapter("PAdapter");
test(adapter.getPublishedEndpoints().Length == 1);
Ice.Endpoint endpt = adapter.getPublishedEndpoints()[0];
test(endpt.ToString().Equals("tcp -h localhost -p 12345 -t 30000"));
Ice.ObjectPrx prx =
communicator.stringToProxy("dummy:tcp -h localhost -p 12346 -t 20000:tcp -h localhost -p 12347 -t 10000");
adapter.setPublishedEndpoints(prx.ice_getEndpoints());
test(adapter.getPublishedEndpoints().Length == 2);
Ice.Identity id = new Ice.Identity();
id.name = "dummy";
test(IceUtilInternal.Arrays.Equals(adapter.createProxy(id).ice_getEndpoints(), prx.ice_getEndpoints()));
test(IceUtilInternal.Arrays.Equals(adapter.getPublishedEndpoints(), prx.ice_getEndpoints()));
adapter.refreshPublishedEndpoints();
test(adapter.getPublishedEndpoints().Length == 1);
test(adapter.getPublishedEndpoints()[0].Equals(endpt));
communicator.getProperties().setProperty("PAdapter.PublishedEndpoints", "tcp -h localhost -p 12345 -t 20000");
adapter.refreshPublishedEndpoints();
test(adapter.getPublishedEndpoints().Length == 1);
test(adapter.getPublishedEndpoints()[0].ToString().Equals("tcp -h localhost -p 12345 -t 20000"));
adapter.destroy();
test(adapter.getPublishedEndpoints().Length == 0);
}
output.WriteLine("ok");
if (obj.ice_getConnection() != null)
{
output.Write("testing object adapter with bi-dir connection... ");
output.Flush();
Ice.ObjectAdapter adapter = communicator.createObjectAdapter("");
obj.ice_getConnection().setAdapter(adapter);
obj.ice_getConnection().setAdapter(null);
adapter.deactivate();
try
{
obj.ice_getConnection().setAdapter(adapter);
test(false);
}
catch (Ice.ObjectAdapterDeactivatedException)
{
}
output.WriteLine("ok");
}
output.Write("testing object adapter with router... ");
output.Flush();
{
Ice.Identity routerId = new Ice.Identity();
routerId.name = "router";
Ice.RouterPrx router =
Ice.RouterPrxHelper.uncheckedCast(@base.ice_identity(routerId).ice_connectionId("rc"));
Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithRouter("", router);
test(adapter.getPublishedEndpoints().Length == 1);
test(adapter.getPublishedEndpoints()[0].ToString().Equals("tcp -h localhost -p 23456 -t 30000"));
adapter.refreshPublishedEndpoints();
test(adapter.getPublishedEndpoints().Length == 1);
test(adapter.getPublishedEndpoints()[0].ToString().Equals("tcp -h localhost -p 23457 -t 30000"));
try
{
adapter.setPublishedEndpoints(router.ice_getEndpoints());
test(false);
}
catch (ArgumentException)
{
// Expected.
}
adapter.destroy();
try
{
routerId.name = "test";
router = Ice.RouterPrxHelper.uncheckedCast(@base.ice_identity(routerId));
communicator.createObjectAdapterWithRouter("", router);
test(false);
}
catch (Ice.OperationNotExistException)
{
// Expected: the "test" object doesn't implement Ice::Router!
}
try
{
router = Ice.RouterPrxHelper.uncheckedCast(communicator.stringToProxy("test:" +
helper.getTestEndpoint(1)));
communicator.createObjectAdapterWithRouter("", router);
test(false);
}
catch (Ice.ConnectFailedException)
{
}
}
output.WriteLine("ok");
output.Write("testing object adapter creation with port in use... ");
output.Flush();
{
var adapter1 = communicator.createObjectAdapterWithEndpoints("Adpt1", helper.getTestEndpoint(10));
try
{
communicator.createObjectAdapterWithEndpoints("Adpt2", helper.getTestEndpoint(10));
test(false);
}
catch (Ice.LocalException)
{
// Expected can't re-use the same endpoint.
}
adapter1.destroy();
}
output.WriteLine("ok");
output.Write("deactivating object adapter in the server... ");
output.Flush();
obj.deactivate();
output.WriteLine("ok");
output.Write("testing whether server is gone... ");
output.Flush();
try
{
obj.ice_timeout(100).ice_ping(); // Use timeout to speed up testing on Windows
test(false);
}
catch (Ice.LocalException)
{
output.WriteLine("ok");
}
return(obj);
}
public Reference create(string s, string propertyPrefix)
{
if (s.Length == 0)
{
return(null);
}
const string delim = " \t\n\r";
int beg;
int end = 0;
beg = IceUtilInternal.StringUtil.findFirstNotOf(s, delim, end);
if (beg == -1)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "no non-whitespace characters found in `" + s + "'";
throw e;
}
//
// Extract the identity, which may be enclosed in single
// or double quotation marks.
//
string idstr = null;
end = IceUtilInternal.StringUtil.checkQuote(s, beg);
if (end == -1)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "mismatched quotes around identity in `" + s + "'";
throw e;
}
else if (end == 0)
{
end = IceUtilInternal.StringUtil.findFirstOf(s, delim + ":@", beg);
if (end == -1)
{
end = s.Length;
}
idstr = s.Substring(beg, end - beg);
}
else
{
beg++; // Skip leading quote
idstr = s.Substring(beg, end - beg);
end++; // Skip trailing quote
}
if (beg == end)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "no identity in `" + s + "'";
throw e;
}
//
// Parsing the identity may raise IdentityParseException.
//
Ice.Identity ident = Ice.Util.stringToIdentity(idstr);
if (ident.name.Length == 0)
{
//
// An identity with an empty name and a non-empty
// category is illegal.
//
if (ident.category.Length > 0)
{
Ice.IllegalIdentityException e = new Ice.IllegalIdentityException();
e.id = ident;
throw e;
}
//
// Treat a stringified proxy containing two double
// quotes ("") the same as an empty string, i.e.,
// a null proxy, but only if nothing follows the
// quotes.
//
else if (IceUtilInternal.StringUtil.findFirstNotOf(s, delim, end) != -1)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "invalid characters after identity in `" + s + "'";
throw e;
}
else
{
return(null);
}
}
string facet = "";
Reference.Mode mode = Reference.Mode.ModeTwoway;
bool secure = false;
Ice.EncodingVersion encoding = _instance.defaultsAndOverrides().defaultEncoding;
Ice.ProtocolVersion protocol = Ice.Util.Protocol_1_0;
string adapter = "";
while (true)
{
beg = IceUtilInternal.StringUtil.findFirstNotOf(s, delim, end);
if (beg == -1)
{
break;
}
if (s[beg] == ':' || s[beg] == '@')
{
break;
}
end = IceUtilInternal.StringUtil.findFirstOf(s, delim + ":@", beg);
if (end == -1)
{
end = s.Length;
}
if (beg == end)
{
break;
}
string option = s.Substring(beg, end - beg);
if (option.Length != 2 || option[0] != '-')
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "expected a proxy option but found `" + option + "' in `" + s + "'";
throw e;
}
//
// Check for the presence of an option argument. The
// argument may be enclosed in single or double
// quotation marks.
//
string argument = null;
int argumentBeg = IceUtilInternal.StringUtil.findFirstNotOf(s, delim, end);
if (argumentBeg != -1)
{
char ch = s[argumentBeg];
if (ch != '@' && ch != ':' && ch != '-')
{
beg = argumentBeg;
end = IceUtilInternal.StringUtil.checkQuote(s, beg);
if (end == -1)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "mismatched quotes around value for " + option + " option in `" + s + "'";
throw e;
}
else if (end == 0)
{
end = IceUtilInternal.StringUtil.findFirstOf(s, delim + ":@", beg);
if (end == -1)
{
end = s.Length;
}
argument = s.Substring(beg, end - beg);
}
else
{
beg++; // Skip leading quote
argument = s.Substring(beg, end - beg);
end++; // Skip trailing quote
}
}
}
//
// If any new options are added here,
// IceInternal::Reference::toString() and its derived classes must be updated as well.
//
switch (option[1])
{
case 'f':
{
if (argument == null)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "no argument provided for -f option in `" + s + "'";
throw e;
}
try
{
facet = IceUtilInternal.StringUtil.unescapeString(argument, 0, argument.Length, "");
}
catch (ArgumentException argEx)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "invalid facet in `" + s + "': " + argEx.Message;
throw e;
}
break;
}
case 't':
{
if (argument != null)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "unexpected argument `" + argument + "' provided for -t option in `" + s + "'";
throw e;
}
mode = Reference.Mode.ModeTwoway;
break;
}
case 'o':
{
if (argument != null)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "unexpected argument `" + argument + "' provided for -o option in `" + s + "'";
throw e;
}
mode = Reference.Mode.ModeOneway;
break;
}
case 'O':
{
if (argument != null)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "unexpected argument `" + argument + "' provided for -O option in `" + s + "'";
throw e;
}
mode = Reference.Mode.ModeBatchOneway;
break;
}
case 'd':
{
if (argument != null)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "unexpected argument `" + argument + "' provided for -d option in `" + s + "'";
throw e;
}
mode = Reference.Mode.ModeDatagram;
break;
}
case 'D':
{
if (argument != null)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "unexpected argument `" + argument + "' provided for -D option in `" + s + "'";
throw e;
}
mode = Reference.Mode.ModeBatchDatagram;
break;
}
case 's':
{
if (argument != null)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "unexpected argument `" + argument + "' provided for -s option in `" + s + "'";
throw e;
}
secure = true;
break;
}
case 'e':
{
if (argument == null)
{
throw new Ice.ProxyParseException("no argument provided for -e option `" + s + "'");
}
try
{
encoding = Ice.Util.stringToEncodingVersion(argument);
}
catch (Ice.VersionParseException e)
{
throw new Ice.ProxyParseException("invalid encoding version `" + argument + "' in `" + s +
"':\n" + e.str);
}
break;
}
case 'p':
{
if (argument == null)
{
throw new Ice.ProxyParseException("no argument provided for -p option `" + s + "'");
}
try
{
protocol = Ice.Util.stringToProtocolVersion(argument);
}
catch (Ice.VersionParseException e)
{
throw new Ice.ProxyParseException("invalid protocol version `" + argument + "' in `" + s +
"':\n" + e.str);
}
break;
}
default:
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "unknown option `" + option + "' in `" + s + "'";
throw e;
}
}
}
if (beg == -1)
{
return(create(ident, facet, mode, secure, protocol, encoding, null, null, propertyPrefix));
}
List <EndpointI> endpoints = new List <EndpointI>();
if (s[beg] == ':')
{
List <string> unknownEndpoints = new List <string>();
end = beg;
while (end < s.Length && s[end] == ':')
{
beg = end + 1;
end = beg;
while (true)
{
end = s.IndexOf(':', end);
if (end == -1)
{
end = s.Length;
break;
}
else
{
bool quoted = false;
int quote = beg;
while (true)
{
quote = s.IndexOf('\"', quote);
if (quote == -1 || end < quote)
{
break;
}
else
{
quote = s.IndexOf('\"', ++quote);
if (quote == -1)
{
break;
}
else if (end < quote)
{
quoted = true;
break;
}
++quote;
}
}
if (!quoted)
{
break;
}
++end;
}
}
string es = s.Substring(beg, end - beg);
EndpointI endp = _instance.endpointFactoryManager().create(es, false);
if (endp != null)
{
endpoints.Add(endp);
}
else
{
unknownEndpoints.Add(es);
}
}
if (endpoints.Count == 0)
{
Debug.Assert(unknownEndpoints.Count > 0);
Ice.EndpointParseException e2 = new Ice.EndpointParseException();
e2.str = "invalid endpoint `" + unknownEndpoints[0] + "' in `" + s + "'";
throw e2;
}
else if (unknownEndpoints.Count != 0 &&
_instance.initializationData().properties.getPropertyAsIntWithDefault(
"Ice.Warn.Endpoints", 1) > 0)
{
StringBuilder msg = new StringBuilder("Proxy contains unknown endpoints:");
int sz = unknownEndpoints.Count;
for (int idx = 0; idx < sz; ++idx)
{
msg.Append(" `");
msg.Append(unknownEndpoints[idx]);
msg.Append("'");
}
_instance.initializationData().logger.warning(msg.ToString());
}
EndpointI[] ep = endpoints.ToArray();
return(create(ident, facet, mode, secure, protocol, encoding, ep, null, propertyPrefix));
}
else if (s[beg] == '@')
{
beg = IceUtilInternal.StringUtil.findFirstNotOf(s, delim, beg + 1);
if (beg == -1)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "missing adapter id in `" + s + "'";
throw e;
}
string adapterstr = null;
end = IceUtilInternal.StringUtil.checkQuote(s, beg);
if (end == -1)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "mismatched quotes around adapter id in `" + s + "'";
throw e;
}
else if (end == 0)
{
end = IceUtilInternal.StringUtil.findFirstOf(s, delim, beg);
if (end == -1)
{
end = s.Length;
}
adapterstr = s.Substring(beg, end - beg);
}
else
{
beg++; // Skip leading quote
adapterstr = s.Substring(beg, end - beg);
end++; // Skip trailing quote
}
if (end != s.Length && IceUtilInternal.StringUtil.findFirstNotOf(s, delim, end) != -1)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "invalid trailing characters after `" + s.Substring(0, end + 1) + "' in `" + s + "'";
throw e;
}
try
{
adapter = IceUtilInternal.StringUtil.unescapeString(adapterstr, 0, adapterstr.Length, "");
}
catch (ArgumentException argEx)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "invalid adapter id in `" + s + "': " + argEx.Message;
throw e;
}
if (adapter.Length == 0)
{
Ice.ProxyParseException e = new Ice.ProxyParseException();
e.str = "empty adapter id in `" + s + "'";
throw e;
}
return(create(ident, facet, mode, secure, protocol, encoding, null, adapter, propertyPrefix));
}
Ice.ProxyParseException ex = new Ice.ProxyParseException();
ex.str = "malformed proxy `" + s + "'";
throw ex;
}
public void Initialize(IScene scene)
{
try
{
if (!m_enabled)
return;
IMurmurService service = scene.RequestModuleInterface<IMurmurService>();
if (service == null)
return;
MurmurConfig config = service.GetConfiguration(scene.RegionInfo.RegionName);
if (config == null)
return;
bool justStarted = false;
if (!m_started)
{
justStarted = true;
m_started = true;
// retrieve configuration variables
m_murmurd_host = config.MurmurHost;
m_server_version = config.ServerVersion;
//Fix the callback URL, its our IP, so we deal with it
IConfig m_config = m_source.Configs["MurmurService"];
if (m_config != null)
config.IceCB = m_config.GetString("murmur_ice_cb", "tcp -h 127.0.0.1");
// Admin interface required values
if (String.IsNullOrEmpty(m_murmurd_host))
{
m_log.Error("[MurmurVoice] plugin disabled: incomplete configuration");
return;
}
Ice.Communicator comm = Ice.Util.initialize();
if (config.GlacierEnabled)
{
router = RouterPrxHelper.uncheckedCast(comm.stringToProxy(config.GlacierIce));
comm.setDefaultRouter(router);
router.createSession(config.GlacierUser, config.GlacierPass);
}
MetaPrx meta = MetaPrxHelper.checkedCast(comm.stringToProxy(config.MetaIce));
// Create the adapter
comm.getProperties().setProperty("Ice.PrintAdapterReady", "0");
if (config.GlacierEnabled)
adapter = comm.createObjectAdapterWithRouter("Callback.Client", comm.getDefaultRouter());
else
adapter = comm.createObjectAdapterWithEndpoints("Callback.Client", config.IceCB);
adapter.activate();
// Create identity and callback for Metaserver
Ice.Identity metaCallbackIdent = new Ice.Identity();
metaCallbackIdent.name = "metaCallback";
if (router != null)
metaCallbackIdent.category = router.getCategoryForClient();
MetaCallbackPrx meta_callback = MetaCallbackPrxHelper.checkedCast(adapter.add(new MetaCallbackImpl(), metaCallbackIdent));
meta.addCallback(meta_callback);
m_log.InfoFormat("[MurmurVoice] using murmur server ice '{0}'", config.MetaIce);
// create a server and figure out the port name
Dictionary<string, string> defaults = meta.getDefaultConf();
m_server = ServerPrxHelper.checkedCast(meta.getServer(config.ServerID));
// start thread to ping glacier2 router and/or determine if con$
m_keepalive = new KeepAlive(m_server);
ThreadStart ka_d = new ThreadStart(m_keepalive.StartPinging);
m_keepalive_t = new Thread(ka_d);
m_keepalive_t.Start();
// first check the conf for a port, if not then use server id and default port to find the right one.
string conf_port = m_server.getConf("port");
if (!String.IsNullOrEmpty(conf_port))
m_murmurd_port = Convert.ToInt32(conf_port);
else
m_murmurd_port = Convert.ToInt32(defaults["port"]) + config.ServerID - 1;
try
{
m_server.start();
}
catch
{
}
}
// starts the server and gets a callback
ServerManager manager = new ServerManager(m_server, config.ChannelName);
// Create identity and callback for this current server
AddServerCallback(scene, new ServerCallbackImpl(manager));
AddServerManager(scene, manager);
if (justStarted)
{
Ice.Identity serverCallbackIdent = new Ice.Identity();
serverCallbackIdent.name = "serverCallback";
if (router != null)
serverCallbackIdent.category = router.getCategoryForClient();
m_server.addCallback(ServerCallbackPrxHelper.checkedCast(adapter.add(GetServerCallback(scene), serverCallbackIdent)));
}
// Show information on console for debugging purposes
m_log.InfoFormat("[MurmurVoice] using murmur server '{0}:{1}', sid '{2}'", m_murmurd_host, m_murmurd_port, config.ServerID);
m_log.Info("[MurmurVoice] plugin enabled");
m_enabled = true;
}
catch (Exception e)
{
m_log.ErrorFormat("[MurmurVoice] plugin initialization failed: {0}", e.ToString());
return;
}
}
public static Ice.DispatchStatus addClient___(KP obj__, IceInternal.Incoming inS__, Ice.Current current__)
{
checkMode__(Ice.OperationMode.Normal, current__.mode);
IceInternal.BasicStream is__ = inS__.istr();
is__.startReadEncaps();
Ice.Identity ident;
ident = null;
if(ident == null)
{
ident = new Ice.Identity();
}
ident.read__(is__);
is__.endReadEncaps();
obj__.addClient(ident, current__);
return Ice.DispatchStatus.DispatchOK;
}
findObjectByIdAsync(Ice.Identity id, Action <Ice.ObjectPrx> response, Action <Exception> exception,
Ice.Current current)
{
response(null);
}
public LocatorKey(Ice.LocatorPrx prx)
{
Reference r = ((Ice.ObjectPrxHelperBase)prx).reference__();
_id = r.getIdentity();
_encoding = r.getEncoding();
}
public void activate()
{
LocatorInfo locatorInfo = null;
bool printAdapterReady = false;
lock(this)
{
checkForDeactivation();
//
// If we've previously been initialized we just need to activate the
// incoming connection factories and we're done.
//
if(state_ != StateUninitialized)
{
foreach(IncomingConnectionFactory icf in _incomingConnectionFactories)
{
icf.activate();
}
return;
}
//
// One off initializations of the adapter: update the
// locator registry and print the "adapter ready"
// message. We set set state to StateActivating to prevent
// deactivation from other threads while these one off
// initializations are done.
//
state_ = StateActivating;
locatorInfo = _locatorInfo;
if(!_noConfig)
{
Properties properties = instance_.initializationData().properties;
printAdapterReady = properties.getPropertyAsInt("Ice.PrintAdapterReady") > 0;
}
}
try
{
Ice.Identity dummy = new Ice.Identity();
dummy.name = "dummy";
updateLocatorRegistry(locatorInfo, createDirectProxy(dummy));
}
catch(Ice.LocalException)
{
//
// If we couldn't update the locator registry, we let the
// exception go through and don't activate the adapter to
// allow to user code to retry activating the adapter
// later.
//
lock(this)
{
state_ = StateUninitialized;
System.Threading.Monitor.PulseAll(this);
}
throw;
}
if(printAdapterReady)
{
System.Console.Out.WriteLine(_name + " ready");
}
lock(this)
{
Debug.Assert(state_ == StateActivating);
foreach(IncomingConnectionFactory icf in _incomingConnectionFactories)
{
icf.activate();
}
state_ = StateActive;
System.Threading.Monitor.PulseAll(this);
}
}
/// <summary>
/// Set the router object identity.
/// </summary>
/// <param name="identity">The Glacier2 router's identity.</param>
public void setRouterIdentity(Ice.Identity identity)
{
lock(this)
{
_identity = identity;
}
}
public void Initialise(IConfigSource config)
{
if(m_started)
return;
m_started = true;
m_config = config.Configs["MurmurVoice"];
if (null == m_config)
{
m_log.Info("[MurmurVoice] no config found, plugin disabled");
return;
}
if (!m_config.GetBoolean("enabled", false))
{
m_log.Info("[MurmurVoice] plugin disabled by configuration");
return;
}
try
{
// retrieve configuration variables
m_murmurd_ice = m_config.GetString("murmur_ice", String.Empty);
m_murmurd_host = m_config.GetString("murmur_host", String.Empty);
m_murmurd_exthost = m_config.GetString("murmur_exthost", String.Empty);
m_murmurd_AgentPass = m_config.GetString("murmur_AgentPass", String.Empty);
m_murmurd_EstateChannel = m_config.GetString("murmur_EstateChannel", "MyEstate");
int server_id = m_config.GetInt("murmur_sid", 1);
// Admin interface required values
if (String.IsNullOrEmpty(m_murmurd_ice) ||
String.IsNullOrEmpty(m_murmurd_host) ||
String.IsNullOrEmpty(m_murmurd_AgentPass)
)
{
m_log.Error("[MurmurVoice] plugin disabled: incomplete configuration");
return;
}
if (String.IsNullOrEmpty(m_murmurd_exthost))
m_murmurd_exthost = m_murmurd_host;
m_murmurd_ice = "Meta:" + m_murmurd_ice;
Ice.Communicator comm = Ice.Util.initialize();
bool glacier_enabled = m_config.GetBoolean("glacier", false);
Glacier2.RouterPrx router = null;
if(glacier_enabled)
{
router = RouterPrxHelper.uncheckedCast(comm.stringToProxy(m_config.GetString("glacier_ice", String.Empty)));
comm.setDefaultRouter(router);
router.createSession(m_config.GetString("glacier_user","admin"),m_config.GetString("glacier_pass","password"));
}
MetaPrx meta = MetaPrxHelper.checkedCast(comm.stringToProxy(m_murmurd_ice));
// Create the adapter
comm.getProperties().setProperty("Ice.PrintAdapterReady", "0");
Ice.ObjectAdapter adapter;
if(glacier_enabled)
{
adapter = comm.createObjectAdapterWithRouter("Callback.Client", comm.getDefaultRouter() );
}
else
{
adapter = comm.createObjectAdapterWithEndpoints("Callback.Client", m_config.GetString("murmur_ice_cb","tcp -h 127.0.0.1"));
}
adapter.activate();
// Create identity and callback for Metaserver
Ice.Identity metaCallbackIdent = new Ice.Identity();
metaCallbackIdent.name = "metaCallback";
if(router != null)
metaCallbackIdent.category = router.getCategoryForClient();
MetaCallbackPrx meta_callback = MetaCallbackPrxHelper.checkedCast(adapter.add(new MetaCallbackImpl(), metaCallbackIdent ));
meta.addCallback(meta_callback);
m_log.InfoFormat("[MurmurVoice] using murmur server ice '{0}'", m_murmurd_ice);
// create a server and figure out the port name
Dictionary<string,string> defaults = meta.getDefaultConf();
ServerPrx server = ServerPrxHelper.checkedCast(meta.getServer(server_id));
// first check the conf for a port, if not then use server id and default port to find the right one.
string conf_port = server.getConf("port");
if(!String.IsNullOrEmpty(conf_port))
m_murmurd_port = Convert.ToInt32(conf_port);
else
m_murmurd_port = Convert.ToInt32(defaults["port"])+server_id-1;
// starts the server and gets a callback
m_manager = new ServerManager(server, m_murmurd_EstateChannel);
// Create identity and callback for this current server
m_callback = new ServerCallbackImpl(server, m_manager);
Ice.Identity serverCallbackIdent = new Ice.Identity();
serverCallbackIdent.name = "serverCallback";
if(router != null)
serverCallbackIdent.category = router.getCategoryForClient();
server.addCallback(ServerCallbackPrxHelper.checkedCast(adapter.add(m_callback, serverCallbackIdent)));
// Show information on console for debugging purposes
m_log.InfoFormat("[MurmurVoice] using murmur server '{0}:{1}', sid '{2}' extern host {3}", m_murmurd_host, m_murmurd_port, server_id,m_murmurd_exthost);
m_log.Info("[MurmurVoice] plugin enabled");
m_enabled = true;
}
catch (Exception e)
{
m_log.ErrorFormat("[MurmurVoice] plugin initialization failed: {0}", e.ToString());
return;
}
}
public virtual void WriteProxy (object o, Type ot) {
if (!RemotingServices.IsTransparentProxy (o)) {
Console.WriteLine ("o {0} ot {1} is not transparent proxy!", o, ot);
throw new InvalidOperationException ("object which is not a transparent proxy passed to WriteProxy, type " + ot);
}
ObjRef or = RemotingServices.GetObjRefForProxy ((System.MarshalByRefObject) o);
Ice.Identity proxy_ident = new Ice.Identity (or.URI.StartsWith("/") ? or.URI.Substring(1) : or.URI);
Ice.Endpoint proxy_ep = null;
foreach (object cdo in or.ChannelInfo.ChannelData) {
ChannelDataStore cd = cdo as ChannelDataStore;
if (cd == null)
continue;
foreach (string ch_uri in cd.ChannelUris) {
string host;
int port;
string uri;
if (IceChannelUtils.ParseIceURL (ch_uri, out host, out port, out uri)) {
proxy_ep = new Ice.TcpEndpoint (host, port);
proxy_ep.Incoming = true;
break;
}
}
}
if (proxy_ep == null) {
throw new InvalidOperationException ("Couldn't find valid Ice endpoint/channel for " + o);
}
Ice.ProxyData pd = new Ice.ProxyData();
pd.id = proxy_ident;
pd.facet = new string[0];
pd.mode = ProxyMode.Twoway; // FIXME -- do I need to send multiple proxy things here?
pd.secure = false;
WriteStruct (pd);
WriteSize (1); // one endpoint follows
// tcp endpoint encapsulation
WriteObject ((short) 1); // it's a TCP endpoint
BeginEncapsulation();
Ice.TcpEndpoint te = proxy_ep as Ice.TcpEndpoint;
Write (te.host);
WriteObject (te.port);
WriteObject (te.timeout);
WriteObject (te.compress);
EndEncapsulation();
}
public static Ice.DispatchStatus Join___(Lobby obj__, IceInternal.Incoming inS__, Ice.Current current__)
{
checkMode__(Ice.OperationMode.Normal, current__.mode);
IceInternal.BasicStream is__ = inS__.istr();
is__.startReadEncaps();
string nick;
nick = is__.readString();
string topic;
topic = is__.readString();
Ice.Identity listenerIdentity;
listenerIdentity = null;
if(listenerIdentity == null)
{
listenerIdentity = new Ice.Identity();
}
listenerIdentity.read__(is__);
is__.endReadEncaps();
IceInternal.BasicStream os__ = inS__.ostr();
try
{
Chat.RoomAccess ret__ = obj__.Join(nick, topic, listenerIdentity, current__);
if(ret__ == null)
{
Chat.RoomAccess tmp__ = new Chat.RoomAccess();
tmp__.write__(os__);
}
else
{
ret__.write__(os__);
}
return Ice.DispatchStatus.DispatchOK;
}
catch(Chat.IChatException ex__)
{
os__.writeUserException(ex__);
return Ice.DispatchStatus.DispatchUserException;
}
}
public void initialize()
{
Ice.Properties properties = _communicator.getProperties();
bool ipv4 = properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
bool preferIPv6 = properties.getPropertyAsInt("Ice.PreferIPv6Address") > 0;
string address;
if(ipv4 && !preferIPv6)
{
address = properties.getPropertyWithDefault("IceLocatorDiscovery.Address", "239.255.0.1");
}
else
{
address = properties.getPropertyWithDefault("IceLocatorDiscovery.Address", "ff15::1");
}
int port = properties.getPropertyAsIntWithDefault("IceLocatorDiscovery.Port", 4061);
string intf = properties.getProperty("IceLocatorDiscovery.Interface");
if(properties.getProperty("IceLocatorDiscovery.Reply.Endpoints").Length == 0)
{
System.Text.StringBuilder s = new System.Text.StringBuilder();
s.Append("udp");
if(intf.Length > 0)
{
s.Append(" -h \"");
s.Append(intf);
s.Append("\"");
}
properties.setProperty("IceLocatorDiscovery.Reply.Endpoints", s.ToString());
}
if(properties.getProperty("IceLocatorDiscovery.Locator.Endpoints").Length == 0)
{
properties.setProperty("IceLocatorDiscovery.Locator.AdapterId", Guid.NewGuid().ToString());
}
_replyAdapter = _communicator.createObjectAdapter("IceLocatorDiscovery.Reply");
_locatorAdapter = _communicator.createObjectAdapter("IceLocatorDiscovery.Locator");
// We don't want those adapters to be registered with the locator so clear their locator.
_replyAdapter.setLocator(null);
_locatorAdapter.setLocator(null);
string lookupEndpoints = properties.getProperty("IceLocatorDiscovery.Lookup");
if(lookupEndpoints.Length == 0)
{
System.Text.StringBuilder s = new System.Text.StringBuilder();
s.Append("udp -h \"");
s.Append(address);
s.Append("\" -p ");
s.Append(port);
if(intf.Length > 0)
{
s.Append(" --interface \"");
s.Append(intf);
s.Append("\"");
}
lookupEndpoints = s.ToString();
}
Ice.ObjectPrx lookupPrx = _communicator.stringToProxy("IceLocatorDiscovery/Lookup -d:" + lookupEndpoints);
lookupPrx = lookupPrx.ice_collocationOptimized(false); // No colloc optimization for the multicast proxy!
try
{
lookupPrx.ice_getConnection(); // Ensure we can establish a connection to the multicast proxy
}
catch (Ice.LocalException ex)
{
System.Text.StringBuilder s = new System.Text.StringBuilder();
s.Append("IceLocatorDiscovery is unable to establish a multicast connection:\n");
s.Append("proxy = ");
s.Append(lookupPrx.ToString());
s.Append("\n");
s.Append(ex);
throw new Ice.PluginInitializationException(s.ToString());
}
Ice.LocatorPrx voidLo = Ice.LocatorPrxHelper.uncheckedCast(_locatorAdapter.addWithUUID(new VoidLocatorI()));
string instanceName = properties.getProperty("IceLocatorDiscovery.InstanceName");
Ice.Identity id = new Ice.Identity();
id.name = "Locator";
id.category = instanceName.Length > 0 ? instanceName : Guid.NewGuid().ToString();
LocatorI locator = new LocatorI(LookupPrxHelper.uncheckedCast(lookupPrx), properties, instanceName, voidLo);
_communicator.setDefaultLocator(Ice.LocatorPrxHelper.uncheckedCast(_locatorAdapter.addWithUUID(locator)));
Ice.ObjectPrx lookupReply = _replyAdapter.addWithUUID(new LookupReplyI(locator)).ice_datagram();
locator.setLookupReply(LookupReplyPrxHelper.uncheckedCast(lookupReply));
_replyAdapter.activate();
_locatorAdapter.activate();
}
public void Initialize(Scene scene)
{
try
{
if (!m_enabled) return;
if (!m_started)
{
m_started = true;
scene.AddCommand(this, "mumble report", "mumble report",
"Returns mumble report", MumbleReport);
scene.AddCommand(this, "mumble unregister", "mumble unregister <userid>",
"Unregister User by userid", UnregisterUser);
scene.AddCommand(this, "mumble remove", "mumble remove <UUID>",
"Remove Agent by UUID", RemoveAgent);
Ice.Communicator comm = Ice.Util.initialize();
/*
if (m_glacier_enabled)
{
m_router = RouterPrxHelper.uncheckedCast(comm.stringToProxy(m_glacier_ice));
comm.setDefaultRouter(m_router);
m_router.createSession(m_glacier_user, m_glacier_pass);
}
*/
MetaPrx meta = MetaPrxHelper.checkedCast(comm.stringToProxy(m_murmurd_ice));
// Create the adapter
comm.getProperties().setProperty("Ice.PrintAdapterReady", "0");
if (m_glacier_enabled)
m_adapter = comm.createObjectAdapterWithRouter("Callback.Client", comm.getDefaultRouter() );
else
m_adapter = comm.createObjectAdapterWithEndpoints("Callback.Client", m_murmur_ice_cb);
m_adapter.activate();
// Create identity and callback for Metaserver
Ice.Identity metaCallbackIdent = new Ice.Identity();
metaCallbackIdent.name = "metaCallback";
//if (m_router != null)
// metaCallbackIdent.category = m_router.getCategoryForClient();
MetaCallbackPrx meta_callback = MetaCallbackPrxHelper.checkedCast(m_adapter.add(new MetaCallbackImpl(), metaCallbackIdent));
meta.addCallback(meta_callback);
m_log.InfoFormat("[MurmurVoice] using murmur server ice '{0}'", m_murmurd_ice);
// create a server and figure out the port name
Dictionary<string,string> defaults = meta.getDefaultConf();
m_server = ServerPrxHelper.checkedCast(meta.getServer(m_server_id));
// start thread to ping glacier2 router and/or determine if con$
m_keepalive = new KeepAlive(m_server);
ThreadStart ka_d = new ThreadStart(m_keepalive.StartPinging);
m_keepalive_t = new Thread(ka_d);
m_keepalive_t.Start();
// first check the conf for a port, if not then use server id and default port to find the right one.
string conf_port = m_server.getConf("port");
if(!String.IsNullOrEmpty(conf_port))
m_murmurd_port = Convert.ToInt32(conf_port);
else
m_murmurd_port = Convert.ToInt32(defaults["port"])+m_server_id-1;
try
{
m_server.start();
}
catch
{
}
m_log.Info("[MurmurVoice] started");
}
// starts the server and gets a callback
ServerManager manager = new ServerManager(m_server, m_channel_name);
// Create identity and callback for this current server
AddServerCallback(scene, new ServerCallbackImpl(manager));
AddServerManager(scene, manager);
Ice.Identity serverCallbackIdent = new Ice.Identity();
serverCallbackIdent.name = "serverCallback_" + scene.RegionInfo.RegionName.Replace(" ","_");
//if (m_router != null)
// serverCallbackIdent.category = m_router.getCategoryForClient();
m_server.addCallback(ServerCallbackPrxHelper.checkedCast(m_adapter.add(GetServerCallback(scene), serverCallbackIdent)));
// Show information on console for debugging purposes
m_log.InfoFormat("[MurmurVoice] using murmur server '{0}:{1}', sid '{2}'", m_murmurd_host, m_murmurd_port, m_server_id);
m_log.Info("[MurmurVoice] plugin enabled");
m_enabled = true;
}
catch (Exception e)
{
m_log.ErrorFormat("[MurmurVoice] plugin initialization failed: {0}", e.ToString());
return;
}
}
public Chat.RoomAccess Join(string nick, string topic, Ice.Identity listenerIdentity, _System.Collections.Generic.Dictionary<string, string> context__)
{
IceInternal.Outgoing og__ = handler__.getOutgoing("Join", Ice.OperationMode.Normal, context__);
try
{
try
{
IceInternal.BasicStream os__ = og__.ostr();
os__.writeString(nick);
os__.writeString(topic);
if(listenerIdentity == null)
{
Ice.Identity tmp__ = new Ice.Identity();
tmp__.write__(os__);
}
else
{
listenerIdentity.write__(os__);
}
}
catch(Ice.LocalException ex__)
{
og__.abort(ex__);
}
bool ok__ = og__.invoke();
try
{
if(!ok__)
{
try
{
og__.throwUserException();
}
catch(Chat.IChatException)
{
throw;
}
catch(Ice.UserException ex__)
{
throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
}
}
IceInternal.BasicStream is__ = og__.istr();
is__.startReadEncaps();
Chat.RoomAccess ret__;
ret__ = null;
if(ret__ == null)
{
ret__ = new Chat.RoomAccess();
}
ret__.read__(is__);
is__.endReadEncaps();
return ret__;
}
catch(Ice.LocalException ex__)
{
throw new IceInternal.LocalExceptionWrapper(ex__, false);
}
}
finally
{
handler__.reclaimOutgoing(og__);
}
}
attachRemoteLogger(Ice.RemoteLoggerPrx prx, Ice.LogMessageType[] messageTypes, string[] categories,
int messageMax, Ice.Current current)
{
if (prx == null)
{
return; // can't send this null RemoteLogger anything!
}
Ice.RemoteLoggerPrx remoteLogger = Ice.RemoteLoggerPrxHelper.uncheckedCast(prx.ice_twoway());
Filters filters = new Filters(messageTypes, categories);
LinkedList <Ice.LogMessage> initLogMessages = null;
lock (this)
{
if (_sendLogCommunicator == null)
{
if (_destroyed)
{
throw new Ice.ObjectNotExistException();
}
_sendLogCommunicator =
createSendLogCommunicator(current.adapter.getCommunicator(), _logger.getLocalLogger());
}
Ice.Identity remoteLoggerId = remoteLogger.ice_getIdentity();
if (_remoteLoggerMap.ContainsKey(remoteLoggerId))
{
if (_traceLevel > 0)
{
_logger.trace(_traceCategory, "rejecting `" + remoteLogger.ToString() +
"' with RemoteLoggerAlreadyAttachedException");
}
throw new Ice.RemoteLoggerAlreadyAttachedException();
}
_remoteLoggerMap.Add(remoteLoggerId,
new RemoteLoggerData(changeCommunicator(remoteLogger, _sendLogCommunicator), filters));
if (messageMax != 0)
{
initLogMessages = new LinkedList <Ice.LogMessage>(_queue); // copy
}
else
{
initLogMessages = new LinkedList <Ice.LogMessage>();
}
}
if (_traceLevel > 0)
{
_logger.trace(_traceCategory, "attached `" + remoteLogger.ToString() + "'");
}
if (initLogMessages.Count > 0)
{
filterLogMessages(initLogMessages, filters.messageTypes, filters.traceCategories, messageMax);
}
try
{
remoteLogger.initAsync(_logger.getPrefix(), initLogMessages.ToArray()).ContinueWith(
(t) =>
{
try
{
t.Wait();
if (_traceLevel > 1)
{
_logger.trace(_traceCategory, "init on `" + remoteLogger.ToString()
+ "' completed successfully");
}
}
catch (System.AggregateException ae)
{
Debug.Assert(ae.InnerException is Ice.LocalException);
deadRemoteLogger(remoteLogger, _logger, (Ice.LocalException)ae.InnerException, "init");
}
});
}
catch (Ice.LocalException ex)
{
deadRemoteLogger(remoteLogger, _logger, ex, "init");
throw;
}
}
override public Ice.AsyncCallback completed()
{
Debug.Assert(_is != null); // _is has been initialized prior to this call
//
// NOTE: this method is called from ConnectionI.parseMessage
// with the connection locked. Therefore, it must not invoke
// any user callbacks.
//
Debug.Assert(proxy_.ice_isTwoway()); // Can only be called for twoways.
if (childObserver_ != null)
{
childObserver_.reply(_is.size() - Protocol.headerSize - 4);
childObserver_.detach();
childObserver_ = null;
}
byte replyStatus;
try
{
replyStatus = _is.readByte();
switch (replyStatus)
{
case ReplyStatus.replyOK:
{
break;
}
case ReplyStatus.replyUserException:
{
if (observer_ != null)
{
observer_.userException();
}
break;
}
case ReplyStatus.replyObjectNotExist:
case ReplyStatus.replyFacetNotExist:
case ReplyStatus.replyOperationNotExist:
{
Ice.Identity id = new Ice.Identity();
id.read__(_is);
//
// For compatibility with the old FacetPath.
//
string[] facetPath = _is.readStringSeq();
string facet;
if (facetPath.Length > 0)
{
if (facetPath.Length > 1)
{
throw new Ice.MarshalException();
}
facet = facetPath[0];
}
else
{
facet = "";
}
string operation = _is.readString();
Ice.RequestFailedException ex = null;
switch (replyStatus)
{
case ReplyStatus.replyObjectNotExist:
{
ex = new Ice.ObjectNotExistException();
break;
}
case ReplyStatus.replyFacetNotExist:
{
ex = new Ice.FacetNotExistException();
break;
}
case ReplyStatus.replyOperationNotExist:
{
ex = new Ice.OperationNotExistException();
break;
}
default:
{
Debug.Assert(false);
break;
}
}
ex.id = id;
ex.facet = facet;
ex.operation = operation;
throw ex;
}
case ReplyStatus.replyUnknownException:
case ReplyStatus.replyUnknownLocalException:
case ReplyStatus.replyUnknownUserException:
{
string unknown = _is.readString();
Ice.UnknownException ex = null;
switch (replyStatus)
{
case ReplyStatus.replyUnknownException:
{
ex = new Ice.UnknownException();
break;
}
case ReplyStatus.replyUnknownLocalException:
{
ex = new Ice.UnknownLocalException();
break;
}
case ReplyStatus.replyUnknownUserException:
{
ex = new Ice.UnknownUserException();
break;
}
default:
{
Debug.Assert(false);
break;
}
}
ex.unknown = unknown;
throw ex;
}
default:
{
throw new Ice.UnknownReplyStatusException();
}
}
return(finished(replyStatus == ReplyStatus.replyOK));
}
catch (Ice.Exception ex)
{
return(completed(ex));
}
}
public string identityToString(Ice.Identity ident)
{
return(Ice.Util.identityToString(ident, _instance.toStringMode()));
}
initialize()
{
Ice.Properties properties = _communicator.getProperties();
bool ipv4 = properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
bool preferIPv6 = properties.getPropertyAsInt("Ice.PreferIPv6Address") > 0;
string address;
if (ipv4 && !preferIPv6)
{
address = properties.getPropertyWithDefault("IceLocatorDiscovery.Address", "239.255.0.1");
}
else
{
address = properties.getPropertyWithDefault("IceLocatorDiscovery.Address", "ff15::1");
}
int port = properties.getPropertyAsIntWithDefault("IceLocatorDiscovery.Port", 4061);
string intf = properties.getProperty("IceLocatorDiscovery.Interface");
if (properties.getProperty("IceLocatorDiscovery.Reply.Endpoints").Length == 0)
{
System.Text.StringBuilder s = new System.Text.StringBuilder();
s.Append("udp");
if (intf.Length > 0)
{
s.Append(" -h \"");
s.Append(intf);
s.Append("\"");
}
properties.setProperty("IceLocatorDiscovery.Reply.Endpoints", s.ToString());
}
if (properties.getProperty("IceLocatorDiscovery.Locator.Endpoints").Length == 0)
{
properties.setProperty("IceLocatorDiscovery.Locator.AdapterId", Guid.NewGuid().ToString());
}
_replyAdapter = _communicator.createObjectAdapter("IceLocatorDiscovery.Reply");
_locatorAdapter = _communicator.createObjectAdapter("IceLocatorDiscovery.Locator");
// We don't want those adapters to be registered with the locator so clear their locator.
_replyAdapter.setLocator(null);
_locatorAdapter.setLocator(null);
string lookupEndpoints = properties.getProperty("IceLocatorDiscovery.Lookup");
if (lookupEndpoints.Length == 0)
{
System.Text.StringBuilder s = new System.Text.StringBuilder();
s.Append("udp -h \"");
s.Append(address);
s.Append("\" -p ");
s.Append(port);
if (intf.Length > 0)
{
s.Append(" --interface \"");
s.Append(intf);
s.Append("\"");
}
lookupEndpoints = s.ToString();
}
Ice.ObjectPrx lookupPrx = _communicator.stringToProxy("IceLocatorDiscovery/Lookup -d:" + lookupEndpoints);
lookupPrx = lookupPrx.ice_collocationOptimized(false); // No colloc optimization for the multicast proxy!
try
{
lookupPrx.ice_getConnection(); // Ensure we can establish a connection to the multicast proxy
}
catch (Ice.LocalException ex)
{
System.Text.StringBuilder s = new System.Text.StringBuilder();
s.Append("IceLocatorDiscovery is unable to establish a multicast connection:\n");
s.Append("proxy = ");
s.Append(lookupPrx.ToString());
s.Append("\n");
s.Append(ex);
throw new Ice.PluginInitializationException(s.ToString());
}
Ice.LocatorPrx voidLo = Ice.LocatorPrxHelper.uncheckedCast(_locatorAdapter.addWithUUID(new VoidLocatorI()));
string instanceName = properties.getProperty("IceLocatorDiscovery.InstanceName");
Ice.Identity id = new Ice.Identity();
id.name = "Locator";
id.category = instanceName.Length > 0 ? instanceName : Guid.NewGuid().ToString();
LocatorI locator = new LocatorI(LookupPrxHelper.uncheckedCast(lookupPrx), properties, instanceName, voidLo);
_communicator.setDefaultLocator(Ice.LocatorPrxHelper.uncheckedCast(_locatorAdapter.addWithUUID(locator)));
Ice.ObjectPrx lookupReply = _replyAdapter.addWithUUID(new LookupReplyI(locator)).ice_datagram();
locator.setLookupReply(LookupReplyPrxHelper.uncheckedCast(lookupReply));
_replyAdapter.activate();
_locatorAdapter.activate();
}
public override bool Equals(object other)
{
Ice.Identity oi = (Ice.Identity)other;
return(oi.name == name && oi.category == category);
}
private Reference create(Ice.Identity ident,
string facet,
Reference.Mode mode,
bool secure,
Ice.ProtocolVersion protocol,
Ice.EncodingVersion encoding,
EndpointI[] endpoints,
string adapterId,
string propertyPrefix)
{
DefaultsAndOverrides defaultsAndOverrides = _instance.defaultsAndOverrides();
//
// Default local proxy options.
//
LocatorInfo locatorInfo = null;
if (_defaultLocator != null)
{
if (!((Ice.ObjectPrxHelperBase)_defaultLocator).iceReference().getEncoding().Equals(encoding))
{
locatorInfo = _instance.locatorManager().get(
(Ice.LocatorPrx)_defaultLocator.ice_encodingVersion(encoding));
}
else
{
locatorInfo = _instance.locatorManager().get(_defaultLocator);
}
}
RouterInfo routerInfo = _instance.routerManager().get(_defaultRouter);
bool collocOptimized = defaultsAndOverrides.defaultCollocationOptimization;
bool cacheConnection = true;
bool preferSecure = defaultsAndOverrides.defaultPreferSecure;
Ice.EndpointSelectionType endpointSelection = defaultsAndOverrides.defaultEndpointSelection;
int locatorCacheTimeout = defaultsAndOverrides.defaultLocatorCacheTimeout;
int invocationTimeout = defaultsAndOverrides.defaultInvocationTimeout;
Dictionary <string, string> context = null;
//
// Override the defaults with the proxy properties if a property prefix is defined.
//
if (propertyPrefix != null && propertyPrefix.Length > 0)
{
Ice.Properties properties = _instance.initializationData().properties;
//
// Warn about unknown properties.
//
if (properties.getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0)
{
checkForUnknownProperties(propertyPrefix);
}
string property;
property = propertyPrefix + ".Locator";
Ice.LocatorPrx locator = Ice.LocatorPrxHelper.uncheckedCast(_communicator.propertyToProxy(property));
if (locator != null)
{
if (!((Ice.ObjectPrxHelperBase)locator).iceReference().getEncoding().Equals(encoding))
{
locatorInfo = _instance.locatorManager().get(
(Ice.LocatorPrx)locator.ice_encodingVersion(encoding));
}
else
{
locatorInfo = _instance.locatorManager().get(locator);
}
}
property = propertyPrefix + ".Router";
Ice.RouterPrx router = Ice.RouterPrxHelper.uncheckedCast(_communicator.propertyToProxy(property));
if (router != null)
{
if (propertyPrefix.EndsWith(".Router", StringComparison.Ordinal))
{
string s = "`" + property + "=" + properties.getProperty(property) +
"': cannot set a router on a router; setting ignored";
_instance.initializationData().logger.warning(s);
}
else
{
routerInfo = _instance.routerManager().get(router);
}
}
property = propertyPrefix + ".CollocationOptimized";
collocOptimized = properties.getPropertyAsIntWithDefault(property, collocOptimized ? 1 : 0) > 0;
property = propertyPrefix + ".ConnectionCached";
cacheConnection = properties.getPropertyAsIntWithDefault(property, cacheConnection ? 1 : 0) > 0;
property = propertyPrefix + ".PreferSecure";
preferSecure = properties.getPropertyAsIntWithDefault(property, preferSecure ? 1 : 0) > 0;
property = propertyPrefix + ".EndpointSelection";
if (properties.getProperty(property).Length > 0)
{
string type = properties.getProperty(property);
if (type.Equals("Random"))
{
endpointSelection = Ice.EndpointSelectionType.Random;
}
else if (type.Equals("Ordered"))
{
endpointSelection = Ice.EndpointSelectionType.Ordered;
}
else
{
throw new Ice.EndpointSelectionTypeParseException("illegal value `" + type +
"'; expected `Random' or `Ordered'");
}
}
property = propertyPrefix + ".LocatorCacheTimeout";
string val = properties.getProperty(property);
if (val.Length > 0)
{
locatorCacheTimeout = properties.getPropertyAsIntWithDefault(property, locatorCacheTimeout);
if (locatorCacheTimeout < -1)
{
locatorCacheTimeout = -1;
StringBuilder msg = new StringBuilder("invalid value for ");
msg.Append(property);
msg.Append(" `");
msg.Append(properties.getProperty(property));
msg.Append("': defaulting to -1");
_instance.initializationData().logger.warning(msg.ToString());
}
}
property = propertyPrefix + ".InvocationTimeout";
val = properties.getProperty(property);
if (val.Length > 0)
{
invocationTimeout = properties.getPropertyAsIntWithDefault(property, invocationTimeout);
if (invocationTimeout < 1 && invocationTimeout != -1)
{
invocationTimeout = -1;
StringBuilder msg = new StringBuilder("invalid value for ");
msg.Append(property);
msg.Append(" `");
msg.Append(properties.getProperty(property));
msg.Append("': defaulting to -1");
_instance.initializationData().logger.warning(msg.ToString());
}
}
property = propertyPrefix + ".Context.";
Dictionary <string, string> contexts = properties.getPropertiesForPrefix(property);
if (contexts.Count != 0)
{
context = new Dictionary <string, string>();
foreach (KeyValuePair <string, string> e in contexts)
{
context.Add(e.Key.Substring(property.Length), e.Value);
}
}
}
//
// Create new reference
//
return(new RoutableReference(_instance,
_communicator,
ident,
facet,
mode,
secure,
protocol,
encoding,
endpoints,
adapterId,
locatorInfo,
routerInfo,
collocOptimized,
cacheConnection,
preferSecure,
endpointSelection,
locatorCacheTimeout,
invocationTimeout,
context));
}
public override bool response()
{
//
// NOTE: this method is called from ConnectionI.parseMessage
// with the connection locked. Therefore, it must not invoke
// any user callbacks.
//
Debug.Assert(proxy_.IsTwoway); // Can only be called for twoways.
if (childObserver_ != null)
{
childObserver_.reply(is_.size() - Protocol.headerSize - 4);
childObserver_.detach();
childObserver_ = null;
}
byte replyStatus;
try
{
replyStatus = is_.readByte();
switch (replyStatus)
{
case ReplyStatus.replyOK:
{
break;
}
case ReplyStatus.replyUserException:
{
if (observer_ != null)
{
observer_.userException();
}
break;
}
case ReplyStatus.replyObjectNotExist:
case ReplyStatus.replyFacetNotExist:
case ReplyStatus.replyOperationNotExist:
{
Ice.Identity ident = new Ice.Identity();
ident.ice_readMembers(is_);
//
// For compatibility with the old FacetPath.
//
string[] facetPath = is_.readStringSeq();
;
string facet;
if (facetPath.Length > 0)
{
if (facetPath.Length > 1)
{
throw new Ice.MarshalException();
}
facet = facetPath[0];
}
else
{
facet = "";
}
string operation = is_.readString();
Ice.RequestFailedException ex = null;
switch (replyStatus)
{
case ReplyStatus.replyObjectNotExist:
{
ex = new Ice.ObjectNotExistException();
break;
}
case ReplyStatus.replyFacetNotExist:
{
ex = new Ice.FacetNotExistException();
break;
}
case ReplyStatus.replyOperationNotExist:
{
ex = new Ice.OperationNotExistException();
break;
}
default:
{
Debug.Assert(false);
break;
}
}
ex.id = ident;
ex.facet = facet;
ex.operation = operation;
throw ex;
}
case ReplyStatus.replyUnknownException:
case ReplyStatus.replyUnknownLocalException:
case ReplyStatus.replyUnknownUserException:
{
string unknown = is_.readString();
Ice.UnknownException ex = null;
switch (replyStatus)
{
case ReplyStatus.replyUnknownException:
{
ex = new Ice.UnknownException();
break;
}
case ReplyStatus.replyUnknownLocalException:
{
ex = new Ice.UnknownLocalException();
break;
}
case ReplyStatus.replyUnknownUserException:
{
ex = new Ice.UnknownUserException();
break;
}
default:
{
Debug.Assert(false);
break;
}
}
ex.unknown = unknown;
throw ex;
}
default:
{
throw new Ice.UnknownReplyStatusException();
}
}
return(responseImpl(false, replyStatus == ReplyStatus.replyOK, true));
}
catch (Ice.Exception ex)
{
return(exception(ex));
}
}
public void addClient(Ice.Identity ident, _System.Collections.Generic.Dictionary<string, string> context__)
{
IceInternal.Outgoing og__ = handler__.getOutgoing("addClient", Ice.OperationMode.Normal, context__);
try
{
try
{
IceInternal.BasicStream os__ = og__.ostr();
if(ident == null)
{
Ice.Identity tmp__ = new Ice.Identity();
tmp__.write__(os__);
}
else
{
ident.write__(os__);
}
}
catch(Ice.LocalException ex__)
{
og__.abort(ex__);
}
bool ok__ = og__.invoke();
if(!og__.istr().isEmpty())
{
try
{
if(!ok__)
{
try
{
og__.throwUserException();
}
catch(Ice.UserException ex)
{
throw new Ice.UnknownUserException(ex.ice_name(), ex);
}
}
og__.istr().skipEmptyEncaps();
}
catch(Ice.LocalException ex__)
{
throw new IceInternal.LocalExceptionWrapper(ex__, false);
}
}
}
finally
{
handler__.reclaimOutgoing(og__);
}
}
public static void allTests(global::Test.TestHelper helper)
{
Ice.Communicator communicator = helper.communicator();
var output = helper.getWriter();
output.Write("testing communicator operations... ");
output.Flush();
{
//
// Test: Exercise addAdminFacet, findAdminFacet, removeAdminFacet with a typical configuration.
//
Ice.InitializationData init = new Ice.InitializationData();
init.properties = Ice.Util.createProperties();
init.properties.setProperty("Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
init.properties.setProperty("Ice.Admin.InstanceName", "Test");
Ice.Communicator com = Ice.Util.initialize(init);
testFacets(com, true);
com.destroy();
}
{
//
// Test: Verify that the operations work correctly in the presence of facet filters.
//
Ice.InitializationData init = new Ice.InitializationData();
init.properties = Ice.Util.createProperties();
init.properties.setProperty("Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
init.properties.setProperty("Ice.Admin.InstanceName", "Test");
init.properties.setProperty("Ice.Admin.Facets", "Properties");
Ice.Communicator com = Ice.Util.initialize(init);
testFacets(com, false);
com.destroy();
}
{
//
// Test: Verify that the operations work correctly with the Admin object disabled.
//
Ice.Communicator com = Ice.Util.initialize();
testFacets(com, false);
com.destroy();
}
{
//
// Test: Verify that the operations work correctly with Ice.Admin.Enabled=1
//
Ice.InitializationData init = new Ice.InitializationData();
init.properties = Ice.Util.createProperties();
init.properties.setProperty("Ice.Admin.Enabled", "1");
Ice.Communicator com = Ice.Util.initialize(init);
test(com.getAdmin() == null);
Ice.Identity id = Ice.Util.stringToIdentity("test-admin");
try
{
com.createAdmin(null, id);
test(false);
}
catch (Ice.InitializationException)
{
}
Ice.ObjectAdapter adapter = com.createObjectAdapter("");
test(com.createAdmin(adapter, id) != null);
test(com.getAdmin() != null);
testFacets(com, true);
com.destroy();
}
{
//
// Test: Verify that the operations work correctly when creation of the Admin object is delayed.
//
Ice.InitializationData init = new Ice.InitializationData();
init.properties = Ice.Util.createProperties();
init.properties.setProperty("Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
init.properties.setProperty("Ice.Admin.InstanceName", "Test");
init.properties.setProperty("Ice.Admin.DelayCreation", "1");
Ice.Communicator com = Ice.Util.initialize(init);
testFacets(com, true);
com.getAdmin();
testFacets(com, true);
com.destroy();
}
output.WriteLine("ok");
string @ref = "factory:" + helper.getTestEndpoint(0) + " -t 10000";
Test.RemoteCommunicatorFactoryPrx factory =
Test.RemoteCommunicatorFactoryPrxHelper.uncheckedCast(communicator.stringToProxy(@ref));
output.Write("testing process facet... ");
output.Flush();
{
//
// Test: Verify that Process::shutdown() operation shuts down the communicator.
//
Dictionary <string, string> props = new Dictionary <string, string>();
props.Add("Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
props.Add("Ice.Admin.InstanceName", "Test");
var com = factory.createCommunicator(props);
Ice.ObjectPrx obj = com.getAdmin();
Ice.ProcessPrx proc = Ice.ProcessPrxHelper.checkedCast(obj, "Process");
proc.shutdown();
com.waitForShutdown();
com.destroy();
}
output.WriteLine("ok");
output.Write("testing properties facet... ");
output.Flush();
{
Dictionary <string, string> props = new Dictionary <string, string>();
props.Add("Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
props.Add("Ice.Admin.InstanceName", "Test");
props.Add("Prop1", "1");
props.Add("Prop2", "2");
props.Add("Prop3", "3");
var com = factory.createCommunicator(props);
Ice.ObjectPrx obj = com.getAdmin();
Ice.PropertiesAdminPrx pa = Ice.PropertiesAdminPrxHelper.checkedCast(obj, "Properties");
//
// Test: PropertiesAdmin::getProperty()
//
test(pa.getProperty("Prop2").Equals("2"));
test(pa.getProperty("Bogus").Equals(""));
//
// Test: PropertiesAdmin::getProperties()
//
Dictionary <string, string> pd = pa.getPropertiesForPrefix("");
test(pd.Count == 5);
test(pd["Ice.Admin.Endpoints"].Equals("tcp -h 127.0.0.1"));
test(pd["Ice.Admin.InstanceName"].Equals("Test"));
test(pd["Prop1"].Equals("1"));
test(pd["Prop2"].Equals("2"));
test(pd["Prop3"].Equals("3"));
Dictionary <string, string> changes;
//
// Test: PropertiesAdmin::setProperties()
//
Dictionary <string, string> setProps = new Dictionary <string, string>();
setProps.Add("Prop1", "10"); // Changed
setProps.Add("Prop2", "20"); // Changed
setProps.Add("Prop3", ""); // Removed
setProps.Add("Prop4", "4"); // Added
setProps.Add("Prop5", "5"); // Added
pa.setProperties(setProps);
test(pa.getProperty("Prop1").Equals("10"));
test(pa.getProperty("Prop2").Equals("20"));
test(pa.getProperty("Prop3").Equals(""));
test(pa.getProperty("Prop4").Equals("4"));
test(pa.getProperty("Prop5").Equals("5"));
changes = com.getChanges();
test(changes.Count == 5);
test(changes["Prop1"].Equals("10"));
test(changes["Prop2"].Equals("20"));
test(changes["Prop3"].Equals(""));
test(changes["Prop4"].Equals("4"));
test(changes["Prop5"].Equals("5"));
pa.setProperties(setProps);
changes = com.getChanges();
test(changes.Count == 0);
com.destroy();
}
output.WriteLine("ok");
output.Write("testing logger facet... ");
output.Flush();
{
Dictionary <String, String> props = new Dictionary <String, String>();
props.Add("Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
props.Add("Ice.Admin.InstanceName", "Test");
props.Add("NullLogger", "1");
var com = factory.createCommunicator(props);
com.trace("testCat", "trace");
com.warning("warning");
com.error("error");
com.print("print");
Ice.ObjectPrx obj = com.getAdmin();
Ice.LoggerAdminPrx logger = Ice.LoggerAdminPrxHelper.checkedCast(obj, "Logger");
test(logger != null);
string prefix = null;
//
// Get all
//
Ice.LogMessage[] logMessages = logger.getLog(null, null, -1, out prefix);
test(logMessages.Length == 4);
test(prefix.Equals("NullLogger"));
test(logMessages[0].traceCategory.Equals("testCat") && logMessages[0].message.Equals("trace"));
test(logMessages[1].message.Equals("warning"));
test(logMessages[2].message.Equals("error"));
test(logMessages[3].message.Equals("print"));
//
// Get only errors and warnings
//
com.error("error2");
com.print("print2");
com.trace("testCat", "trace2");
com.warning("warning2");
Ice.LogMessageType[] messageTypes =
{
Ice.LogMessageType.ErrorMessage,
Ice.LogMessageType.WarningMessage
};
logMessages = logger.getLog(messageTypes, null, -1, out prefix);
test(logMessages.Length == 4);
test(prefix.Equals("NullLogger"));
foreach (var msg in logMessages)
{
test(msg.type == Ice.LogMessageType.ErrorMessage ||
msg.type == Ice.LogMessageType.WarningMessage);
}
//
// Get only errors and traces with Cat = "testCat"
//
com.trace("testCat2", "A");
com.trace("testCat", "trace3");
com.trace("testCat2", "B");
messageTypes = new Ice.LogMessageType[] {
Ice.LogMessageType.ErrorMessage,
Ice.LogMessageType.TraceMessage
};
string[] categories = { "testCat" };
logMessages = logger.getLog(messageTypes, categories, -1, out prefix);
test(logMessages.Length == 5);
test(prefix.Equals("NullLogger"));
foreach (var msg in logMessages)
{
test(msg.type == Ice.LogMessageType.ErrorMessage ||
(msg.type == Ice.LogMessageType.TraceMessage && msg.traceCategory.Equals("testCat")));
}
//
// Same, but limited to last 2 messages(trace3 + error3)
//
com.error("error3");
logMessages = logger.getLog(messageTypes, categories, 2, out prefix);
test(logMessages.Length == 2);
test(prefix.Equals("NullLogger"));
test(logMessages[0].message.Equals("trace3"));
test(logMessages[1].message.Equals("error3"));
//
// Now, test RemoteLogger
//
Ice.ObjectAdapter adapter =
communicator.createObjectAdapterWithEndpoints("RemoteLoggerAdapter", "tcp -h localhost");
RemoteLoggerI remoteLogger = new RemoteLoggerI();
Ice.RemoteLoggerPrx myProxy =
Ice.RemoteLoggerPrxHelper.uncheckedCast(adapter.addWithUUID(remoteLogger));
adapter.activate();
//
// No filtering
//
logMessages = logger.getLog(null, null, -1, out prefix);
remoteLogger.checkNextInit(prefix, logMessages);
logger.attachRemoteLogger(myProxy, null, null, -1);
remoteLogger.wait(1);
remoteLogger.checkNextLog(Ice.LogMessageType.TraceMessage, "rtrace", "testCat");
remoteLogger.checkNextLog(Ice.LogMessageType.WarningMessage, "rwarning", "");
remoteLogger.checkNextLog(Ice.LogMessageType.ErrorMessage, "rerror", "");
remoteLogger.checkNextLog(Ice.LogMessageType.PrintMessage, "rprint", "");
com.trace("testCat", "rtrace");
com.warning("rwarning");
com.error("rerror");
com.print("rprint");
remoteLogger.wait(4);
test(logger.detachRemoteLogger(myProxy));
test(!logger.detachRemoteLogger(myProxy));
//
// Use Error + Trace with "traceCat" filter with 4 limit
//
logMessages = logger.getLog(messageTypes, categories, 4, out prefix);
test(logMessages.Length == 4);
remoteLogger.checkNextInit(prefix, logMessages);
logger.attachRemoteLogger(myProxy, messageTypes, categories, 4);
remoteLogger.wait(1);
remoteLogger.checkNextLog(Ice.LogMessageType.TraceMessage, "rtrace2", "testCat");
remoteLogger.checkNextLog(Ice.LogMessageType.ErrorMessage, "rerror2", "");
com.warning("rwarning2");
com.trace("testCat", "rtrace2");
com.warning("rwarning3");
com.error("rerror2");
com.print("rprint2");
remoteLogger.wait(2);
//
// Attempt reconnection with slightly different proxy
//
try
{
logger.attachRemoteLogger(Ice.RemoteLoggerPrxHelper.uncheckedCast(myProxy.ice_oneway()),
messageTypes, categories, 4);
test(false);
}
catch (Ice.RemoteLoggerAlreadyAttachedException)
{
// expected
}
com.destroy();
}
output.WriteLine("ok");
output.Write("testing custom facet... ");
output.Flush();
{
//
// Test: Verify that the custom facet is present.
//
Dictionary <string, string> props = new Dictionary <string, string>();
props.Add("Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
props.Add("Ice.Admin.InstanceName", "Test");
var com = factory.createCommunicator(props);
Ice.ObjectPrx obj = com.getAdmin();
var tf = Test.TestFacetPrxHelper.checkedCast(obj, "TestFacet");
tf.op();
com.destroy();
}
output.WriteLine("ok");
output.Write("testing facet filtering... ");
output.Flush();
{
//
// Test: Set Ice.Admin.Facets to expose only the Properties facet,
// meaning no other facet is available.
//
Dictionary <string, string> props = new Dictionary <string, string>();
props.Add("Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
props.Add("Ice.Admin.InstanceName", "Test");
props.Add("Ice.Admin.Facets", "Properties");
var com = factory.createCommunicator(props);
Ice.ObjectPrx obj = com.getAdmin();
Ice.ProcessPrx proc = Ice.ProcessPrxHelper.checkedCast(obj, "Process");
test(proc == null);
var tf = Test.TestFacetPrxHelper.checkedCast(obj, "TestFacet");
test(tf == null);
com.destroy();
}
{
//
// Test: Set Ice.Admin.Facets to expose only the Process facet,
// meaning no other facet is available.
//
Dictionary <string, string> props = new Dictionary <string, string>();
props.Add("Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
props.Add("Ice.Admin.InstanceName", "Test");
props.Add("Ice.Admin.Facets", "Process");
var com = factory.createCommunicator(props);
Ice.ObjectPrx obj = com.getAdmin();
Ice.PropertiesAdminPrx pa = Ice.PropertiesAdminPrxHelper.checkedCast(obj, "Properties");
test(pa == null);
var tf = Test.TestFacetPrxHelper.checkedCast(obj, "TestFacet");
test(tf == null);
com.destroy();
}
{
//
// Test: Set Ice.Admin.Facets to expose only the TestFacet facet,
// meaning no other facet is available.
//
Dictionary <string, string> props = new Dictionary <string, string>();
props.Add("Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
props.Add("Ice.Admin.InstanceName", "Test");
props.Add("Ice.Admin.Facets", "TestFacet");
var com = factory.createCommunicator(props);
Ice.ObjectPrx obj = com.getAdmin();
Ice.PropertiesAdminPrx pa = Ice.PropertiesAdminPrxHelper.checkedCast(obj, "Properties");
test(pa == null);
Ice.ProcessPrx proc = Ice.ProcessPrxHelper.checkedCast(obj, "Process");
test(proc == null);
com.destroy();
}
{
//
// Test: Set Ice.Admin.Facets to expose two facets. Use whitespace to separate the
// facet names.
//
Dictionary <string, string> props = new Dictionary <string, string>();
props.Add("Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
props.Add("Ice.Admin.InstanceName", "Test");
props.Add("Ice.Admin.Facets", "Properties TestFacet");
var com = factory.createCommunicator(props);
Ice.ObjectPrx obj = com.getAdmin();
Ice.PropertiesAdminPrx pa = Ice.PropertiesAdminPrxHelper.checkedCast(obj, "Properties");
test(pa.getProperty("Ice.Admin.InstanceName").Equals("Test"));
var tf = Test.TestFacetPrxHelper.checkedCast(obj, "TestFacet");
tf.op();
Ice.ProcessPrx proc = Ice.ProcessPrxHelper.checkedCast(obj, "Process");
test(proc == null);
com.destroy();
}
{
//
// Test: Set Ice.Admin.Facets to expose two facets. Use a comma to separate the
// facet names.
//
Dictionary <string, string> props = new Dictionary <string, string>();
props.Add("Ice.Admin.Endpoints", "tcp -h 127.0.0.1");
props.Add("Ice.Admin.InstanceName", "Test");
props.Add("Ice.Admin.Facets", "TestFacet, Process");
var com = factory.createCommunicator(props);
Ice.ObjectPrx obj = com.getAdmin();
Ice.PropertiesAdminPrx pa = Ice.PropertiesAdminPrxHelper.checkedCast(obj, "Properties");
test(pa == null);
var tf = Test.TestFacetPrxHelper.checkedCast(obj, "TestFacet");
tf.op();
Ice.ProcessPrx proc = Ice.ProcessPrxHelper.checkedCast(obj, "Process");
proc.shutdown();
com.waitForShutdown();
com.destroy();
}
output.WriteLine("ok");
factory.shutdown();
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="T:Ferda.Modules.BoxModuleI"/> class.
/// </summary>
/// <param name="boxInfo">The box info.</param>
/// <param name="myIdentity">My identity.</param>
/// <param name="myFactoryProxy">My factory proxy.</param>
/// <param name="manager">The manager.</param>
/// <param name="adapter">The adapter.</param>
/// <param name="localePrefs">The localization preferences.</param>
public BoxModuleI(IBoxInfo boxInfo,
Ice.Identity myIdentity,
BoxModuleFactoryPrx myFactoryProxy,
Ferda.ModulesManager.ManagersEnginePrx manager,
Ice.ObjectAdapter adapter,
string[] localePrefs)
{
System.Diagnostics.Debug.WriteLine("BoxModuleI Constructor (entering): " + boxInfo.Identifier);
// initializes inner fields by specified parameters
this.boxInfo = boxInfo;
this.iceIdentity = myIdentity;
this.stringIceIdentity = Ice.Util.identityToString(IceIdentity);
this.myFactoryProxy = myFactoryProxy;
this.manager = manager;
this.adapter = adapter;
this.localePrefs = localePrefs;
// add the new box module to the specified adapter
adapter.add(this, this.iceIdentity);
// get my proxy
this.myProxy = BoxModulePrxHelper.uncheckedCast(adapter.createProxy(myIdentity));
// initializes box module`s functions object
this.boxInfo.CreateFunctions(this, out this.functionsIceObj, out this.functionsIObj);
this.functionsIObj.setBoxModuleInfo(this, this.boxInfo);
this.functionsObjPrx = Ice.ObjectPrxHelper.uncheckedCast(adapter.addWithUUID(this.functionsIceObj));
// initializes properties
this.properties = new Dictionary<string, PropertyValue>();
foreach (string propertyName in boxInfo.GetPropertiesNames())
{
if (!boxInfo.IsPropertyReadOnly(propertyName))
{
this.setProperty(propertyName, boxInfo.GetPropertyDefaultValue(propertyName));
}
}
// initializes sockets (connections and functions)
this.connections = new Dictionary<string, Dictionary<string, BoxModulePrx>>();
foreach (string socketName in boxInfo.GetSocketNames())
{
connections[socketName] = new Dictionary<string, BoxModulePrx>();
}
System.Diagnostics.Debug.WriteLine("BoxModuleI Constructor (leaving): " + this.boxInfo.Identifier);
}
connectImpl(ConnectStrategy factory)
{
Debug.Assert(!_destroy);
try
{
_communicator = Ice.Util.initialize(_initData);
}
catch (Ice.LocalException ex)
{
_destroy = true;
new Thread(
new ThreadStart(() =>
{
dispatchCallback(() =>
{
_callback.connectFailed(this, ex);
},
null);
})).Start();
return;
}
Ice.RouterFinderPrx finder = Ice.RouterFinderPrxHelper.uncheckedCast(_communicator.stringToProxy(_finderStr));
new Thread(new ThreadStart(() =>
{
if (_communicator.getDefaultRouter() == null)
{
try
{
_communicator.setDefaultRouter(finder.getRouter());
}
catch (Ice.CommunicatorDestroyedException ex)
{
dispatchCallback(() =>
{
_callback.connectFailed(this, ex);
}, null);
return;
}
catch (Exception)
{
//
// In case of error getting router identity from RouterFinder use default identity.
//
Ice.Identity ident = new Ice.Identity("router", "Glacier2");
_communicator.setDefaultRouter(Ice.RouterPrxHelper.uncheckedCast(finder.ice_identity(ident)));
}
}
try
{
dispatchCallbackAndWait(() =>
{
_callback.createdCommunicator(this);
});
RouterPrx routerPrx = RouterPrxHelper.uncheckedCast(_communicator.getDefaultRouter());
SessionPrx session = factory(routerPrx);
connected(routerPrx, session);
}
catch (Exception ex)
{
_communicator.destroy();
dispatchCallback(() =>
{
_callback.connectFailed(this, ex);
}, null);
}
})).Start();
}
protected Reference(Instance instance,
Ice.Communicator communicator,
Ice.Identity identity,
string facet,
Mode mode,
bool secure)
{
//
// Validate string arguments.
//
Debug.Assert(identity.name != null);
Debug.Assert(identity.category != null);
Debug.Assert(facet != null);
instance_ = instance;
communicator_ = communicator;
mode_ = mode;
identity_ = identity;
context_ = _emptyContext;
facet_ = facet;
secure_ = secure;
hashInitialized_ = false;
overrideCompress_ = false;
compress_ = false;
}
public int run()
{
try
{
Ice.Properties properties = _communicator.getProperties();
//
// Create an object adapter. Services probably should NOT share
// this object adapter, as the endpoint(s) for this object adapter
// will most likely need to be firewalled for security reasons.
//
Ice.ObjectAdapter adapter = null;
if (properties.getProperty("IceBox.ServiceManager.Endpoints").Length != 0)
{
adapter = _communicator.createObjectAdapter("IceBox.ServiceManager");
Ice.Identity identity = new Ice.Identity();
identity.category = properties.getPropertyWithDefault("IceBox.InstanceName", "IceBox");
identity.name = "ServiceManager";
adapter.add(this, identity);
}
//
// Parse the property set with the prefix "IceBox.Service.". These
// properties should have the following format:
//
// IceBox.Service.Foo=<assembly>:Package.Foo [args]
//
// We parse the service properties specified in IceBox.LoadOrder
// first, then the ones from remaining services.
//
string prefix = "IceBox.Service.";
Dictionary <string, string> services = properties.getPropertiesForPrefix(prefix);
if (services.Count == 0)
{
throw new FailureException("ServiceManager: configuration must include at least one IceBox service");
}
string[] loadOrder = properties.getPropertyAsList("IceBox.LoadOrder");
List <StartServiceInfo> servicesInfo = new List <StartServiceInfo>();
for (int i = 0; i < loadOrder.Length; ++i)
{
if (loadOrder[i].Length > 0)
{
string key = prefix + loadOrder[i];
string value = services[key];
if (value == null)
{
FailureException ex = new FailureException();
ex.reason = "ServiceManager: no service definition for `" + loadOrder[i] + "'";
throw ex;
}
servicesInfo.Add(new StartServiceInfo(loadOrder[i], value, _argv));
services.Remove(key);
}
}
foreach (KeyValuePair <string, string> entry in services)
{
string name = entry.Key.Substring(prefix.Length);
string value = entry.Value;
servicesInfo.Add(new StartServiceInfo(name, value, _argv));
}
//
// Check if some services are using the shared communicator in which
// case we create the shared communicator now with a property set that
// is the union of all the service properties (from services that use
// the shared communicator).
//
if (properties.getPropertiesForPrefix("IceBox.UseSharedCommunicator.").Count > 0)
{
Ice.InitializationData initData = new Ice.InitializationData();
initData.properties = createServiceProperties("SharedCommunicator");
foreach (StartServiceInfo service in servicesInfo)
{
if (properties.getPropertyAsInt("IceBox.UseSharedCommunicator." + service.name) <= 0)
{
continue;
}
//
// Load the service properties using the shared communicator properties as
// the default properties.
//
Ice.Properties svcProperties = Ice.Util.createProperties(ref service.args, initData.properties);
//
// Remove properties from the shared property set that a service explicitly clears.
//
Dictionary <string, string> allProps = initData.properties.getPropertiesForPrefix("");
foreach (string key in allProps.Keys)
{
if (svcProperties.getProperty(key).Length == 0)
{
initData.properties.setProperty(key, "");
}
}
//
// Add the service properties to the shared communicator properties.
//
foreach (KeyValuePair <string, string> entry in svcProperties.getPropertiesForPrefix(""))
{
initData.properties.setProperty(entry.Key, entry.Value);
}
//
// Parse <service>.* command line options (the Ice command line options
// were parsed by the call to createProperties above).
//
service.args = initData.properties.parseCommandLineOptions(service.name, service.args);
}
string facetNamePrefix = "IceBox.SharedCommunicator.";
bool addFacets = configureAdmin(initData.properties, facetNamePrefix);
_sharedCommunicator = Ice.Util.initialize(initData);
if (addFacets)
{
// Add all facets created on shared communicator to the IceBox communicator
// but renamed <prefix>.<facet-name>, except for the Process facet which is
// never added.
foreach (KeyValuePair <string, Ice.Object> p in _sharedCommunicator.findAllAdminFacets())
{
if (!p.Key.Equals("Process"))
{
_communicator.addAdminFacet(p.Value, facetNamePrefix + p.Key);
}
}
}
}
foreach (StartServiceInfo s in servicesInfo)
{
startService(s.name, s.entryPoint, s.args);
}
//
// We may want to notify external scripts that the services
// have started. This is done by defining the property:
//
// PrintServicesReady=bundleName
//
// Where bundleName is whatever you choose to call this set of
// services. It will be echoed back as "bundleName ready".
//
// This must be done after start() has been invoked on the
// services.
//
string bundleName = properties.getProperty("IceBox.PrintServicesReady");
if (bundleName.Length > 0)
{
Console.Out.WriteLine(bundleName + " ready");
}
//
// Register "this" as a facet to the Admin object and create Admin object
//
try
{
_communicator.addAdminFacet(this, "IceBox.ServiceManager");
_communicator.getAdmin();
}
catch (Ice.ObjectAdapterDeactivatedException)
{
//
// Expected if the communicator has been shutdown.
//
}
//
// Start request dispatching after we've started the services.
//
if (adapter != null)
{
try
{
adapter.activate();
}
catch (Ice.ObjectAdapterDeactivatedException)
{
//
// Expected if the communicator has been shutdown.
//
}
}
_communicator.waitForShutdown();
}
catch (FailureException ex)
{
_logger.error(ex.ToString());
return(1);
}
catch (Exception ex)
{
_logger.error("ServiceManager: caught exception:\n" + ex.ToString());
return(1);
}
finally
{
//
// Invoke stop() on the services.
//
stopAll();
}
return(0);
}
public void refreshPublishedEndpoints()
{
LocatorInfo locatorInfo = null;
bool registerProcess = false;
List<EndpointI> oldPublishedEndpoints;
lock(this)
{
checkForDeactivation();
oldPublishedEndpoints = _publishedEndpoints;
_publishedEndpoints = parsePublishedEndpoints();
locatorInfo = _locatorInfo;
if(!_noConfig)
{
registerProcess =
instance_.initializationData().properties.getPropertyAsInt(_name + ".RegisterProcess") > 0;
}
}
try
{
Ice.Identity dummy = new Ice.Identity();
dummy.name = "dummy";
updateLocatorRegistry(locatorInfo, createDirectProxy(dummy), registerProcess);
}
catch(Ice.LocalException)
{
lock(this)
{
//
// Restore the old published endpoints.
//
_publishedEndpoints = oldPublishedEndpoints;
throw;
}
}
}
internal static void batchOneways(global::Test.TestHelper helper, Test.MyClassPrx p)
{
byte[] bs1 = new byte[10 * 1024];
Test.MyClassPrx batch = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway());
batch.ice_flushBatchRequests(); // Empty flush
p.opByteSOnewayCallCount(); // Reset the call count
for (int i = 0; i < 30; ++i)
{
try
{
batch.opByteSOneway(bs1);
}
catch (Ice.MemoryLimitException)
{
test(false);
}
}
int count = 0;
while (count < 27) // 3 * 9 requests auto-flushed.
{
count += p.opByteSOnewayCallCount();
System.Threading.Thread.Sleep(10);
}
if (batch.ice_getConnection() != null)
{
Test.MyClassPrx batch1 = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway());
Test.MyClassPrx batch2 = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway());
batch1.ice_ping();
batch2.ice_ping();
batch1.ice_flushBatchRequests();
batch1.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
batch1.ice_ping();
batch2.ice_ping();
batch1.ice_getConnection();
batch2.ice_getConnection();
batch1.ice_ping();
batch1.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait);
batch1.ice_ping();
batch2.ice_ping();
}
Ice.Identity identity = new Ice.Identity();
identity.name = "invalid";
Ice.ObjectPrx batch3 = batch.ice_identity(identity);
batch3.ice_ping();
batch3.ice_flushBatchRequests();
// Make sure that a bogus batch request doesn't cause troubles to other ones.
batch3.ice_ping();
batch.ice_ping();
batch.ice_flushBatchRequests();
batch.ice_ping();
if (batch.ice_getConnection() != null)
{
Ice.InitializationData initData = new Ice.InitializationData();
initData.properties = p.ice_getCommunicator().getProperties().ice_clone_();
BatchRequestInterceptorI interceptor = new BatchRequestInterceptorI();
initData.batchRequestInterceptor = interceptor.enqueue;
Ice.Communicator ic = helper.initialize(initData);
batch = Test.MyClassPrxHelper.uncheckedCast(ic.stringToProxy(p.ToString()).ice_batchOneway());
test(interceptor.count() == 0);
batch.ice_ping();
batch.ice_ping();
batch.ice_ping();
test(interceptor.count() == 0);
interceptor.setEnqueue(true);
batch.ice_ping();
batch.ice_ping();
batch.ice_ping();
test(interceptor.count() == 3);
batch.ice_flushBatchRequests();
batch.ice_ping();
test(interceptor.count() == 1);
batch.opByteSOneway(bs1);
test(interceptor.count() == 2);
batch.opByteSOneway(bs1);
test(interceptor.count() == 3);
batch.opByteSOneway(bs1); // This should trigger the flush
batch.ice_ping();
test(interceptor.count() == 2);
ic.destroy();
}
p.ice_ping();
bool supportsCompress = true;
try
{
supportsCompress = p.supportsCompress();
}
catch (Ice.OperationNotExistException)
{
}
if (supportsCompress && p.ice_getConnection() != null &&
p.ice_getCommunicator().getProperties().getProperty("Ice.Override.Compress").Equals(""))
{
Ice.ObjectPrx prx = p.ice_getConnection().createProxy(p.ice_getIdentity()).ice_batchOneway();
Test.MyClassPrx batchC1 = Test.MyClassPrxHelper.uncheckedCast(prx.ice_compress(false));
Test.MyClassPrx batchC2 = Test.MyClassPrxHelper.uncheckedCast(prx.ice_compress(true));
Test.MyClassPrx batchC3 = Test.MyClassPrxHelper.uncheckedCast(prx.ice_identity(identity));
batchC1.opByteSOneway(bs1);
batchC1.opByteSOneway(bs1);
batchC1.opByteSOneway(bs1);
batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.Yes);
batchC2.opByteSOneway(bs1);
batchC2.opByteSOneway(bs1);
batchC2.opByteSOneway(bs1);
batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.No);
batchC1.opByteSOneway(bs1);
batchC1.opByteSOneway(bs1);
batchC1.opByteSOneway(bs1);
batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.BasedOnProxy);
batchC1.opByteSOneway(bs1);
batchC2.opByteSOneway(bs1);
batchC1.opByteSOneway(bs1);
batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.BasedOnProxy);
batchC1.opByteSOneway(bs1);
batchC3.opByteSOneway(bs1);
batchC1.opByteSOneway(bs1);
batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.BasedOnProxy);
}
}
public Ice.ObjectPrx createAdmin(Ice.ObjectAdapter adminAdapter, Ice.Identity adminIdentity)
{
bool createAdapter = (adminAdapter == null);
lock(this)
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
if(adminIdentity == null || string.IsNullOrEmpty(adminIdentity.name))
{
throw new Ice.IllegalIdentityException(adminIdentity);
}
if(_adminAdapter != null)
{
throw new Ice.InitializationException("Admin already created");
}
if(!_adminEnabled)
{
throw new Ice.InitializationException("Admin is disabled");
}
if(createAdapter)
{
if(_initData.properties.getProperty("Ice.Admin.Endpoints").Length > 0)
{
adminAdapter = _objectAdapterFactory.createObjectAdapter("Ice.Admin", null);
}
else
{
throw new Ice.InitializationException("Ice.Admin.Endpoints is not set");
}
}
_adminIdentity = adminIdentity;
_adminAdapter = adminAdapter;
addAllAdminFacets();
}
if(createAdapter)
{
try
{
adminAdapter.activate();
}
catch(Ice.LocalException)
{
//
// We cleanup _adminAdapter, however this error is not recoverable
// (can't call again getAdmin() after fixing the problem)
// since all the facets (servants) in the adapter are lost
//
adminAdapter.destroy();
lock(this)
{
_adminAdapter = null;
}
throw;
}
}
setServerProcessProxy(adminAdapter, adminIdentity);
return adminAdapter.createProxy(adminIdentity);
}
findObjectById_async(Ice.AMD_Locator_findObjectById amdCB, Ice.Identity id, Ice.Current current)
{
amdCB.ice_response(null);
}
private string getRouterFinderStr()
{
Ice.Identity ident = new Ice.Identity("RouterFinder", "Ice");
return createProxyStr(ident);
}
getRouterFinderStr()
{
Ice.Identity ident = new Ice.Identity("RouterFinder", "Ice");
return(createProxyStr(ident));
}
connectImpl(ConnectStrategy factory)
{
Debug.Assert(!_destroy);
try
{
_communicator = Ice.Util.initialize(_initData);
}
catch(Ice.LocalException ex)
{
_destroy = true;
new Thread(
new ThreadStart(() =>
{
dispatchCallback(() =>
{
_callback.connectFailed(this, ex);
},
null);
})).Start();
return;
}
Ice.RouterFinderPrx finder = Ice.RouterFinderPrxHelper.uncheckedCast(_communicator.stringToProxy(_finderStr));
new Thread(new ThreadStart(() =>
{
if(_communicator.getDefaultRouter() == null)
{
try
{
_communicator.setDefaultRouter(finder.getRouter());
}
catch(Ice.CommunicatorDestroyedException ex)
{
dispatchCallback(() =>
{
_callback.connectFailed(this, ex);
}, null);
return;
}
catch(Exception)
{
//
// In case of error getting router identity from RouterFinder use default identity.
//
Ice.Identity ident = new Ice.Identity("router", "Glacier2");
_communicator.setDefaultRouter(Ice.RouterPrxHelper.uncheckedCast(finder.ice_identity(ident)));
}
}
try
{
dispatchCallbackAndWait(() =>
{
_callback.createdCommunicator(this);
});
Glacier2.RouterPrx routerPrx = Glacier2.RouterPrxHelper.uncheckedCast(_communicator.getDefaultRouter());
Glacier2.SessionPrx session = factory(routerPrx);
connected(routerPrx, session);
}
catch(Exception ex)
{
try
{
_communicator.destroy();
}
catch(Exception)
{
}
dispatchCallback(() =>
{
_callback.connectFailed(this, ex);
}, null);
}
})).Start();
}
public override void foundObjectById(Ice.Identity id, Ice.ObjectPrx proxy, Ice.Current c)
{
_lookup.foundObject(id, c.id.name, proxy);
}
public void proxyToStream(Ice.ObjectPrx proxy, BasicStream s)
{
if(proxy != null)
{
Ice.ObjectPrxHelperBase h = (Ice.ObjectPrxHelperBase)proxy;
Reference r = h.reference__();
r.getIdentity().write__(s);
r.streamWrite(s);
}
else
{
Ice.Identity ident = new Ice.Identity();
ident.name = "";
ident.category = "";
ident.write__(s);
}
}
public void invoke(ServantManager servantManager, Ice.InputStream stream)
{
_is = stream;
int start = _is.pos();
//
// Read the current.
//
var id = new Ice.Identity();
id.ice_readMembers(_is);
//
// For compatibility with the old FacetPath.
//
string[] facetPath = _is.ReadStringSeq();
string facet;
if (facetPath.Length > 0)
{
if (facetPath.Length > 1)
{
throw new Ice.MarshalException();
}
facet = facetPath[0];
}
else
{
facet = "";
}
string operation = _is.ReadString();
byte mode = _is.ReadByte();
Dictionary <string, string> context = new Dictionary <string, string>();
int sz = _is.ReadSize();
while (sz-- > 0)
{
string first = _is.ReadString();
string second = _is.ReadString();
context[first] = second;
}
_current = new Ice.Current(_adapter, id, facet, operation, (Ice.OperationMode)mode, context, _requestId, _connection);
Ice.Instrumentation.CommunicatorObserver?obsv = _communicator.initializationData().observer;
if (obsv != null)
{
// Read the encapsulation size.
int size = _is.ReadInt();
_is.pos(_is.pos() - 4);
_observer = obsv.getDispatchObserver(_current, _is.pos() - start + size);
if (_observer != null)
{
_observer.attach();
}
}
//
// Don't put the code above into the try block below. Exceptions
// in the code above are considered fatal, and must propagate to
// the caller of this operation.
//
if (servantManager != null)
{
_servant = servantManager.findServant(_current.Id, _current.Facet);
if (_servant == null)
{
_locator = servantManager.findServantLocator(_current.Id.category);
if (_locator == null && _current.Id.category.Length > 0)
{
_locator = servantManager.findServantLocator("");
}
if (_locator != null)
{
Debug.Assert(_locator != null);
try
{
_servant = _locator.locate(_current, out _cookie);
}
catch (Exception ex)
{
skipReadParams(); // Required for batch requests.
handleException(ex, false);
return;
}
}
}
}
if (_servant == null)
{
try
{
if (servantManager != null && servantManager.hasServant(_current.Id))
{
throw new Ice.FacetNotExistException(_current.Id, _current.Facet, _current.Operation);
}
else
{
throw new Ice.ObjectNotExistException(_current.Id, _current.Facet, _current.Operation);
}
}
catch (Exception ex)
{
skipReadParams(); // Required for batch requests
handleException(ex, false);
return;
}
}
try
{
Task <Ice.OutputStream>?task = _servant(this, _current);
if (task == null)
{
completed(null, false);
}
else
{
if (task.IsCompleted)
{
_os = task.GetAwaiter().GetResult(); // Get the response
completed(null, false);
}
else
{
task.ContinueWith((Task <Ice.OutputStream> t) =>
{
try
{
_os = t.GetAwaiter().GetResult();
completed(null, true); // true = asynchronous
}
catch (Exception ex)
{
completed(ex, true); // true = asynchronous
}
},
CancellationToken.None,
TaskContinuationOptions.ExecuteSynchronously,
scheduler: TaskScheduler.Current);
}
}
}
catch (Exception ex)
{
completed(ex, false);
}
}
public void refreshPublishedEndpoints()
{
LocatorInfo locatorInfo = null;
List<EndpointI> oldPublishedEndpoints;
lock(this)
{
checkForDeactivation();
oldPublishedEndpoints = _publishedEndpoints;
_publishedEndpoints = parsePublishedEndpoints();
locatorInfo = _locatorInfo;
}
try
{
Ice.Identity dummy = new Ice.Identity();
dummy.name = "dummy";
updateLocatorRegistry(locatorInfo, createDirectProxy(dummy));
}
catch(Ice.LocalException)
{
lock(this)
{
//
// Restore the old published endpoints.
//
_publishedEndpoints = oldPublishedEndpoints;
throw;
}
}
}
public string identityToString(Ice.Identity ident)
{
return(instance_.identityToString(ident));
}
getAdmin()
{
Ice.ObjectAdapter adminAdapter;
Ice.Identity adminIdentity;
lock(this)
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
if(_adminAdapter != null)
{
return _adminAdapter.createProxy(_adminIdentity);
}
else if(_adminEnabled)
{
if(_initData.properties.getProperty("Ice.Admin.Endpoints").Length > 0)
{
adminAdapter = _objectAdapterFactory.createObjectAdapter("Ice.Admin", null);
}
else
{
return null;
}
adminIdentity = new Ice.Identity("admin", _initData.properties.getProperty("Ice.Admin.InstanceName"));
if(adminIdentity.category.Length == 0)
{
adminIdentity.category = System.Guid.NewGuid().ToString();
}
_adminIdentity = adminIdentity;
_adminAdapter = adminAdapter;
addAllAdminFacets();
// continue below outside synchronization
}
else
{
return null;
}
}
try
{
adminAdapter.activate();
}
catch(Ice.LocalException)
{
//
// We cleanup _adminAdapter, however this error is not recoverable
// (can't call again getAdmin() after fixing the problem)
// since all the facets (servants) in the adapter are lost
//
adminAdapter.destroy();
lock(this)
{
_adminAdapter = null;
}
throw;
}
setServerProcessProxy(adminAdapter, adminIdentity);
return adminAdapter.createProxy(adminIdentity);
}
findObjectByIdAsync(Ice.Identity id, Ice.Current current)
{
return(_lookup.findObject(id));
}
getAdmin()
{
Ice.ObjectAdapter adapter = null;
string serverId = null;
Ice.LocatorPrx defaultLocator = null;
lock(this)
{
if(_state == StateDestroyed)
{
throw new Ice.CommunicatorDestroyedException();
}
string adminOA = "Ice.Admin";
if(_adminAdapter != null)
{
return _adminAdapter.createProxy(_adminIdentity);
}
else if(_initData.properties.getProperty(adminOA + ".Endpoints").Length == 0)
{
return null;
}
else
{
serverId = _initData.properties.getProperty("Ice.Admin.ServerId");
string instanceName = _initData.properties.getProperty("Ice.Admin.InstanceName");
defaultLocator = _referenceFactory.getDefaultLocator();
if((defaultLocator != null && serverId.Length > 0) || instanceName.Length > 0)
{
if(_adminIdentity == null)
{
if(instanceName.Length == 0)
{
instanceName = System.Guid.NewGuid().ToString();
}
_adminIdentity = new Ice.Identity("admin", instanceName);
//
// Afterwards, _adminIdentity is read-only
//
}
//
// Create OA
//
_adminAdapter = _objectAdapterFactory.createObjectAdapter(adminOA, null);
//
// Add all facets to OA
//
Dictionary<string, Ice.Object> filteredFacets = new Dictionary<string, Ice.Object>();
foreach(KeyValuePair<string, Ice.Object> entry in _adminFacets)
{
if(_adminFacetFilter.Count == 0 || _adminFacetFilter.Contains(entry.Key))
{
_adminAdapter.addFacet(entry.Value, _adminIdentity, entry.Key);
}
else
{
filteredFacets.Add(entry.Key, entry.Value);
}
}
_adminFacets = filteredFacets;
adapter = _adminAdapter;
}
}
}
if(adapter == null)
{
return null;
}
else
{
try
{
adapter.activate();
}
catch(Ice.LocalException)
{
//
// We cleanup _adminAdapter, however this error is not recoverable
// (can't call again getAdmin() after fixing the problem)
// since all the facets (servants) in the adapter are lost
//
adapter.destroy();
lock(this)
{
_adminAdapter = null;
}
throw;
}
Ice.ObjectPrx admin = adapter.createProxy(_adminIdentity);
if(defaultLocator != null && serverId.Length > 0)
{
Ice.ProcessPrx process = Ice.ProcessPrxHelper.uncheckedCast(admin.ice_facet("Process"));
try
{
//
// Note that as soon as the process proxy is registered, the communicator might be
// shutdown by a remote client and admin facets might start receiving calls.
//
defaultLocator.getRegistry().setServerProcessProxy(serverId, process);
}
catch(Ice.ServerNotFoundException)
{
if(_traceLevels.location >= 1)
{
System.Text.StringBuilder s = new System.Text.StringBuilder();
s.Append("couldn't register server `" + serverId + "' with the locator registry:\n");
s.Append("the server is not known to the locator registry");
_initData.logger.trace(_traceLevels.locationCat, s.ToString());
}
throw new Ice.InitializationException("Locator knows nothing about server '" + serverId +
"'");
}
catch(Ice.LocalException ex)
{
if(_traceLevels.location >= 1)
{
System.Text.StringBuilder s = new System.Text.StringBuilder();
s.Append("couldn't register server `" + serverId + "' with the locator registry:\n" + ex);
_initData.logger.trace(_traceLevels.locationCat, s.ToString());
}
throw; // TODO: Shall we raise a special exception instead of a non obvious local exception?
}
if(_traceLevels.location >= 1)
{
System.Text.StringBuilder s = new System.Text.StringBuilder();
s.Append("registered server `" + serverId + "' with the locator registry");
_initData.logger.trace(_traceLevels.locationCat, s.ToString());
}
}
return admin;
}
}
private Ice.AsyncResult<Chat.Callback_Lobby_Join> begin_Join(string nick, string topic, Ice.Identity listenerIdentity, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__Join_name);
IceInternal.TwowayOutgoingAsync<Chat.Callback_Lobby_Join> result__ = new IceInternal.TwowayOutgoingAsync<Chat.Callback_Lobby_Join>(this, __Join_name, Join_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__Join_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeString(nick);
os__.writeString(topic);
if(listenerIdentity == null)
{
Ice.Identity tmp__ = new Ice.Identity();
tmp__.write__(os__);
}
else
{
listenerIdentity.write__(os__);
}
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}