public static Func <HttpRequest, HttpResponse, RouteData, Task> Create(SyncActor syncActor,
AsyncRetryPolicy retryPolicy,
IMetrics metrics,
ILogger logger = null)
{
logger = logger ?? NullLogger.Instance;
retryPolicy = retryPolicy ?? Policy.Handle <Exception>().RetryAsync();
return(async(req, res, routedata) =>
{
try
{
await retryPolicy
.ExecuteAsync(syncActor.SyncToLatest);
metrics.Measure.Counter.Increment(SyncToLatest, Success);
}
catch (Exception ex)
{
metrics.Measure.Counter.Increment(SyncToLatest, Failure);
res.StatusCode = 500;
await res.WriteAsync(ex.Message);
}
});
}
public static Func <HttpRequest, HttpResponse, RouteData, Task> Create(SyncActor syncActor, IMetrics metrics, HooksHelper hooksHelper)
{
return(async(req, res, routeData) =>
{
var commitId = req.Query["commit"].ToString();
if (!IsCommitIdString(commitId))
{
res.StatusCode = 400;
await res.WriteAsync("Invalid commit id");
return;
}
try
{
await syncActor.PushToUpstream(commitId);
metrics.Measure.Counter.Increment(Push, Success);
#pragma warning disable CS4014
hooksHelper.TriggerPostCommitHooks(commitId);
#pragma warning restore CS4014
}
catch (Exception ex)
{
metrics.Measure.Counter.Increment(Push, Failure);
res.StatusCode = 500;
await res.WriteAsync(ex.Message);
}
#pragma warning disable CS4014
syncActor.SyncToLatest();
#pragma warning restore CS4014
});
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory,
IApplicationLifetime lifetime)
{
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(_configuration)
.WriteTo.Console(new JsonFormatter())
.Enrich.FromLogContext()
.CreateLogger();
_logger.LogInformation("Starting service");
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
RunSSHDeamon(lifetime, loggerFactory.CreateLogger("sshd"));
var executor = ShellHelper.Executor.WithWorkingDirectory(_configuration.GetValue <string>("REPO_LOCATION"))
.ForwardEnvVariable("GIT_SSH");
var gitValidationFlow = new GitValidationFlow
{
Validators =
{
(Patterns.Manifests, new CircularDependencyValidator()),
(Patterns.JPad, new CompileJPadValidator())
}
};
var minioConfig = _configuration.GetSection("Minio");
var storageClient = Policy.Handle <Exception>()
.WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)))
.ExecuteAsync(() =>
MinioBucketStorage.GetOrCreateBucket(CreateMinioClient(minioConfig),
minioConfig.GetValue("Bucket", "tweek-ruleset")))
.Result;
var natsClient = new NatsPublisher(_configuration.GetSection("Nats").GetValue <string>("Endpoint"));
var versionPublisher = natsClient.GetSubjectPublisher("version");
var repoSynchronizer = new RepoSynchronizer(executor.WithUser("git").CreateCommandExecutor("git"));
var storageSynchronizer = new StorageSynchronizer(storageClient, executor.WithUser("git"), new Packer());
storageSynchronizer.Sync(repoSynchronizer.CurrentHead().Result, checkForStaleRevision: false).Wait();
RunIntervalPublisher(lifetime, versionPublisher, repoSynchronizer, storageSynchronizer);
var syncActor = SyncActor.Create(storageSynchronizer, repoSynchronizer, natsClient, lifetime.ApplicationStopping, loggerFactory.CreateLogger("SyncActor"));
app.UseRouter(router =>
{
router.MapGet("validate", ValidationHandler.Create(executor, gitValidationFlow, loggerFactory.CreateLogger <ValidationHandler>()));
router.MapGet("sync", SyncHandler.Create(syncActor, _syncPolicy));
router.MapGet("push", PushHandler.Create(syncActor));
router.MapGet("log", async(req, res, routedata) => _logger.LogInformation(req.Query["message"]));
router.MapGet("health", async(req, res, routedata) => await res.WriteAsync(JsonConvert.SerializeObject(new { })));
router.MapGet("version", async(req, res, routedata) => await res.WriteAsync(Assembly.GetEntryAssembly()
.GetCustomAttribute <AssemblyInformationalVersionAttribute>().InformationalVersion));
});
}
/// <inheritdoc />
/// <summary>
/// Sends a request <paramref name="message" /> to <paramref name="recipient" /> and waits for the response of required <paramref name="responseType" />.
/// </summary>
/// <param name="recipient">Reference to recipient actor</param>
/// <param name="message">Request message</param>
/// <param name="responseType"><see cref="T:System.Type" /> of the message to wait for</param>
/// <param name="timeoutMilliseconds">Timeout for the response</param>
/// <param name="throwTimeoutException">If true, the <see cref="T:System.TimeoutException" /> is raised, otherwise the default(T) response is returned</param>
/// <returns>The "synchronous" response</returns>
public object Ask(IActorRef recipient, object message, Type responseType, int timeoutMilliseconds, bool throwTimeoutException = false)
{
if (recipient == null)
{
throw new ArgumentNullException(nameof(recipient));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (responseType == null)
{
throw new ArgumentNullException(nameof(responseType));
}
using (var waitHandle = new AutoResetEvent(false))
{
using (var actor = new SyncActor(this, responseType, waitHandle))
{
recipient.Tell(message, actor.Self);
if (waitHandle.WaitOne(timeoutMilliseconds, false))
{
return(actor.Response.Message);
}
}
}
if (throwTimeoutException)
{
throw new TimeoutException();
}
return(responseType.GetDefaultValue());
}
public static Func <HttpRequest, HttpResponse, RouteData, Task> Create(SyncActor syncActor)
{
return(async(req, res, routedata) =>
{
var commitId = req.Query["commit"].ToString();
try
{
await syncActor.PushToUpstream(commitId);
}
catch (Exception ex)
{
res.StatusCode = 500;
await res.WriteAsync(ex.Message);
}
syncActor.SyncToLatest();
});
}
public static Func <HttpRequest, HttpResponse, RouteData, Task> Create(SyncActor syncActor,
RetryPolicy retryPolicy,
ILogger logger = null)
{
retryPolicy = retryPolicy ?? Policy.Handle <Exception>().RetryAsync();
return(async(req, res, routedata) =>
{
try
{
await retryPolicy
.ExecuteAsync(syncActor.SyncToLatest);
}
catch (Exception ex)
{
res.StatusCode = 500;
await res.WriteAsync(ex.Message);
}
});
}
