protected override async Task <string> HandleRequest(HttpListenerRequest request, HttpListenerResponse response, string defaultMessage)
{
string command = request.GetHeaderValue(Headers.Command, "Wrong request to service, command is not specified");
bool forService = request.GetHeaderValue <bool>(Headers.CommandTarget, "Wrong request to service, command target is not specified");
if (forService)
{
switch (command)
{
case ServiceCommands.Stop:
{
Stop();
break;
}
case ServiceCommands.Info:
{
var builder = new StringBuilder();
Dictionary <long, Task <HttpResponseMessage> > handlerInfoTasks;
lock (_wrappersLock)
{
RefreshWrappers();
builder.Append($"\nTotal active handlers: {_wrappers.Count}\n");
handlerInfoTasks = _wrappers
.Values
.Where(x => x.IsRunning)
.ToDictionary(x => x.ID, x => _client.SendMessageAsync(x.Port, true, null, (Headers.Command, HandlerCommands.Info)));
}
try
{
await Task.WhenAll(handlerInfoTasks.Values);
}
catch (Exception ex)
{
Log.Error("Exception while gathering info from handlers: {0}", ex);
}
foreach ((long key, var task) in handlerInfoTasks.OrderBy(x => x.Key))
{
builder.Append($"\nHandler[{key}]:\n");
try
{
string message = await(await task).GetMessageAsync();
builder.Append($"{message}");
}
catch (Exception ex)
{
builder.Append($"Request failed with exception: {ex}");
}
}
return(builder.ToString());
}
case ServiceCommands.RunHandler:
{
var options = await request.GetContentAsync <HandlerOptions>();
return(await RunHandlerAsync(options));
}
default:
{
throw new Exception($"Service cannot handle command: {command}");
}
}
}
else
{
long handlerID = request.GetHeaderValue <long>(Headers.HandlerID, "Handler ID is not specified");
if (!TryGetWrapper(handlerID, out var wrapper))
{
throw new Exception($"No handler for ID = {handlerID}");
}
if (!wrapper.IsRunning)
{
throw new Exception("Handler is closing and cannot accept requests");
}
string content = await request.GetContentAsync();
var handlerResponse = await _client.SendMessageAsync(wrapper.Port, false, content, (Headers.Command, command));
string message = await handlerResponse.GetMessageAsync();
if (handlerResponse.IsSuccessStatusCode)
{
return(message);
}
throw new Exception(message);
}
return(defaultMessage);
}
protected override async Task <string> HandleRequest(HttpListenerRequest request, HttpListenerResponse response, string defaultMessage)
{
string command = request.GetHeaderValue(Headers.Command, "Wrong request to handler, command is not specified");
switch (command)
{
case HandlerCommands.InitInfo:
{
await InitTask;
break;
}
case HandlerCommands.Stop:
{
string[] args = await request.GetContentAsync <string[]>();
if (args != null)
{
_handlerOptions.DisposeArgs = args;
}
Stop();
break;
}
case HandlerCommands.StopTrigger:
{
long triggerID = await request.GetContentAsync <long>();
_scheduler.Remove(triggerID);
break;
}
case HandlerCommands.Handle:
{
var info = await request.GetContentAsync <CommandInfo>();
(string value, bool returns) = await _handler.Handle(info.Command, info.Args);
if (returns)
{
return(value);
}
break;
}
case HandlerCommands.ExtendSchedule:
{
var options = await request.GetContentAsync <TriggersOptions>();
_scheduler.AddRange(options.All);
return(_scheduler.GetStat());
}
case HandlerCommands.Info:
{
return(_scheduler.GetStat());
}
case HandlerCommands.GetLog:
{
using (var reader = new StreamReader(_processArgs.Log))
{
return(await reader.ReadToEndAsync());
}
}
default:
{
throw new Exception($"Handler cannot handle command: {command}");
}
}
return(defaultMessage);
}
