Ejemplo n.º 1
0
        DetachRemoteLogger(IRemoteLoggerPrx remoteLogger, Current current)
        {
            if (remoteLogger == null)
            {
                return(false);
            }

            //
            // No need to convert the proxy as we only use its identity
            //
            bool found = RemoveRemoteLogger(remoteLogger);

            if (_traceLevel > 0)
            {
                if (found)
                {
                    _logger.Trace(TraceCategory, "detached `" + remoteLogger.ToString() + "'");
                }
                else
                {
                    _logger.Trace(TraceCategory, "cannot detach `" + remoteLogger.ToString() + "': not found");
                }
            }

            return(found);
        }
Ejemplo n.º 2
0
 internal void DeadRemoteLogger(IRemoteLoggerPrx remoteLogger, ILogger logger, LocalException ex,
                                string operation)
 {
     //
     // No need to convert remoteLogger as we only use its identity
     //
     if (RemoveRemoteLogger(remoteLogger))
     {
         if (_traceLevel > 0)
         {
             logger.Trace(TraceCategory, "detached `" + remoteLogger.ToString() + "' because "
                          + operation + " raised:\n" + ex.ToString());
         }
     }
 }
Ejemplo n.º 3
0
 //
 // Change this proxy's communicator, while keeping its invocation timeout
 //
 private static IRemoteLoggerPrx ChangeCommunicator(IRemoteLoggerPrx prx, Communicator communicator) =>
 IRemoteLoggerPrx.Parse(prx.ToString(), communicator).Clone(invocationTimeout: prx.InvocationTimeout);
Ejemplo n.º 4
0
        AttachRemoteLogger(IRemoteLoggerPrx prx, LogMessageType[] messageTypes, string[] categories,
                           int messageMax, Current current)
        {
            if (prx == null)
            {
                return; // can't send this null RemoteLogger anything!
            }

            IRemoteLoggerPrx remoteLogger = prx.Clone(oneway: false);

            var filters = new Filters(messageTypes, categories);
            LinkedList <LogMessage>?initLogMessages = null;

            lock (this)
            {
                if (_sendLogCommunicator == null)
                {
                    if (_destroyed)
                    {
                        throw new ObjectNotExistException();
                    }

                    _sendLogCommunicator =
                        CreateSendLogCommunicator(current.Adapter.Communicator, _logger.GetLocalLogger());
                }

                Identity remoteLoggerId = remoteLogger.Identity;

                if (_remoteLoggerMap.ContainsKey(remoteLoggerId))
                {
                    if (_traceLevel > 0)
                    {
                        _logger.Trace(TraceCategory, "rejecting `" + remoteLogger.ToString() +
                                      "' with RemoteLoggerAlreadyAttachedException");
                    }

                    throw new RemoteLoggerAlreadyAttachedException();
                }

                _remoteLoggerMap.Add(remoteLoggerId,
                                     new RemoteLoggerData(ChangeCommunicator(remoteLogger, _sendLogCommunicator), filters));

                if (messageMax != 0)
                {
                    initLogMessages = new LinkedList <LogMessage>(_queue); // copy
                }
                else
                {
                    initLogMessages = new LinkedList <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 (AggregateException ae)
                    {
                        Debug.Assert(ae.InnerException is LocalException);
                        DeadRemoteLogger(remoteLogger, _logger, (LocalException)ae.InnerException, "init");
                    }
                },
                    System.Threading.Tasks.TaskScheduler.Current);
            }
            catch (LocalException ex)
            {
                DeadRemoteLogger(remoteLogger, _logger, ex, "init");
                throw;
            }
        }