예제 #1
0
        protected SingleThreadEventExecutorOld(IEventExecutorGroup parent, string threadName, TimeSpan breakoutInterval, IQueue <IRunnable> taskQueue)
            : base(parent)
        {
            _firstTask     = true;
            _emptyEvent    = new ManualResetEventSlim(false, 1);
            _shutdownHooks = new HashSet <Action>();

            _loopAction     = Loop;
            _loopCoreAciton = LoopCore;

            _terminationCompletionSource = NewPromise();
            _taskQueue = taskQueue;
            _preciseBreakoutInterval = PreciseTimeSpan.FromTimeSpan(breakoutInterval);
            _scheduler = new ExecutorTaskScheduler(this);
            _thread    = new Thread(_loopAction);
            if (string.IsNullOrEmpty(threadName))
            {
                _thread.Name = DefaultWorkerThreadName;
            }
            else
            {
                _thread.Name = threadName;
            }
            _thread.Start();
        }
예제 #2
0
        public IChannelPipeline AddAfter(IEventExecutorGroup group, string baseName, string name, IChannelHandler handler)
        {
            Contract.Requires(handler != null);

            AbstractChannelHandlerContext newCtx;

            lock (this)
            {
                CheckMultiplicity(handler);
                AbstractChannelHandlerContext ctx = this.GetContextOrThrow(baseName);

                newCtx = this.NewContext(group, this.FilterName(name, handler), handler);
                IEventExecutor executor = this.ExecutorSafe(newCtx.executor);

                AddAfter0(ctx, newCtx);

                // If the executor is null it means that the channel was not registered on an eventloop yet.
                // In this case we remove the context from the pipeline and add a task that will call
                // ChannelHandler.handlerRemoved(...) once the channel is registered.
                if (executor == null)
                {
                    this.CallHandlerCallbackLater(newCtx, true);
                    return(this);
                }

                if (!executor.InEventLoop)
                {
                    executor.Execute(CallHandlerAddedAction, this, newCtx);
                    return(this);
                }
            }
            this.CallHandlerAdded0(newCtx);
            return(this);
        }
예제 #3
0
        public RlpxPeer(IMessageSerializationService serializationService,
                        PublicKey localNodeId,
                        int localPort,
                        IHandshakeService handshakeService,
                        ISessionMonitor sessionMonitor,
                        IDisconnectsAnalyzer disconnectsAnalyzer,
                        ILogManager logManager)
        {
            // .NET Core definitely got the easy logging setup right :D
            // ResourceLeakDetector.Level = ResourceLeakDetector.DetectionLevel.Paranoid;
            // ConfigureNamedOptions<ConsoleLoggerOptions> configureNamedOptions = new("", null);
            // OptionsFactory<ConsoleLoggerOptions> optionsFactory = new(
            //     new []{ configureNamedOptions },
            //     Enumerable.Empty<IPostConfigureOptions<ConsoleLoggerOptions>>());
            // OptionsMonitor<ConsoleLoggerOptions> optionsMonitor = new(
            //     optionsFactory,
            //     Enumerable.Empty<IOptionsChangeTokenSource<ConsoleLoggerOptions>>(),
            //     new OptionsCache<ConsoleLoggerOptions>());
            // LoggerFactory loggerFactory = new(
            //     new[] { new ConsoleLoggerProvider(optionsMonitor) },
            //     new LoggerFilterOptions { MinLevel = Microsoft.Extensions.Logging.LogLevel.Warning });
            // InternalLoggerFactory.DefaultFactory = loggerFactory;

            _group = new SingleThreadEventLoop();
            _serializationService = serializationService ?? throw new ArgumentNullException(nameof(serializationService));
            _logManager           = logManager ?? throw new ArgumentNullException(nameof(logManager));
            _logger              = logManager.GetClassLogger();
            _sessionMonitor      = sessionMonitor ?? throw new ArgumentNullException(nameof(sessionMonitor));
            _disconnectsAnalyzer = disconnectsAnalyzer ?? throw new ArgumentNullException(nameof(disconnectsAnalyzer));
            _handshakeService    = handshakeService ?? throw new ArgumentNullException(nameof(handshakeService));
            LocalNodeId          = localNodeId ?? throw new ArgumentNullException(nameof(localNodeId));
            LocalPort            = localPort;
        }
예제 #4
0
        public static Task ShutdownChannelAsync(
            IEventExecutorGroup bossExecutor,
            IEventExecutorGroup workerExecutor,
            IChannelGroup allChannels,
            TimeSpan timeSpan)
        {
            timeSpan = timeSpan.TotalSeconds <= 2 ? TimeSpan.FromSeconds(3) : timeSpan;
            List <Task> tasks = new List <Task>();

            // Close all channels
            if (allChannels != null)
            {
                tasks.Add(allChannels.CloseAsync());
            }

            // Stop boss threads
            if (bossExecutor != null)
            {
                tasks.Add(bossExecutor.ShutdownGracefullyAsync(TimeSpan.FromSeconds(2), timeSpan));
            }

            // Finally stop I/O workers
            if (workerExecutor != null)
            {
                tasks.Add(workerExecutor.ShutdownGracefullyAsync(TimeSpan.FromSeconds(2), timeSpan));
            }
            return(Task.WhenAll(tasks.ToArray()));
        }
예제 #5
0
 public IChannelPipeline AddLast(IEventExecutorGroup group, params IChannelHandler[] handlers)
 {
     foreach (IChannelHandler h in handlers)
     {
         this.AddLast(group, (string)null, h);
     }
     return(this);
 }
예제 #6
0
        public IChannelPipeline AddFirst(IEventExecutorGroup group, params IChannelHandler[] handlers)
        {
            Contract.Requires(handlers != null);

            for (int i = handlers.Length - 1; i >= 0; i--)
            {
                IChannelHandler h = handlers[i];
                this.AddFirst(group, (string)null, h);
            }

            return(this);
        }
예제 #7
0
 public Bootstrap Group(IEventExecutorGroup group)
 {
     if (group == null)
     {
         throw new ArgumentNullException("group can not be null.");
     }
     if (this.group != null)
     {
         throw new InvalidOperationException("group has already been set.");
     }
     this.group = group;
     return(this);
 }
        /// <summary>Creates a new instance of <see cref="SingleThreadEventExecutor"/>.</summary>
        /// <param name="parent">the <see cref="IEventExecutorGroup"/> which is the parent of this instance and belongs to it.</param>
        /// <param name="threadFactory">the <see cref="IThreadFactory"/> which will be used for the used <see cref="Thread"/>.</param>
        /// <param name="addTaskWakesUp"><c>true</c> if and only if invocation of <see cref="AddTask(IRunnable)"/> will wake up the executor thread.</param>
        /// <param name="maxPendingTasks">the maximum number of pending tasks before new tasks will be rejected.</param>
        /// <param name="rejectedHandler">the <see cref="IRejectedExecutionHandler"/> to use.</param>
        protected SingleThreadEventExecutor(IEventExecutorGroup parent, IThreadFactory threadFactory, bool addTaskWakesUp,
                                            int maxPendingTasks, IRejectedExecutionHandler rejectedHandler)
            : this(parent, addTaskWakesUp, rejectedHandler)
        {
            if (threadFactory is null)
            {
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.threadFactory);
            }

            _maxPendingTasks   = Math.Max(16, maxPendingTasks);
            _taskQueue         = NewTaskQueue(_maxPendingTasks);
            _blockingTaskQueue = _taskQueue as IBlockingQueue <IRunnable>;

            _thread = NewThread(threadFactory);
        }
 public NettyHandshakeHandler(
     IEncryptionHandshakeService service,
     ISession session,
     HandshakeRole role,
     ILogManager logManager,
     IEventExecutorGroup group)
 {
     _role                 = role;
     _logManager           = logManager ?? throw new ArgumentNullException(nameof(NettyHandshakeHandler));
     _group                = @group;
     _logger               = logManager.GetClassLogger <NettyHandshakeHandler>();
     _service              = service;
     _session              = session;
     _initCompletionSource = new TaskCompletionSource <object>();
 }
예제 #10
0
 public RlpxPeer(
     PublicKey localNodeId,
     int localPort,
     IEncryptionHandshakeService encryptionHandshakeService,
     ILogManager logManager,
     ISessionMonitor sessionMonitor)
 {
     _group                      = new SingleThreadEventLoop();
     _logManager                 = logManager ?? throw new ArgumentNullException(nameof(logManager));
     _logger                     = logManager.GetClassLogger();
     _sessionMonitor             = sessionMonitor ?? throw new ArgumentNullException(nameof(sessionMonitor));
     _encryptionHandshakeService = encryptionHandshakeService ?? throw new ArgumentNullException(nameof(encryptionHandshakeService));
     LocalNodeId                 = localNodeId ?? throw new ArgumentNullException(nameof(localNodeId));
     LocalPort                   = localPort;
 }
예제 #11
0
 public NettyHandshakeHandler(
     IMessageSerializationService serializationService,
     IHandshakeService handshakeService,
     ISession session,
     HandshakeRole role,
     ILogManager logManager,
     IEventExecutorGroup group)
 {
     _serializationService = serializationService ?? throw new ArgumentNullException(nameof(serializationService));
     _logManager           = logManager ?? throw new ArgumentNullException(nameof(logManager));
     _logger  = logManager.GetClassLogger <NettyHandshakeHandler>();
     _role    = role;
     _group   = group;
     _service = handshakeService ?? throw new ArgumentNullException(nameof(handshakeService));
     _session = session ?? throw new ArgumentNullException(nameof(session));
     _initCompletionSource = new TaskCompletionSource <object>();
 }
예제 #12
0
 protected SingleThreadEventExecutor(IEventExecutorGroup parent, string threadName, TimeSpan breakoutInterval, IQueue <IRunnable> taskQueue)
     : base(parent)
 {
     this.terminationCompletionSource = new TaskCompletionSource();
     this.taskQueue = taskQueue;
     this.preciseBreakoutInterval = PreciseTimeSpan.FromTimeSpan(breakoutInterval);
     this.scheduler = new ExecutorTaskScheduler(this);
     this.thread    = new Thread(this.Loop);
     if (string.IsNullOrEmpty(threadName))
     {
         this.thread.Name = DefaultWorkerThreadName;
     }
     else
     {
         this.thread.Name = threadName;
     }
     this.thread.Start();
 }
예제 #13
0
        IEventExecutor GetChildExecutor(IEventExecutorGroup group)
        {
            if (group == null)
            {
                return(null);
            }
            // Use size of 4 as most people only use one extra EventExecutor.
            Dictionary <IEventExecutorGroup, IEventExecutor> executorMap = this.childExecutors
                                                                           ?? (this.childExecutors = new Dictionary <IEventExecutorGroup, IEventExecutor>(4, ReferenceEqualityComparer.Default));

            // Pin one of the child executors once and remember it so that the same child executor
            // is used to fire events for the same channel.
            if (!executorMap.TryGetValue(group, out IEventExecutor childExecutor))
            {
                childExecutor      = group.GetNext();
                executorMap[group] = childExecutor;
            }
            return(childExecutor);
        }
예제 #14
0
        public RlpxPeer(
            IMessageSerializationService serializationService,
            PublicKey localNodeId,
            int localPort,
            IHandshakeService handshakeService,
            ILogManager logManager,
            ISessionMonitor sessionMonitor)
        {
//            InternalLoggerFactory.DefaultFactory.AddProvider(new ConsoleLoggerProvider((s, level) => level > LogLevel.Warning, false));
//            ResourceLeakDetector.Level = ResourceLeakDetector.DetectionLevel.Paranoid;
            _group = new SingleThreadEventLoop();
            _serializationService = serializationService ?? throw new ArgumentNullException(nameof(serializationService));
            _logManager           = logManager ?? throw new ArgumentNullException(nameof(logManager));
            _logger           = logManager.GetClassLogger();
            _sessionMonitor   = sessionMonitor ?? throw new ArgumentNullException(nameof(sessionMonitor));
            _handshakeService = handshakeService ?? throw new ArgumentNullException(nameof(handshakeService));
            LocalNodeId       = localNodeId ?? throw new ArgumentNullException(nameof(localNodeId));
            LocalPort         = localPort;
        }
        /// <summary>Creates a new instance of <see cref="SingleThreadEventExecutor"/>.</summary>
        /// <param name="parent">the <see cref="IEventExecutorGroup"/> which is the parent of this instance and belongs to it.</param>
        /// <param name="threadFactory">the <see cref="IThreadFactory"/> which will be used for the used <see cref="Thread"/>.</param>
        /// <param name="addTaskWakesUp"><c>true</c> if and only if invocation of <see cref="AddTask(IRunnable)"/> will wake up the executor thread.</param>
        /// <param name="taskQueue">The pending task queue.</param>
        /// <param name="rejectedHandler">the <see cref="IRejectedExecutionHandler"/> to use.</param>
        protected SingleThreadEventExecutor(IEventExecutorGroup parent, IThreadFactory threadFactory, bool addTaskWakesUp,
                                            IQueue <IRunnable> taskQueue, IRejectedExecutionHandler rejectedHandler)
            : this(parent, addTaskWakesUp, rejectedHandler)
        {
            if (threadFactory is null)
            {
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.threadFactory);
            }
            if (taskQueue is null)
            {
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.taskQueue);
            }

            _maxPendingTasks   = DefaultMaxPendingExecutorTasks;
            _taskQueue         = taskQueue;
            _blockingTaskQueue = taskQueue as IBlockingQueue <IRunnable>;

            _thread = NewThread(threadFactory);
        }
예제 #16
0
        protected SingleThreadEventExecutor(IEventExecutorGroup parent, string threadName, TimeSpan breakoutInterval, IQueue <IRunnable> taskQueue)
            : base(parent)
        {
            _loopAction     = Loop;
            _loopCoreAciton = LoopCore;

            _terminationCompletionSource = NewPromise();
            _taskQueue = taskQueue;
            _preciseBreakoutInterval = PreciseTimeSpan.FromTimeSpan(breakoutInterval);
            _scheduler = new ExecutorTaskScheduler(this);
            _thread    = new Thread(_loopAction);
            if (string.IsNullOrEmpty(threadName))
            {
                _thread.Name = DefaultWorkerThreadName;
            }
            else
            {
                _thread.Name = threadName;
            }
            _thread.Start();
        }
예제 #17
0
 public CmppClient(
     CmppClientConfig config,
     BaseCmppSmsHandler smsHandler,
     ClientLoggerFactory loggerFactory)
 {
     this.loggerFactory  = loggerFactory;
     this.logger         = loggerFactory.CreateLogger <CmppClient>();
     config.ClientStatus = ClientStatus.WAITING_CONNECT;
     config.Version      = CmppVersion.CMPP20;
     Config            = config;
     smsHandler.client = this;
     this.smsHandler   = smsHandler;
     matchQueue        = new SubmitSmsMatchPool <MsgEx>(32, 60 * 1000);
     if (smsHandler != null)
     {
         matchQueue.timeOutHandle = smsHandler.SubmitTimeOutHandle;
     }
     eventExecutorGroup = new MultithreadEventLoopGroup();
     group     = new MultithreadEventLoopGroup();
     dbContext = new SqliteContext(Config.ClientId);
     InitClient();
 }
        private SingleThreadEventExecutor(IEventExecutorGroup parent, bool addTaskWakesUp, IRejectedExecutionHandler rejectedHandler)
            : base(parent)
        {
            if (rejectedHandler is null)
            {
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.rejectedHandler);
            }

            _firstTask = true;

            _loopAction     = Loop;
            _loopCoreAciton = LoopCore;

            _addTaskWakesUp           = addTaskWakesUp;
            _rejectedExecutionHandler = rejectedHandler;

            _shutdownHooks = new HashSet <Action>();
            _terminationCompletionSource = NewPromise();
            _threadLock = new CountdownEvent(1);

            _taskScheduler = new ExecutorTaskScheduler(this);
        }
예제 #19
0
 /// <summary>Creates a new instance of <see cref="SingleThreadEventExecutor"/>.</summary>
 public SingleThreadEventExecutor(IEventExecutorGroup parent, string threadName, TimeSpan breakoutInterval)
     : this(parent, threadName, breakoutInterval, new CompatibleConcurrentQueue <IRunnable>())
 {
 }
예제 #20
0
 /// <summary>Creates an instance of <see cref="AbstractEventExecutor"/>.</summary>
 protected AbstractEventExecutor(IEventExecutorGroup parent)
 {
     Parent = parent;
 }
예제 #21
0
 AbstractChannelHandlerContext NewContext(IEventExecutorGroup group, string name, IChannelHandler handler) => new DefaultChannelHandlerContext(this, this.GetChildExecutor(group), name, handler);
예제 #22
0
 public DefaultEventExecutor(IEventExecutorGroup parent, int maxPendingTasks)
     : this(parent, RejectedExecutionHandlers.Reject(), maxPendingTasks)
 {
 }
 protected AbstractScheduledEventExecutor(IEventExecutorGroup parent)
     : base(parent)
 {
     ScheduledTaskQueue = new DefaultPriorityQueue <IScheduledRunnable>();
 }
예제 #24
0
 public DefaultEventExecutor(IEventExecutorGroup parent)
     : this(parent, DefaultMaxPendingExecutorTasks)
 {
 }
예제 #25
0
 protected AbstractScheduledEventExecutor(IEventExecutorGroup parent)
     : base(parent)
 {
 }
예제 #26
0
 public DefaultEventExecutor(IEventExecutorGroup parent) : base(parent)
 {
 }
예제 #27
0
 public DefaultEventExecutor(IEventExecutorGroup parent, IRejectedExecutionHandler rejectedHandler, IEventExecutorTaskQueueFactory queueFactory)
     : this(parent, DefaultThreadFactory <DefaultEventExecutor> .Instance, rejectedHandler, queueFactory)
 {
 }
예제 #28
0
 public DefaultEventExecutor(IEventExecutorGroup parent, IThreadFactory threadFactory, IEventExecutorTaskQueueFactory queueFactory)
     : this(parent, threadFactory, RejectedExecutionHandlers.Reject(), queueFactory)
 {
 }
예제 #29
0
 public SingleThreadEventExecutor(IEventExecutorGroup parent) : base(parent)
 {
     taskQueue = new SynchronizedQueue <IRunnable>();
     thread    = new Thread(Loop);
     thread.Start();
 }
예제 #30
0
 public DefaultEventExecutor(IEventExecutorGroup parent, IThreadFactory threadFactory, IRejectedExecutionHandler rejectedHandler, IEventExecutorTaskQueueFactory queueFactory)
     : base(parent, threadFactory, true, NewBlockingTaskQueue(queueFactory), rejectedHandler)
 {
     Start();
 }