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);
}
