public static ServerBuilder BuildServer(string[] args, TaskMonitor monitor)
{
var builder = new ServerBuilder();
builder.ConfigureAppConfiguration(config =>
{
config.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", false, true)
.AddEnvironmentVariables()
.AddCommandLine(args);
})
.ConfigureLogging((config, l) =>
{
var debugLevel = config.GetValue <Extensions.Logging.LogLevel>("Logging:Debug:LogLevel:Default", Extensions.Logging.LogLevel.Debug);
l.AddConsole(config.GetSection("Logging").GetSection("Console"))
.AddDebug(debugLevel);
})
.ConfigureCloudOptions(c => c.GetSection("CloudOption").Get <CloudOption>())
.AddTaskItemSource(async(u, c, l, token) => new TaskItemSource(
await u.GetOrCreateNodeDispatchQueueAsync(c.GetValue <string>(Constants.HpcHostNameEnv), token),
TimeSpan.FromSeconds(u.Option.VisibleTimeoutSeconds),
l))
.AddWorker(async(config, u, l, token) => new NodeAgentWorker(
config,
l,
await u.GetOrCreateJobsTableAsync(token),
await u.GetOrCreateNodesTableAsync(token),
u))
.ConfigureWorker(w => ((NodeAgentWorker)w).Monitor = monitor);
return(builder);
}
public static ServerBuilder BuildServer(string[] args, TaskMonitor monitor) =>
new ServerBuilder(args)
.ConfigServiceCollection((svc, config, token) =>
{
svc.AddSingleton(monitor);
svc.Configure <TaskItemSourceOptions>(config.GetSection(nameof(TaskItemSourceOptions)));
svc.Configure <NodeCommunicatorOptions>(config.GetSection(nameof(NodeCommunicatorOptions)));
svc.Configure <NodeRegisterWorkerOptions>(config.GetSection(nameof(NodeRegisterWorkerOptions)));
svc.AddSingleton <NodeCommunicator>();
svc.AddSingleton <NodeSynchronizer>();
svc.Configure <MetadataWorkerOptions>(config.GetSection(nameof(MetadataWorkerOptions)));
svc.AddSingleton <IWorker, MetadataWorker>();
svc.AddSingleton <NodeRegister>();
svc.AddSingleton <IWorker, NodeRegisterWorker>();
svc.Configure <MetricsWorkerOptions>(config.GetSection(nameof(MetricsWorkerOptions)));
svc.AddSingleton <IWorker, MetricsWorker>();
svc.Configure <JobDispatchWorkerGroupOptions>(config.GetSection(nameof(JobDispatchWorkerGroupOptions)));
svc.Configure <JobCancelWorkerGroupOptions>(config.GetSection(nameof(JobCancelWorkerGroupOptions)));
svc.AddSingleton <IWorker, JobDispatchWorkerGroup>();
svc.AddSingleton <IWorker, JobCancelWorkerGroup>();
svc.AddTransient <JobCancelWorker>();
svc.AddTransient <JobDispatchWorker>();
svc.AddTransient <StartJobAndTaskProcessor>();
svc.AddTransient <CancelJobOrTaskProcessor>();
});
public static void Main(string[] args)
{
var taskMonitor = new TaskMonitor();
using (var serverBuilder = BuildServer(args, taskMonitor))
{
serverBuilder.BuildAsync().GetAwaiter().GetResult();
Task.Run(() => BuildWebHost(args, taskMonitor, serverBuilder.Utilities).Run());
serverBuilder.Start();
// TODO: refactor with multi purpose server.
var metricsWorker = new MetricsWorker(
serverBuilder.Utilities,
serverBuilder.Configuration,
serverBuilder.Utilities.GetMetricsTable(),
serverBuilder.Utilities.GetNodesTable(),
serverBuilder.LoggerFactory);
metricsWorker.DoWorkAsync(null, serverBuilder.CancelToken).FireAndForget();
Console.CancelKeyPress += (s, e) => { serverBuilder.Stop(); };
while (Console.In.Peek() == -1)
{
Task.Delay(1000).Wait();
}
var logger = serverBuilder.LoggerFactory.CreateLogger <Program>();
logger.LogInformation("Stop message received, stopping");
serverBuilder.Stop();
}
}
public static void Main(string[] args)
{
var taskMonitor = new TaskMonitor();
using (var serverBuilder = BuildServer(args, taskMonitor))
{
var server = serverBuilder.BuildAsync().GetAwaiter().GetResult();
Console.CancelKeyPress += (s, e) => { serverBuilder.Stop(); };
var webHost = BuildWebHost(
args,
taskMonitor,
serverBuilder.Utilities,
serverBuilder.GetRequiredService <NodeSynchronizer>(),
serverBuilder.GetRequiredService <ILogger>(),
serverBuilder.GetRequiredService <NodeRegister>());
server.Start(serverBuilder.CancelToken);
webHost.RunAsync(serverBuilder.CancelToken);
while (Console.In.Peek() == -1)
{
Task.Delay(1000).Wait();
}
serverBuilder.Logger?.Information("Stop message received, stopping");
serverBuilder.Stop();
}
}
public CallbackController(ILogger logger, TaskMonitor monitor, CloudUtilities utilities, NodeSynchronizer synchronizer)
{
this.logger = logger;
this.monitor = monitor;
this.utilities = utilities;
this.synchronizer = synchronizer;
}
public TaskEntry(int jobId, string key, TaskMonitor monitor, Func <string, bool, CancellationToken, T.Task> outputProcessor)
{
this.jobId = jobId;
this.key = key;
this.monitor = monitor;
this.Result = new TaskResultMonitor();
this.Sorter = new OutputSorter(outputProcessor);
}
public static IWebHost BuildWebHost(string[] args, TaskMonitor taskMonitor, CloudUtilities utilities) =>
WebHost.CreateDefaultBuilder()
.ConfigureAppConfiguration(c =>
{
c.AddJsonFile("appsettings.json")
.AddEnvironmentVariables()
.AddCommandLine(args);
})
.ConfigureLogging((c, l) =>
{
l.AddConfiguration(c.Configuration.GetSection("Logging"))
.AddConsole()
.AddDebug()
.AddAzureWebAppDiagnostics();
})
.ConfigureServices(services =>
{
services.Add(new Extensions.DependencyInjection.ServiceDescriptor(typeof(TaskMonitor), taskMonitor));
services.Add(new Extensions.DependencyInjection.ServiceDescriptor(typeof(CloudUtilities), utilities));
})
.UseUrls("http://*:8080", "http://*:5000")
.UseStartup <Startup>()
.Build();
public StartJobAndTaskProcessor(TaskMonitor monitor, NodeCommunicator communicator) : base(communicator)
{
this.Monitor = monitor;
}
public CallbackController(ILogger <CallbackController> logger, TaskMonitor monitor, CloudUtilities utilities)
{
this.logger = logger;
this.monitor = monitor;
this.utilities = utilities;
}
public CancelJobOrTaskProcessor(TaskMonitor monitor, NodeCommunicator communicator) : base(communicator)
{
this.Monitor = monitor;
}
public OutputController(ILogger logger, TaskMonitor monitor, CloudUtilities utilities)
{
this.logger = logger;
this.monitor = monitor;
this.Utilities = utilities;
}
public OutputSorter(string key, TaskMonitor monitor, Func <string, CancellationToken, Task> processor)
{
this.processor = processor;
this.key = key;
this.monitor = monitor;
}
public TaskResultMonitor(string key, TaskMonitor monitor)
{
this.key = key;
this.monitor = monitor;
}
