/// <summary>Creates a SessionFactory object.</summary>
/// <param name="callback">The callback for notifications about session establishment.</param>
/// <param name="properties">Optional properties used for communicator initialization.</param>
/// <param name="logger">Optional logger used for communicator initialization.</param>
/// <param name="observer">Optional communicator observer used for communicator initialization.</param>
public SessionFactoryHelper(ISessionCallback callback,
Dictionary <string, string> properties,
ILogger?logger = null,
ICommunicatorObserver?observer = null)
{
_callback = callback;
_properties = properties;
_logger = logger;
_observer = observer;
SetDefaultProperties();
}
public static async Task <int> Main(string[] args)
{
ICommunicatorObserver? observer = Instrumentation.GetObserver();
Dictionary <string, string> properties = CreateTestProperties(ref args);
properties["Ice.Warn.Dispatch"] = "0";
// This test kills connections, so we don't want warnings.
properties["Ice.Warn.Connections"] = "0";
await using var communicator = CreateCommunicator(properties, observer: observer);
return(await RunTestAsync <Collocated>(communicator, args));
}
public override async Task RunAsync(string[] args)
{
ICommunicatorObserver? observer = Instrumentation.GetObserver();
Dictionary <string, string>?properties = CreateTestProperties(ref args);
properties["Ice.Warn.Dispatch"] = "0";
// This test kills connections, so we don't want warnings.
properties["Ice.Warn.Connections"] = "0";
await using Communicator communicator = Initialize(properties, observer: observer);
communicator.SetProperty("TestAdapter.Endpoints", GetTestEndpoint(0));
communicator.CreateObjectAdapter("TestAdapter").Add("retry", new Retry());
await AllTests.Run(this, communicator, true).ShutdownAsync();
}
public static IInvocationObserver?get(Ice.Communicator communicator, string op)
{
ICommunicatorObserver?obsv = communicator.Observer;
if (obsv != null)
{
IInvocationObserver?observer = obsv.GetInvocationObserver(null, op, _emptyContext);
if (observer != null)
{
observer.Attach();
}
return(observer);
}
return(null);
}
/// <summary>
/// Creates a Glacier2 session.
/// </summary>
/// <param name="callback">The callback for notifications about session
/// establishment.</param>
/// <param name="properties">Optional properties used for communicator initialization.</param>
/// <param name="logger">Optional logger used for communicator initialization.</param>
/// <param name="observer">Optional communicator observer used for communicator initialization.</param>
/// <param name="typeIdNamespaces">Optional list of TypeId namespaces used for communicator initialization.
/// The default is Ice.TypeId.</param>
/// <param name="finderStr">The stringified Ice.RouterFinder proxy.</param>
/// <param name="useCallbacks">True if the session should create an object adapter for receiving callbacks.</param>
internal SessionHelper(ISessionCallback callback,
string finderStr,
bool useCallbacks,
Dictionary <string, string> properties,
ILogger?logger = null,
ICommunicatorObserver?observer = null,
string[]?typeIdNamespaces = null)
{
_callback = callback;
_finderStr = finderStr;
_useCallbacks = useCallbacks;
_properties = properties;
_logger = logger;
_observer = observer;
_typeIdNamespaces = typeIdNamespaces;
}
/// <summary>Creates a SessionFactory object.</summary>
/// <param name="callback">The callback for notifications about session establishment.</param>
/// <param name="properties">Optional properties used for communicator initialization.</param>
/// <param name="logger">Optional logger used for communicator initialization.</param>
/// <param name="observer">Optional communicator observer used for communicator initialization.</param>
/// <param name="tlsClientOptions">TLS transport client side configuration options.</param>
/// <param name="tlsServerOptions">TLS transport server side configuration options.</param>
public SessionFactoryHelper(
ISessionCallback callback,
Dictionary <string, string> properties,
ILogger?logger = null,
ICommunicatorObserver?observer = null,
TlsClientOptions?tlsClientOptions = null,
TlsServerOptions?tlsServerOptions = null)
{
_callback = callback;
_properties = properties;
_logger = logger;
_observer = observer;
_tlsClientOptions = tlsClientOptions;
_tlsServerOptions = tlsServerOptions;
_properties["Ice.RetryIntervals"] = "-1";
}
internal CommunicatorObserver(Communicator communicator, ILogger logger)
{
AdminFacet = new MetricsAdmin(communicator, logger);
_delegate = communicator.Observer;
_connections = new ObserverFactoryWithDelegate <ConnectionMetrics, ConnectionObserver,
IConnectionObserver>(AdminFacet, "Connection");
_dispatch = new ObserverFactoryWithDelegate <DispatchMetrics, DispatchObserver, IDispatchObserver>(
AdminFacet, "Dispatch");
_invocations = new ObserverFactoryWithDelegate <InvocationMetrics, InvocationObserver,
IInvocationObserver>(AdminFacet, "Invocation");
_connects = new ObserverFactoryWithDelegate <Metrics, ObserverWithDelegate,
IObserver>(AdminFacet, "ConnectionEstablishment");
_endpointLookups = new ObserverFactoryWithDelegate <Metrics, ObserverWithDelegate,
IObserver>(AdminFacet, "EndpointLookup");
_invocations.RegisterSubMap <ChildInvocationMetrics>("ChildInvocation",
(obj, metrics) => (obj as InvocationMetrics) !.Children = metrics);
}
internal SessionHelper(ISessionCallback callback,
string finderStr,
bool useCallbacks,
Dictionary <string, string> properties,
ILogger?logger,
ICommunicatorObserver?observer,
TlsClientOptions?tlsClientOptions,
TlsServerOptions?tlsServerOptions)
{
_callback = callback;
_finderStr = finderStr;
_useCallbacks = useCallbacks;
_properties = properties;
_logger = logger;
_observer = observer;
_tlsClientOptions = tlsClientOptions;
_tlsServerOptions = tlsServerOptions;
}
public override async Task RunAsync(string[] args)
{
ICommunicatorObserver? observer = Instrumentation.GetObserver();
Dictionary <string, string>?properties = CreateTestProperties(ref args);
properties["Ice.RetryIntervals"] = "0 1 10 1";
properties["Ice.Warn.Dispatch"] = "0";
// This test kills connections, so we don't want warnings.
properties["Ice.Warn.Connections"] = "0";
await using Communicator communicator = Initialize(properties, observer: observer);
// Configure a second communicator for the invocation timeout + retry test, we need to configure a large
// retry interval to avoid time-sensitive failures.
properties["Ice.RetryIntervals"] = "0 1 10000";
await using Communicator? communicator2 = Initialize(properties, observer: observer);
communicator.CreateObjectAdapter().Add("retry", new Retry());
communicator2.CreateObjectAdapter().Add("retry", new Retry());
await AllTests.Run(this, communicator, communicator2, "retry").ShutdownAsync();
}
/// <summary>
/// Creates a Glacier2 session.
/// </summary>
/// <param name="callback">The callback for notifications about session
/// establishment.</param>
/// <param name="properties">Optional properties used for communicator initialization.</param>
/// <param name="logger">Optional logger used for communicator initialization.</param>
/// <param name="observer">Optional communicator observer used for communicator initialization.</param>
/// <param name="certificates">The user certificates to use with the SSL transport.</param>
/// <param name="caCertificates">The certificate authorities to use with the SSL transport.</param>
/// <param name="certificateValidationCallback">The certificate validation callback to use with the SSL transport.</param>
/// <param name="passwordCallback">The password callback delegate to use with the SSL transport.</param>
/// <param name="finderStr">The stringified Ice.RouterFinder proxy.</param>
/// <param name="useCallbacks">True if the session should create an object adapter for receiving callbacks.</param>
internal SessionHelper(ISessionCallback callback,
string finderStr,
bool useCallbacks,
Dictionary <string, string> properties,
ILogger?logger = null,
ICommunicatorObserver?observer = null,
X509Certificate2Collection?certificates = null,
X509Certificate2Collection?caCertificates = null,
RemoteCertificateValidationCallback?certificateValidationCallback = null,
IPasswordCallback?passwordCallback = null)
{
_callback = callback;
_finderStr = finderStr;
_useCallbacks = useCallbacks;
_properties = properties;
_logger = logger;
_observer = observer;
_certificates = certificates;
_caCertificates = caCertificates;
_certificateValidationCallback = certificateValidationCallback;
_passwordCallback = passwordCallback;
}
/// <summary>Creates a SessionFactory object.</summary>
/// <param name="callback">The callback for notifications about session establishment.</param>
/// <param name="properties">Optional properties used for communicator initialization.</param>
/// <param name="logger">Optional logger used for communicator initialization.</param>
/// <param name="observer">Optional communicator observer used for communicator initialization.</param>
/// <param name="certificates">Optional certificates used by secure transports.</param>
/// <param name="caCertificates">Optional CA certificates used by secure transports.</param>
/// /// <param name="certificateSelectionCallback">Optional certificate selection callback used by secure
/// transports.</param>
/// <param name="certificateValidationCallback">Optional certificate validation callback used by secure
/// transports.</param>
/// <param name="passwordCallback">Optional password callback used by secure transports.</param>
public SessionFactoryHelper(
ISessionCallback callback,
Dictionary <string, string> properties,
ILogger?logger = null,
ICommunicatorObserver?observer = null,
X509Certificate2Collection?certificates = null,
X509Certificate2Collection?caCertificates = null,
LocalCertificateSelectionCallback?certificateSelectionCallback = null,
RemoteCertificateValidationCallback?certificateValidationCallback = null,
IPasswordCallback?passwordCallback = null)
{
_callback = callback;
_properties = properties;
_logger = logger;
_observer = observer;
_certificates = certificates;
_caCertificates = caCertificates;
_certificateSelectionCallback = certificateSelectionCallback;
_certificateValidationCallback = certificateValidationCallback;
_passwordCallback = passwordCallback;
_properties["Ice.RetryIntervals"] = "-1";
}
public static IInvocationObserver?get(Ice.IObjectPrx proxy, string op, Dictionary <string, string>?context)
{
ICommunicatorObserver?obsv = proxy.Communicator.Observer;
if (obsv != null)
{
IInvocationObserver observer;
if (context == null)
{
observer = obsv.GetInvocationObserver(proxy, op, _emptyContext);
}
else
{
observer = obsv.GetInvocationObserver(proxy, op, context);
}
if (observer != null)
{
observer.Attach();
}
return(observer);
}
return(null);
}
internal async ValueTask NextConnectorAsync()
{
System.Exception?lastException = null;
for (int i = 0; i < _connectors.Count; ++i)
{
ConnectorInfo connector = _connectors[i];
try
{
ICommunicatorObserver?obsv = _factory._communicator.Observer;
if (obsv != null)
{
_observer = obsv.GetConnectionEstablishmentObserver(connector.Endpoint,
connector.Connector.ToString() !);
if (_observer != null)
{
_observer.Attach();
}
}
if (_factory._communicator.TraceLevels.Network >= 2)
{
_factory._communicator.Logger.Trace(_factory._communicator.TraceLevels.NetworkCat,
$"trying to establish {connector.Endpoint.Name} connection to " +
$"{connector.Connector}");
}
// TODO: Connection establishement code needs to be re-factored to use async/await
Connection connection = _factory.CreateConnection(connector.Connector.Connect(), connector);
await connection.StartAsync().ConfigureAwait(false);
if (_observer != null)
{
_observer.Detach();
}
_factory.FinishGetConnection(_connectors, connector, connection, this);
return;
}
catch (CommunicatorDestroyedException ex)
{
lastException = ex;
break; // No need to continue
}
catch (System.Exception ex)
{
if (_factory._communicator.TraceLevels.Network >= 2)
{
Debug.Assert(connector != null);
_factory._communicator.Logger.Trace(_factory._communicator.TraceLevels.NetworkCat,
$"failed to establish {connector.Endpoint.Name} connection to " +
$"{connector.Connector}\n{ex}");
}
if (_observer != null)
{
_observer.Failed(ex.GetType().FullName ?? "System.Exception");
_observer.Detach();
}
_factory.HandleConnectionException(ex, _hasMore || (i + 1) < _connectors.Count);
lastException = ex;
}
}
_factory.FinishGetConnection(_connectors, lastException !, this);
}
private async Task <OutgoingResponseFrame> DispatchAsync(
OutgoingRequestFrame outgoingRequest,
int requestId,
CancellationToken cancel)
{
// Increase the direct count to prevent the object adapter from being destroyed while the dispatch is in
// progress. This will also throw if the object adapter has been deactivated.
_adapter.IncDirectCount();
IDispatchObserver?dispatchObserver = null;
try
{
var incomingRequest = new IncomingRequestFrame(outgoingRequest, _adapter.IncomingFrameSizeMax);
var current = new Current(_adapter, incomingRequest, oneway: requestId == 0, cancel);
// Then notify and set dispatch observer, if any.
ICommunicatorObserver?communicatorObserver = _adapter.Communicator.Observer;
if (communicatorObserver != null)
{
dispatchObserver = communicatorObserver.GetDispatchObserver(current,
requestId,
incomingRequest.Size);
dispatchObserver?.Attach();
}
OutgoingResponseFrame?outgoingResponseFrame = null;
try
{
IObject?servant = current.Adapter.Find(current.Identity, current.Facet);
if (servant == null)
{
throw new ObjectNotExistException(current.Identity, current.Facet, current.Operation);
}
ValueTask <OutgoingResponseFrame> vt = servant.DispatchAsync(incomingRequest, current);
if (requestId != 0)
{
// We don't use the cancelable WaitAsync for the await here. The asynchronous dispatch is
// not completed yet and we want to make sure the observer is detached only when the dispatch
// completes, not when the caller cancels the request.
outgoingResponseFrame = await vt.ConfigureAwait(false);
outgoingResponseFrame.Finish();
dispatchObserver?.Reply(outgoingResponseFrame.Size);
}
}
catch (Exception ex)
{
RemoteException actualEx;
if (ex is RemoteException remoteEx && !remoteEx.ConvertToUnhandled)
{
actualEx = remoteEx;
}
else
{
actualEx = new UnhandledException(current.Identity, current.Facet, current.Operation, ex);
}
Incoming.ReportException(actualEx, dispatchObserver, current);
if (requestId != 0)
{
outgoingResponseFrame = new OutgoingResponseFrame(incomingRequest, actualEx);
outgoingResponseFrame.Finish();
dispatchObserver?.Reply(outgoingResponseFrame.Size);
}
}
