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