public void Execute(string[] args) { if (args != null && args.Contains("--no-http-bootstrap")) { _logger.Warning("HTTP bootstrapping disabled. No plugins will be downloaded."); return; } if (_configuration.HasDownloadedCorePluginPackages || _configuration.CorePluginPackages == null || !_configuration.CorePluginPackages.Any()) { _logger.Information("Core packages already installed, or no packages specified."); return; } var packages = _configuration.CorePluginPackages.ToList(); _logger.Information("Installing core packages {Packages}.", packages); foreach (var packageId in packages) { // Find latest version of packageId var package = _packageRepository.FindPackage(packageId); if (package == null) { continue; } _packageManager.InstallPackage(package, false, false); } _configuration.HasDownloadedCorePluginPackages = true; _configuration.Save(); }
public async Task When() { using (var conn = TestConnection.Create(_node.TcpEndPoint, TcpType.Ssl, DefaultData.AdminCredentials)) { await conn.ConnectAsync(); var countdown = new CountdownEvent(2); _result = new List <ResolvedEvent>(); conn.SubscribeToStreamFrom(SystemStreams.ScavengesStream, null, CatchUpSubscriptionSettings.Default, (x, y) => { _result.Add(y); countdown.Signal(); return(Task.CompletedTask); }, _ => Log.Information("Processing events started."), (x, y, z) => { Log.Information("Subscription dropped: {0}, {1}.", y, z); } ); if (!countdown.Wait(Timeout)) { Assert.Fail("Timeout expired while waiting for events."); } } }
public static T Deserialize <T>(this ArraySegment <byte> data) where T : IMessage <T>, new() { try { using (var memory = new MemoryStream(data.Array, data.Offset, data.Count) ) //uses original buffer as memory { var res = new T(); res.MergeFrom(memory); return(res); } } catch (Exception e) { Log.Information(e, "Deserialization to {type} failed", typeof(T).FullName); return(default(T)); } }
protected EventStoreCache(IObservable<IConnected<IEventStoreConnection>> eventStoreConnectionStream, ILogger log) { _log = log; Disposables = new CompositeDisposable(_eventsConnection, _eventsSubscription); _connectionChanged = eventStoreConnectionStream.ObserveOn(_eventLoopScheduler) .Publish(); Disposables.Add(_connectionChanged.Connect()); Disposables.Add(_connectionChanged.Subscribe(x => { if (x.IsConnected) { if (_log.IsEnabled(LogEventLevel.Information)) { _log.Information("Connected to Event Store"); } Initialize(x.Value); } else { if (_log.IsEnabled(LogEventLevel.Information)) { _log.Information("Disconnected from Event Store"); } if (!_stateOfTheWorldContainer.IsStale) { _stateOfTheWorldContainer.IsStale = true; _stateOfTheWorldUpdates.OnNext(_stateOfTheWorldContainer); } } })); }
public void BuildPackage(string basePath, IList <string> includes, ManifestMetadata metadata, string outFolder, bool overwrite, bool verboseInfo) { var filename = metadata.Id + "." + metadata.Version + ".zip"; var output = fileSystem.GetFullPath(Path.Combine(outFolder, filename)); if (fileSystem.FileExists(output) && !overwrite) { throw new CommandException("The package file already exists and --overwrite was not specified"); } log.Information("Saving {Filename} to {OutFolder}...", filename, outFolder); fileSystem.EnsureDirectoryExists(outFolder); var logLevel = verboseInfo ? LogEventLevel.Verbose : LogEventLevel.Debug; var basePathLength = fileSystem.GetFullPath(basePath).Length; using (var stream = fileSystem.OpenFile(output, FileAccess.Write)) using (var archive = new ZipArchive(stream, ZipArchiveMode.Create)) { foreach (var pattern in includes) { log.Debug("Adding files from {Path} matching pattern {Pattern}", basePath, pattern); foreach (var file in PathResolver.PerformWildcardSearch(basePath, pattern)) { var fullFilePath = fileSystem.GetFullPath(file); if (string.Equals(fullFilePath, output, StringComparison.CurrentCultureIgnoreCase)) { continue; } var relativePath = UseCrossPlatformDirectorySeparator( fullFilePath.Substring(basePathLength).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)); log.Write(logLevel, "Added file: {relativePath}"); var entry = archive.CreateEntry(relativePath, CompressionLevel.Optimal); entry.LastWriteTime = new DateTimeOffset(new FileInfo(file).LastWriteTime); using (var entryStream = entry.Open()) using (var sourceStream = File.OpenRead(file)) { sourceStream.CopyTo(entryStream); } } } } }
private async Task OnReadEvent(IStreamSubscription arg1, ResolvedEvent arg2, CancellationToken t) { var(m, ev) = _converter.Convert <TEvent>(arg2); var groupName = typeof(TEvent).FullName.Replace(".", "-"); try { await _connection.Clients.All.SendCoreAsync(groupName, new object[] { m, ev }); Log.Information("SignalR hub send event {eventName} to it's clients.", typeof(TEvent).Name); } catch (Exception ex) { Debug.WriteLine(ex); } }
protected DittoWebSocketManager(string ns, string type, string uri, string username, string password) { // Serilog Configuration Log = Processor.Log.CreateLog(type); blKeepRunning = true; ewh = new AutoResetEvent(false); // Start new read thread cts = new CancellationTokenSource(); CancellationToken ct = cts.Token; // Initiate Configuration conf = new Configuration.Connection(uri, username, password); Log.Information("Starting new task to connect to Ditto Websocket..."); t = Task.Factory.StartNew(() => Start(ns), ct); }
public BaseViewModel(IScreen hostScreen = null) { Log = Serilog.Log.ForContext(GetType()); HostScreen = hostScreen ?? Locator.Current.GetService <IScreen>(); _isVisibleSubject = new BehaviorSubject <bool>(false); Log.Information($"Instatiated: {GetType().Name}"); this.WhenActivated(disposables => { HandleActivation(); Disposable .Create(HandleDeactivation) .DisposeWith(disposables); }); }
public IActionResult Index(string shortCode) { _logger.Debug("Entered the redirect for short code {shortCode}", shortCode); var redirectItem = _shortLinkRepo.GetByShortCode(shortCode); if (string.IsNullOrWhiteSpace(redirectItem?.URL)) { _logger.Warning("No redirect found for requested short code {shortCode}", shortCode); return(View("NotFound")); } _logger.Information("Redirecting {shortCode} to {redirectUrl} using tracking Id {gaTrackingId}", redirectItem.ShortLinkCode, redirectItem.URL, _gaOptions.TrackingPropertyId); var viewModel = new RedirectViewModel(_gaOptions.TrackingPropertyId, _redirectOptions.SecondsToWaitForAnalytics, shortCode, redirectItem.URL); return(View("Index", viewModel)); }
private static void ConfigureDynamics(IServiceCollection services, ProjectConfiguration project, ProjectResource projectResource, Serilog.ILogger logger) { Debug.Assert(services != null, "Required ServiceCollection is null"); Debug.Assert(project != null, "Required ProjectConfiguration is null"); Debug.Assert(projectResource != null, "Required ProjectResource is null"); Debug.Assert(projectResource.Type == ProjectType.Dynamics, "Project type must be Dynamics"); // the projectResourceKey convention is repeated also in OAuthClientFactory which gets the HttpClient using the same convention, // // {Id}-dynamics-authorization // string projectResourceKey = project.Id + "-dynamics"; // add authorization HttpClient services.AddHttpClient(projectResourceKey + "-authorization", configure => configure.BaseAddress = projectResource.AuthorizationUri) ; // add odata HttpClient // note: I do not like this IoC anti-pattern where we are using the service locator directly, however, // there are many named dependencies. There may be an opportunity to address this in the future var builder = services.AddHttpClient(projectResourceKey, configure => { configure.BaseAddress = projectResource.Resource; }) .AddHttpMessageHandler(serviceProvider => { // build the token service that talk to the OAuth endpoint IOAuthClientFactory oauthClientFactory = serviceProvider.GetRequiredService <IOAuthClientFactory>(); IOAuthClient client = oauthClientFactory.Create(project); ITokenCache <OAuthOptions, Token> tokenCache = serviceProvider.GetRequiredService <ITokenCache <OAuthOptions, Token> >(); ITokenService tokenService = new OAuthTokenService(client, tokenCache); var handler = new TokenAuthorizationHandler(tokenService, CreateOAuthOptions(projectResource)); return(handler); }); var apiGatewayHost = projectResource.ApiGatewayHost; var apiGatewayPolicy = projectResource.ApiGatewayPolicy; if (!string.IsNullOrEmpty(apiGatewayHost) && !string.IsNullOrEmpty(apiGatewayPolicy)) { // add the ApiGatewayHandler logger.Information("Using {@ApiGateway} for {Resource}", new { Host = apiGatewayHost, Policy = apiGatewayPolicy }, projectResource.Resource); builder.AddHttpMessageHandler(() => new ApiGatewayHandler(apiGatewayHost, apiGatewayPolicy)); } }
public async Task <IEnumerable <OutputMapping1GetListValues> > GetRemedyChangedWorkItems(DateTime fromUtc) { Stopwatch watch = new Stopwatch(); watch.Start(); try { var authInfo = new AuthenticationInfo() { userName = _options.ServiceUserName, password = _options.ServicePassword, authentication = "?", locale = "?", timeZone = "?" }; var remedyResponse = await _remedyClient.New_Get_Operation_0Async( new New_Get_Operation_0Request( authInfo, _options.TemplateName, fromUtc.ToString("O"))); // TODO: apply time component - like format "O" or "yyyy-MM-dd" int count = 0; if (remedyResponse != null && remedyResponse.getListValues != null) { count = remedyResponse.getListValues.Length; } _logger.Information($"Remedy returned { count } changed work item records in { watch.Elapsed.TotalMilliseconds }ms"); return(remedyResponse.getListValues); } catch (Exception err) { // need to find a better way to detect this... if (err.Message.StartsWith("ERROR (302): Entry does not exist in database")) { // none found, so return empty list return(new OutputMapping1GetListValues[] { }); } else { _logger.Error(err, $"Unable to get response from Remedy: { err.Message }"); throw; } } }
private async Task <List <IRecord> > RunAsync(string cypherQuery) { _logger.Information(cypherQuery); var session = _driver.AsyncSession(); try { var result = await session.RunAsync(cypherQuery); return(await result.ToListAsync()); } finally { await session.CloseAsync(); } }
public async Task <int> RunAsync([NotNull] params string[] args) { if (args == null) { throw new ArgumentNullException(nameof(args)); } _logger.Information("Starting Arbor.SyslogServer"); WebHost = HostBuilder.Build(); await WebHost.StartAsync(_cancellationTokenSource.Token); _logger.Debug("Started webhost"); return(0); }
/// <summary> /// Shows progress information is enumerating takes longer /// </summary> /// <param name="e"></param> /// <param name="metric"></param> /// <param name="updateInterval"></param> /// <param name="metricUnit"></param> /// <param name="description"></param> /// <returns></returns> public static IEnumerable <T> Progress <T>(this IEnumerable <T> e, Func <T, double> metric = null, TimeSpan updateInterval = default(TimeSpan), string metricUnit = null, string description = null ) { if (description == null) { description = String.Empty; } else { description = description + " "; } if (metric == null) { metric = (item) => 1.0; } if (updateInterval == default(TimeSpan)) { updateInterval = TimeSpan.FromSeconds(2); } if (metricUnit == null) { metricUnit = String.Empty; } Func <double, string> format = (double x) => x.MetricShort(); var speedUnit = $"{metricUnit}/s"; var progress = ToProgress((ProgressUpdate <T> p) => { Logger.Information("{description}{total}{unit} complete, {speed}{speedUnit}: {item}", description, format(p.Total), metricUnit, format(p.Speed), speedUnit, p.Current); }); return(e.Progress(progress, metric: metric, updateInterval: updateInterval )); }
public bool Acquire() { if (_acquired) { throw new InvalidOperationException(string.Format("DB mutex '{0}' is already acquired.", MutexName)); } try { _dbMutex = new Mutex(initiallyOwned: true, name: MutexName, createdNew: out _acquired); } catch (AbandonedMutexException exc) { Log.Information(exc, "DB mutex '{mutex}' is said to be abandoned. " + "Probably previous instance of server was terminated abruptly.", MutexName); } return(_acquired); }
protected BaseJobRunner( TraffkGlobalDbContext globalContext, IJobInfoFinder jobInfoFinder, ILogger logger) { GlobalContext = globalContext; InstanceId = Interlocked.Increment(ref InstanceId_s); JobInfo = jobInfoFinder.JobInfo; Logger = logger.ForContext(new ILogEventEnricher[] { new PropertyEnricher(nameof(InstanceId), InstanceId), new PropertyEnricher(nameof(JobInfo.JobId), JobInfo?.JobId), new PropertyEnricher(typeof(Type).Name, GetType().Name), }); Logger.Information(ConstructedText); }
public void Configure(IApplicationBuilder app, IApplicationLifetime applicationLifetime, IHostingEnvironment env) { _logger = app.ApplicationServices.GetService <Serilog.ILogger>(); app.UseMvc(); app.Run(async context => { var message = "Invalid route: " + context.Request.Path; _logger.Information(message); context.Response.StatusCode = 404; await context.Response.WriteAsync(message); }); var host = app.ApplicationServices.GetService <PizzaServiceHost>(); applicationLifetime.ApplicationStarted.Register(async() => await host.Start()); applicationLifetime.ApplicationStopping.Register(host.Stop); }
public static IServiceCollection AddSesEmailConfiguration(this IServiceCollection services, IConfiguration configuration, ILogger logger) { if (!string.IsNullOrEmpty(configuration["ses:accessKey"]) && !string.IsNullOrEmpty(configuration["ses:secretKey"])) { var amazonSesKeys = new AmazonSESKeys(configuration["ses:accessKey"], configuration["ses:secretKey"]); services.AddSingleton(amazonSesKeys); var credentals = new BasicAWSCredentials(amazonSesKeys.Accesskey, amazonSesKeys.SecretKey); services.AddTransient <IAmazonSimpleEmailService>( o => new AmazonSimpleEmailServiceClient(credentals, RegionEndpoint.EUWest1)); } else { logger.Information("Secrets not found."); } return(services); }
public async Task PublishAsync(IntegrationEvent @event) { if (!_persistentConnection.IsConnected) { _persistentConnection.TryConnect(); } var eventName = @event.GetType().Name; _logger.Information("Creating RabbitMQ channel to publish event: {0} {1})", @event.Id, eventName); try { using (var channel = _persistentConnection.CreateModel()) { _logger.Information("Declaring RabbitMQ exchange to publish event: {0}", @event.Id); channel.ExchangeDeclare(exchange: BROKER_NAME, ExchangeType.Direct); channel.QueueBind(_queueName, BROKER_NAME, eventName); var message = JsonConvert.SerializeObject(@event); var body = Encoding.UTF8.GetBytes(message); await _retryPolicy.ExecuteAsync(async() => { var properties = channel.CreateBasicProperties(); properties.DeliveryMode = 2; // persistent _logger.Information("Publishing event to RabbitMQ: {0}", @event.Id); channel.BasicPublish(exchange: BROKER_NAME, routingKey: eventName, mandatory: true, basicProperties: properties, body: body); }); } } catch (Exception ex) { _logger.Error("Could not publish event: {0} after ({1})", @event.Id, ex.Message); throw; } }
public virtual Task <GitVersion.VersionVariables> GetVersion() { return(Task.Factory.StartNew(() => { var gitVersionExecuteCore = new GitVersion.ExecuteCore(new GitVersion.Helpers.FileSystem()); string templateString = @"GitVersion: {message}"; GitVersion.Logger.SetLoggers( _ => Logger.Debug(templateString, _), _ => Logger.Debug(templateString, _), _ => Logger.Warning(templateString, _), _ => Logger.Error(templateString, _)); if (!gitVersionExecuteCore.TryGetVersion(RootDirectory, out var versionVariables, true, null)) { throw new System.Exception("Cannot read version"); } Logger.Information("GitVersion: {InformationalVersion}", versionVariables.InformationalVersion); return versionVariables; }, TaskCreationOptions.LongRunning)); }
private void HandleSaveConfigurationCompleted(Action continueWith, ClientMessage.WriteEventsCompleted obj) { switch (obj.Result) { case OperationResult.Success: continueWith(); break; case OperationResult.CommitTimeout: case OperationResult.PrepareTimeout: Log.Information("Timeout while trying to save persistent subscription configuration. Retrying"); SaveConfiguration(continueWith); break; default: throw new Exception(obj.Result + " is an unexpected result writing persistent subscription configuration."); } }
public Task PublishAsync(HealthReport report, CancellationToken cancellationToken) { if (report.Status == HealthStatus.Healthy) { _serilog.Information("{Timestamp} Readiness Probe Status: {Result}", DateTime.UtcNow, report.Status); } else { _serilog.Error("{Timestamp} Readiness Probe Status: {Result}", DateTime.UtcNow, report.Status); ReportEntriesAsError(report); } cancellationToken.ThrowIfCancellationRequested(); return(Task.CompletedTask); }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { var messageFormat = formatter(state, exception); switch (logLevel) { case LogLevel.Error: logger.Error(messageFormat); break; case LogLevel.Information: logger.Information(messageFormat); break; case LogLevel.Warning: logger.Warning(messageFormat); break; } }
public static IServiceCollection AddGroupConfiguration(this IServiceCollection services, IConfiguration configuration, ILogger logger) { if (!string.IsNullOrEmpty(configuration["group:authenticationKey"])) { var groupKeys = new GroupAuthenticationKeys { Key = configuration["group:authenticationKey"] }; services.AddSingleton(groupKeys); services.AddScoped(p => new GroupAuthorisation(p.GetService <IApplicationConfiguration>(), p.GetService <ILoggedInHelper>())); services.AddSingleton <IJwtDecoder>(p => new JwtDecoder(p.GetService <GroupAuthenticationKeys>(), p.GetService <ILogger <JwtDecoder> >())); } else { logger.Information("Group authenticationKey not found."); } return(services); }
public Task StartAsync(CancellationToken cancellationToken) { Logger.Information($"Starting proto cluster node on {_nodeAddress}:{_nodePort}"); Serialization.RegisterFileDescriptor(CommandsReflection.Descriptor); var eventStoreProvider = new EventStoreProvider(_eventStoreConnection) .WithTypeResolver( t => TypeMapper.GetTypeName(t), s => Type.GetType(s)); var measuredStore = new MeasuredActorStore(eventStoreProvider); Remote.RegisterKnownKind("Vehicle", Props.FromProducer(() => new VehicleActor(measuredStore)) .WithReceiverMiddleware(next => Middleware.Metrics(next, "Vehicle"))); Cluster.Start(_clusterName, _nodeAddress, _nodePort, _consulProvider); return(Task.CompletedTask); }
public void Log(string message, LogLevel logLevel) { switch (logLevel) { case LogLevel.Information: _serilog.Information(message); break; case LogLevel.Error: _serilog.Error(message); break; case LogLevel.Fatal: _serilog.Fatal(message); break; default: break; } }
public async Task <EventEnvelope[]> Append(Guid key, ulong version, Guid correlationId, IEnumerable <IEvent> published) { var streamName = GetStreamName(key); var publishedArray = published as IEvent[] ?? published.ToArray(); EventEnvelope[] data = new EventEnvelope[publishedArray.Length]; for (ulong i = 0; i < (ulong)publishedArray.Length; i++) { var ev = publishedArray[i]; data[i] = new EventEnvelope(ev, _metadataFactory.Create(key, correlationId, ev, version + i)); } var evData = data.Select(_eventDataFactory.Create); await _connection.AppendToStreamAsync(streamName, new StreamRevision(version), evData); _logger.Information("Writing event to stream {streamName} {eventNames}", streamName, publishedArray.Select(x => x.GetType().Name).ToArray()); return(data); }
private void CompleteInterruptedScavenges(IList <string> incompletedScavenges) { if (incompletedScavenges.Count == 0) { Log.Debug("No incomplete scavenges found on node {nodeEndPoint}.", _nodeEndpoint); } else { Log.Information( "Found {incomplete} incomplete scavenge{s} on node {nodeEndPoint}. Marking as failed:{newLine}{incompleteScavenges}", incompletedScavenges.Count, incompletedScavenges.Count == 1 ? "" : "s", _nodeEndpoint, Environment.NewLine, string.Join(Environment.NewLine, incompletedScavenges)); } foreach (var incompletedScavenge in incompletedScavenges) { var log = CreateLogInternal(incompletedScavenge); log.ScavengeCompleted(ScavengeResult.Failed, "The node was restarted.", TimeSpan.Zero); } }
protected EventStoreHostedService(string[] args) { try { Options = EventStoreOptions.Parse <TOptions>(args, Opts.EnvPrefix, Path.Combine(Locations.DefaultConfigurationDirectory, DefaultFiles.DefaultConfigFile), MutateEffectiveOptions); if (Options.Help) { Console.WriteLine("EventStoreDB version {0} ({1}/{2}, {3})", VersionInfo.Version, VersionInfo.Branch, VersionInfo.Hashtag, VersionInfo.Timestamp); Console.WriteLine(); Console.WriteLine(EventStoreOptions.GetUsage <TOptions>()); _skipRun = true; } else if (Options.Version) { Console.WriteLine("EventStoreDB version {0} ({1}/{2}, {3})", VersionInfo.Version, VersionInfo.Branch, VersionInfo.Hashtag, VersionInfo.Timestamp); _skipRun = true; } else { PreInit(Options); Init(Options); Create(Options); } } catch (OptionException exc) { Log.Error("Error while parsing options:"); Log.Error(FormatExceptionMessage(exc)); Log.Information("Options:"); Log.Information(EventStoreOptions.GetUsage <TOptions>()); _skipRun = true; } catch (InvalidConfigurationException exc) { Log.Error("Invalid Configuration Encountered"); Log.Error(exc.Message); _skipRun = true; } }
public async Task Handle(InitiativeStatusDescriptionUpdatedDomainEvent notification, CancellationToken cancellationToken) { _logger.Debug("Initiative Status Description changed, will post message to service bus"); var initiative = await _initiativeRepository.GetInitiativeAsync(notification.InitiativeId); if (initiative == null) { _logger.Error("Received new initiave event but couldn't get initiative with id {InitiativeUid}", notification.InitiativeId); throw new Exception($"Received new initiave event but couldn't get initiative with id {notification.InitiativeId}"); } else { _logger.Information("Posting StatusDescriptionChanged event to service bus for Initiative {InitiativeId}", initiative.Id); } await _initiativeMessageSender.SendInitiativeStatusDescriptionChangedAsync(new InitiativeStatusDescriptionChangedEventArgs() { Initiative = initiative, Owner = _currentUserAccessor.User }); }