public ObjectModelImplementation(ObjectModel receiver)
 {
     m_receiver = receiver;
     m_connector = ConnectorFactory.GetServerConnector<IProvider>("provider", this);
     m_connector.ConnectionOpened += m_connector_ConnectionOpened;
     m_connector.ConnectionClosed += m_connector_ConnectionClosed;
 }
 public ObjectModelImplementation(ObjectModel receiver)
 {
     m_receiver  = receiver;
     m_connector = ConnectorFactory.GetServerConnector <IProvider>("provider", this);
     m_connector.ConnectionOpened += m_connector_ConnectionOpened;
     m_connector.ConnectionClosed += m_connector_ConnectionClosed;
 }
        private static async Task <MyResponse> CallProviderAsync(ProviderConnector connector, MyRequest request, CancellationToken cancellationToken)
        {
            using (Operation.Time($"Submitting request for {connector.ConnectorCode}"))
            {
                await Task.Delay(Randomizer.Next(5000), cancellationToken);

                return(new MyResponse
                {
                    CorrelationId = request.CorrelationId,
                    Ids = new int[] { 1, 2, 3, 4, 5 }
                });
            }
        }
        private async Task <EngineResult <MyResponse> > GetFromProviderTaskAsync(ProviderConnector connector, MyRequest request, TimeSpan timeOut)
        {
            if (connector == null)
            {
                Log.Error("!! GetFromProviderTaskAsync (null connector)");
                throw new ArgumentNullException(nameof(connector));
            }

            if (request == null)
            {
                Log.Error($"!! GetFromProviderTaskAsync (null request)");
                throw new ArgumentNullException(nameof(request));
            }

            using (var op = Operation.Begin($"Retrieving data for {connector.ConnectorCode}"))
            {
                try
                {
                    var cts = new CancellationTokenSource();

                    void TimerCallback(object o)
                    {
                        var c = o as ProviderConnector;

                        cts.Cancel();
                        Log.Warning(
                            $"!! GetFromProviderTaskAsync TIMEOUT {request.CorrelationId} provider '{c?.ConnectorCode}'");
                    }


                    await using var timer = new Timer(TimerCallback, connector, timeOut, Timeout.InfiniteTimeSpan);
                    var response = await CallProviderAsync(connector, request, cts.Token);

                    op.Complete();

                    return(new EngineResult <MyResponse>
                    {
                        Provider = connector.ConnectorCode,
                        Response = response,
                        Status = "OK",
                        Ex = null
                    });
                }

                catch (TaskCanceledException tce)
                {
                    op.Abandon();
                    return(new EngineResult <MyResponse>
                    {
                        Provider = connector.ConnectorCode,
                        Response = null,
                        Status = "TO",
                        Ex = tce
                    });
                }
                catch (Exception ex)
                {
                    op.Abandon();
                    return(new EngineResult <MyResponse>
                    {
                        Provider = connector.ConnectorCode,
                        Response = null,
                        Status = "KO",
                        Ex = ex
                    });
                }
            }
        }