public TaskRunner(Container container, ITaskRequest request) { if (container == null) { throw new ArgumentNullException("container"); } this.container = container; if (request == null) { throw new ArgumentNullException("request"); } this.request = request; if (this.request.Script.IsNullOrWhiteSpace()) { throw new ArgumentNullException("request.Script can't be empty."); } commands = JsonConvert.DeserializeObject <TaskCommandDTO[]>(request.Script); if (commands.IsNullOrEmpty()) { throw new ArgumentException("Expected to run at least one command."); } }
public static Timer StartHeartBeat(string serverCode, ITaskRequest request, int heartbeatPeriod) { //Timer timer = new Timer(o => //{ // object[] arr = (object[])o; // string code = (string)arr[0]; // try // { // ITaskRequest req = (ITaskRequest)arr[1]; // HeartBeatTaskInfo beatInfo = new HeartBeatTaskInfo() // { // TaskName = "HeartBeatTaskHandle", // TaskCreateTime = DateTime.Now, // EmitServerCode = code // }; // ITaskInfo result = req.SendRequest(code, beatInfo); // if (result.TaskStatus != TaskStatus.Success) // { // string msg = result.TaskStatus == TaskStatus.Success ? "成功" : "失败:" + result.TaskRemark; // m_log.Info(string.Format("{0}(LocalIP:{1})于{2},执行心跳检测结果,{3}", code, IPHelper.GetLocalIP(), DateTime.Now, msg)); // } // } // catch (Exception ex) // { // m_log.Error(string.Format("{0}(LocalIP:{1})于{2},执行心跳检测异常:{3}", code, IPHelper.GetLocalIP(), DateTime.Now, ex.Message)); // } //}, new object[] { serverCode, request }, heartbeatPeriod, heartbeatPeriod); //return timer; return(null); }
public void Should_not_complete_timeout_if_handler_completes() { var pongReceived = new FutureMessage <PongMessage>(); var continueCalled = new FutureMessage <Task <PongMessage> >(); var timeoutCalled = new FutureMessage <PingMessage>(); TimeSpan timeout = 8.Seconds(); var ping = new PingMessage(); ITaskRequest <PingMessage> request = LocalBus.PublishRequestAsync(ping, x => { x.HandleTimeout(4.Seconds(), timeoutCalled.Set); x.Handle <PongMessage>(pongReceived.Set) .ContinueWith(continueCalled.Set); }); pongReceived.IsAvailable(timeout).ShouldBeTrue("The pong was not received"); request.Task.Wait(timeout).ShouldBeTrue("Task was not completed"); request.GetResponseTask <PongMessage>().Wait(timeout).ShouldBeTrue("The response task was not completed"); continueCalled.IsAvailable(timeout).ShouldBeTrue("The continuation was not called"); timeoutCalled.IsAvailable(2.Seconds()).ShouldBeFalse("The timeout should not have been called"); }
public void Should_call_timeout_callback_if_timeout_occurs() { var pongCompleted = new FutureMessage <PongMessage>(); var pongCancelled = new FutureMessage <bool>(); Task <PongMessage> pongTask; var ping = new PingMessage(); ITaskRequest <PingMessage> request = LocalBus.PublishRequestAsync(ping, x => { x.SetTimeout(1.Seconds()); pongTask = x.Handle <PongMessage>(message => { }); pongTask.ContinueWith(t => pongCompleted.Set(t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); pongTask.ContinueWith((Task t) => pongCancelled.Set(t.IsCanceled), TaskContinuationOptions.OnlyOnCanceled); }); var aggregateException = Assert.Throws <AggregateException>(() => request.Task.Wait(8.Seconds())); Assert.IsInstanceOf <RequestTimeoutException>(aggregateException.InnerExceptions.First()); pongCompleted.IsAvailable(1.Seconds()).ShouldBeFalse("We only asked to be notified on success"); pongCancelled.IsAvailable(1.Seconds()).ShouldBeTrue("We like to know we were cancelled due to timeout"); }
public TaskRunner(Container container, ITaskRequest request) { if (container == null) { throw new ArgumentNullException("container"); } this.container = container; if (request == null) { throw new ArgumentNullException("request"); } this.request = request; if (this.request.Script.IsNullOrWhiteSpace()) { throw new ArgumentNullException("request.Script can't be empty."); } commands = JsonConvert.DeserializeObject<TaskCommandDTO[]>(request.Script); if (commands.IsNullOrEmpty()) { throw new ArgumentException("Expected to run at least one command."); } }
protected virtual void TaskDistribution(string serverCode, ITaskInfo taskInfo) { IEnumerator enumor = ServerManager.GetServerEnumerator(); taskInfo.EmitServerCode = serverCode; if (enumor != null) { while (enumor.MoveNext()) { IServerInfo s = (IServerInfo)enumor.Current; if (string.Compare(serverCode, s.ServerCode, true) != 0 && //去掉自己发给自己 taskInfo.EmitServerCode != s.ServerCode) //去掉发给源服务器 { if (s.ServerStatus == ServerStatus.Active && TaskAllocAlgFactory.GetProvider().Alloc(taskInfo, s)) { try { Console.WriteLine("正在往" + s.ServerCode + "服务器分发数据"); ITaskRequest request = RegisterService.TaskRequestService.GetService(s.ServerCode); ITaskInfo disTaskInfo = request.SendRequest(s.ServerCode, taskInfo); } catch (Exception ex) { s.ServerStatus = ServerStatus.Shutdown; Console.WriteLine("向" + s.ServerCode + "服务器分发数据失败,异常信息为:" + ex.Message + "|" + ex.Source + "|" + ex.StackTrace); } } } } } }
public void Should_throw_an_exception_from_the_timeout() { var ping = new PingMessage(); ITaskRequest <PingMessage> request = LocalBus.PublishRequestAsync(ping, x => { x.SetTimeout(1.Seconds()); }); var aggregateException = Assert.Throws <AggregateException>(() => request.Task.Wait(8.Seconds())); Assert.IsInstanceOf <RequestTimeoutException>(aggregateException.InnerExceptions.First()); }
protected IJobRunnable GetRunnableFor(ITaskRequest request) { if (request == null) { throw new ArgumentNullException("request"); } Container container = GetContainer(); return new TaskRunner(container, request); }
protected IJobRunnable GetRunnableFor(ITaskRequest request) { if (request == null) { throw new ArgumentNullException("request"); } var container = GetContainer(); return(new TaskRunner(container, request)); }
public void Should_call_timeout_callback_if_timeout_occurs() { var ping = new Messages.PingMessage(); ITaskRequest <Messages.PingMessage> request = LocalBus.PublishRequestAsync(ping, x => { // x.SetTimeout(1.Seconds()); }); var aggregateException = Assert.Throws <AggregateException>(() => request.Task.Wait(8.Seconds())); Assert.IsInstanceOf <RequestTimeoutException>(aggregateException.InnerExceptions.First()); }
public static ITaskRequest <TRequest> PublishRequestAsync <TRequest>(this IServiceBus bus, TRequest message, Action <ITaskRequestConfigurator <TRequest> > configureCallback) where TRequest : class { var configurator = new TaskRequestConfigurator <TRequest>(message); configureCallback(configurator); ITaskRequest <TRequest> request = configurator.Create(bus); bus.Publish(message, context => configurator.ApplyContext(context, bus.Endpoint.Address.Uri)); return(request); }
public void Should_call_timeout_callback_if_timeout_occurs_and_not_fault() { var continueCalled = new FutureMessage <PingMessage>(); var ping = new PingMessage(); ITaskRequest <PingMessage> request = LocalBus.PublishRequestAsync(ping, x => { // x.HandleTimeout(1.Seconds(), continueCalled.Set); }); request.Task.Wait(8.Seconds()).ShouldBeTrue("Should have completed successfully"); continueCalled.IsAvailable(8.Seconds()).ShouldBeTrue("The timeout continuation was not called"); }
public static ITaskRequest GetService(string serverCode) { ITaskRequest request = null; IServerInfo serverInfo = ServerManager.Get(serverCode); if (serverInfo != null) { request = (ITaskRequest)Activator.GetObject(typeof(TaskRequest), string.Format("{0}://{1}:{2}/{3}.{4}", serverInfo.Protocal, serverInfo.Address, serverInfo.Port, serverInfo.ServerCode, serviceName)); } else { throw new Exception("服务未注册"); } return(request); }
static DBLog() { try { m_localLog = LoggerSource.Instance.GetLogger(typeof(DBLog)); AppSetting.InitDistributionConfig(); m_logToServer = AppSetting.LogToServer; m_localServer = ServerManager.GetLocalServer(); m_localServerIP = IPHelper.GetLocalIP(); m_localServerCode = m_localServer != null ? m_localServer.ServerCode : m_localServerIP; if (m_openLogCenter) { #if THRIFT ZKManager.Client.Init(); InitThriftServer(); #endif } m_request = RegisterService.TaskRequestService.GetService(m_logToServer); m_logHandlePool = new DataBufferPool(BatchSendHandleRequest) { AutoFlushLogSeconds = 5, IsBlockMainThread = false }; m_logProcessPool = new DataBufferPool(BatchSendProcessRequest) { AutoFlushLogSeconds = 3, IsBlockMainThread = false }; } catch (Exception ex) { m_localLog.Error(ex); } }
private static void InitBasicTaskProperties(ITaskRequest task) { task.Name = "test"; task.Description = "descr"; task.CallbackUrl = URL; }
private static void AssertSameBasicTaskProperties(ITaskRequest result, ITaskRequest task) { Assert.That(result.Name, Is.EqualTo(task.Name)); Assert.That(result.Description, Is.EqualTo(task.Description)); Assert.That(result.CallbackUrl, Is.EqualTo(task.CallbackUrl)); }
public static Timer StartHeartBeat(string serverCode, ITaskRequest request) { return(StartHeartBeat(serverCode, request, DefaultHeartbeatPeriod)); }
private static void SendRequestExpectArgumentException(ITaskRequest request, ServiceClientBase service, string httpMethod, string wrongArgument) { try { using (service) { service.HttpMethod = httpMethod; service.Send<TaskResponse>(request); Assert.Fail("No Exception occured."); } } catch (WebServiceException ex) { Assert.That(ex.StatusCode, Is.EqualTo((int)HttpStatusCode.BadRequest)); Assert.That(ex.ErrorCode, Is.EqualTo("ArgumentException")); Assert.That(ex.ErrorMessage, Is.StringContaining(wrongArgument)); } }
Task StartStressGenerator(int instance, Task start) { var ready = new TaskCompletionSource <bool>(); var composer = new TaskComposer <bool>(_cancel.Token, false); var endpointAddress = _serviceBus.Endpoint.Address as IRabbitMqEndpointAddress; string queueName = string.Format("{0}_client_{1}", endpointAddress.Name, instance); Uri uri = RabbitMqEndpointAddress.Parse(_clientUri).ForQueue(queueName).Uri; var uriBuilder = new UriBuilder(uri); uriBuilder.Query = _clientUri.Query.Trim('?'); Uri address = uriBuilder.Uri; composer.Execute(() => { Interlocked.Increment(ref _instanceCount); }); IServiceBus bus = null; composer.Execute(() => { _log.InfoFormat("Creating {0}", address); bus = ServiceBusFactory.New(x => { x.UseRabbitMq(r => { r.ConfigureHost(address, h => { h.SetUsername(_username); h.SetPassword(_password); h.SetRequestedHeartbeat(_heartbeat); }); }); x.ReceiveFrom(address); }); }, false); Stopwatch clientTimer = null; composer.Execute(() => { ready.TrySetResult(true); return(start); }); composer.Execute(() => clientTimer = Stopwatch.StartNew()); for (int requestClient = 0; requestClient < _requestsPerInstance; requestClient++) { int clientIndex = requestClient; composer.Execute(() => { Task task = composer.Compose(x => { for (int i = 0; i < _iterations; i++) { int iteration = i; x.Execute(() => { string messageContent = _mixed && iteration % 2 == 0 ? new string('*', 128) : _messageContent; var requestMessage = new StressfulRequestMessage(messageContent); ITaskRequest <StressfulRequest> taskRequest = bus.PublishRequestAsync <StressfulRequest>(requestMessage, r => { r.Handle <StressfulResponse>(response => { Interlocked.Increment(ref _responseCount); TimeSpan timeSpan = response.Timestamp - requestMessage.Timestamp; Interlocked.Add(ref _responseTime, (long)timeSpan.TotalMilliseconds); _timings[instance][clientIndex * _iterations + iteration] = (int)timeSpan.TotalMilliseconds; if (response.RequestId != requestMessage.RequestId) { Interlocked.Increment(ref _mismatchedResponseCount); } }); }); Interlocked.Increment(ref _requestCount); return(taskRequest.Task); }); } }); return(task); }); } composer.Execute(() => clientTimer.Stop()); composer.Execute(() => bus.Dispose(), false); composer.Compensate(compensation => { return(compensation.Handled()); }); composer.Finally(status => { Interlocked.Add(ref _totalTime, clientTimer.ElapsedMilliseconds); int count = Interlocked.Decrement(ref _instanceCount); if (count == 0) { Task.Factory.StartNew(() => _hostControl.Stop()); } }, false); _clientTasks.Add(composer.Finish()); return(ready.Task); }