public RiakStorer(IRiakClient riakClient, IEventWriter eventWriter) { if (riakClient == null) throw new ArgumentNullException("riakClient"); if (eventWriter == null) throw new ArgumentNullException("eventWriter"); _riakClient = riakClient; _eventWriter = eventWriter; }
public FileSystemStorer(RepositoryHierarchy repositoryHierarchy, IEventWriter eventWriter) { if (repositoryHierarchy == null) throw new ArgumentNullException("repositoryHierarchy"); if (eventWriter == null) throw new ArgumentNullException("eventWriter"); _repositoryHierarchy = repositoryHierarchy; _eventWriter = eventWriter; }
public void EmitEvents(IEventWriter eventWriter) { if (_states.Count > 0) { var list = new List <EmittedEventEnvelope>(); foreach (var entry in _states) { var partition = entry.Key; var streamId = _namingBuilder.MakePartitionCheckpointStreamName(partition); var data = entry.Value.PartitionState.Serialize(); var causedBy = entry.Value.PartitionState.CausedBy; var expectedTag = entry.Value.ExpectedTag; list.Add( new EmittedEventEnvelope( new EmittedDataEvent( streamId, Guid.NewGuid(), ProjectionEventTypes.PartitionCheckpoint, true, data, null, causedBy, expectedTag), _partitionCheckpointStreamMetadata)); } //NOTE: order yb is required to satisfy internal emit events validation // which ensures that events are ordered by causedBy tag. // it is too strong check, but ... eventWriter.ValidateOrderAndEmitEvents(list.OrderBy(v => v.Event.CausedByTag).ToArray()); } }
/// <summary> /// Creates a new instance configured to output to the given writer. /// </summary> /// <param name="eventSource"> /// The event source to listen to. /// </param> /// <param name="writer">The TextWriter where to send the output. Note that the writer will be disposed when the TextWriterEventListener is itself disposed.</param> /// <param name="baseTime"> /// The UTC time representing time 0 for this listener. /// </param> /// <param name="warningMapper"> /// An optional delegate that is used to map warnings into errors or to suppress warnings. /// </param> /// <param name="level"> /// The base level of data to be sent to the listener. /// </param> /// <param name="timeDisplay"> /// The kind of time prefix to apply to each chunk of output. /// </param> /// <param name="eventMask"> /// If specified, an EventMask that allows selectively enabling or disabling events /// </param> /// <param name="onDisabledDueToDiskWriteFailure"> /// If specified, called if the listener encounters a disk-write failure such as an out of space condition. /// Otherwise, such conditions will throw an exception. /// </param> /// <param name="pathTranslator"> /// If specified, translates paths from one root to another /// </param> /// <param name="listenDiagnosticMessages"> /// If true, all messages tagged with <see cref="Keywords.Diagnostics" /> at or above <paramref name="level"/> are enabled but not captured unless diagnostics are enabled per-task. /// This is useful for StatisticsEventListener, where you need to listen diagnostics messages but capture only ones tagged with CommonInfrastructure task. /// </param> public TextWriterEventListener( Events eventSource, IEventWriter writer, DateTime baseTime, WarningMapper warningMapper = null, EventLevel level = EventLevel.Verbose, TimeDisplay timeDisplay = TimeDisplay.None, EventMask eventMask = null, DisabledDueToDiskWriteFailureEventHandler onDisabledDueToDiskWriteFailure = null, PathTranslator pathTranslator = null, bool listenDiagnosticMessages = false) : base( eventSource, baseTime, warningMapper, level, false, timeDisplay, eventMask, onDisabledDueToDiskWriteFailure, listenDiagnosticMessages) { Contract.Requires(eventSource != null); Contract.Requires(writer != null); m_writer = writer; m_flushTimer = new StoppableTimer( SynchronizedFlush, (int)s_flushInterval.TotalMilliseconds, (int)s_flushInterval.TotalMilliseconds); m_translator = pathTranslator; }
/// <summary> /// Loads extensions from the configuration file /// </summary> /// <param name="id">Extension ID</param> /// <param name="logger">Logger</param> /// <exception cref="ExtensionException">Loading failure</exception> private void LoadExtension(string id, IEventWriter logger) { if (Extensions.ContainsKey(id)) { throw new ExtensionException(id, "Extension has been already loaded"); } var extensionsConfig = ServiceDescriptor.ExtensionsConfiguration; XmlElement configNode = (extensionsConfig != null) ? extensionsConfig.SelectSingleNode("extension[@id='" + id + "'][1]") as XmlElement : null; if (configNode == null) { throw new ExtensionException(id, "Cannot get the configuration entry"); } var descriptor = WinSWExtensionDescriptor.FromXml(configNode); if (descriptor.Enabled) { IWinSWExtension extension = CreateExtensionInstance(descriptor.Id, descriptor.ClassName); extension.Descriptor = descriptor; extension.Configure(ServiceDescriptor, configNode, logger); Extensions.Add(id, extension); logger.LogEvent("Extension loaded: " + id, EventLogEntryType.Information); } else { logger.LogEvent("Extension is disabled: " + id, EventLogEntryType.Warning); } }
/// <summary> /// Stops all extensions /// </summary> /// <exception cref="ExtensionException">Stop failure</exception> public void OnStop(IEventWriter logger) { foreach (var ext in Extensions) { ext.Value.OnStop(logger); } }
public override void Configure(ServiceDescriptor descriptor, XmlNode node, IEventWriter logger) { // We expect the upper logic to process any errors // TODO: a better parser API for types would be useful Pidfile = XmlHelper.SingleElement(node, "pidfile", false); StopTimeout = TimeSpan.FromMilliseconds(Int32.Parse(XmlHelper.SingleElement(node, "stopTimeout", false))); StopParentProcessFirst = Boolean.Parse(XmlHelper.SingleElement(node, "stopParentFirst", false)); ServiceId = descriptor.Id; }
private void HandleMappingError(SharedDirectoryMapperConfig config, IEventWriter eventWriter, MapperException ex) { String prefix = "Mapping of " + config.Label + " "; eventWriter.LogEvent(prefix + "STDOUT: " + ex.Process.StandardOutput.ReadToEnd(), EventLogEntryType.Information); eventWriter.LogEvent(prefix + "STDERR: " + ex.Process.StandardError.ReadToEnd(), EventLogEntryType.Information); throw new ExtensionException(Descriptor.Id, DisplayName + ": " + prefix + "failed", ex); }
//TODO: Implement loading of external extensions. Current version supports internal hack #region Extension load management public void LoadExtensions(IEventWriter logger) { var extensionIds = ServiceDescriptor.ExtensionIds; foreach (String extensionId in extensionIds) { LoadExtension(extensionId, logger); } }
public CommandIntake(Func <JsonDocument, PointsEvent> eventsFactory, Func <int> maxPointsPerAction, IGameTimer gameTimer, IEventWriter <PointsEvent> pointsEventWriter, PlayerCache playerCache, PlayerStorage playerStorage) { _eventsFactory = eventsFactory; _maxPointsPerAction = maxPointsPerAction; _gameTimer = gameTimer; _pointsEventWriter = pointsEventWriter; _playerCache = playerCache; _playerStorage = playerStorage; }
/// <summary> /// Deserialization constructor /// </summary> /// <param name="info">Serialization info</param> /// <param name="context">Streaming context</param> protected ImportedEventWriter(SerializationInfo info, StreamingContext context) { eventWriter = info.Deserialize <IEventWriter>("EventWriter"); condition = info.GetString("Condition"); measurementsList = info.GetValue("Measurements", typeof(List <string>)) as List <string>; if (eventWriter is IAssociatedObject) { children = new IAssociatedObject[] { eventWriter as IAssociatedObject }; } }
/// <summary> /// Constructor /// </summary> /// <param name="type">Type of imported object</param> public ImportedEventWriter(string type) { Type t = Type.GetType(type); ConstructorInfo ci = t.GetConstructor(new Type[0]); eventWriter = ci.Invoke(new object[0]) as IEventWriter; if (eventWriter is IAssociatedObject) { children = new IAssociatedObject[] { eventWriter as IAssociatedObject }; } }
/// <summary> /// Creates a new instance of the default aggregate store /// </summary> /// <param name="reader"></param> /// <param name="writer"></param> /// <param name="amendEvent"></param> /// <param name="factoryRegistry"></param> public AggregateStore( IEventReader reader, IEventWriter writer, Func <StreamEvent, StreamEvent>?amendEvent = null, AggregateFactoryRegistry?factoryRegistry = null ) { _amendEvent = amendEvent ?? (x => x); _factoryRegistry = factoryRegistry ?? AggregateFactoryRegistry.Instance; _eventReader = Ensure.NotNull(reader); _eventWriter = Ensure.NotNull(writer); }
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger <Startup> logger) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } logger.LogInformation("Service is starting..."); app.UseRouting(); var eventReader = new CloudEventReader(logger); var configReader = new ConfigReader(logger); var bucketExpected = configReader.Read("BUCKET"); IEventWriter eventWriter = configReader.ReadEventWriter(CloudEventSource, CloudEventType); IBucketEventDataReader bucketEventDataReader = configReader.ReadEventDataReader(); app.UseEndpoints(endpoints => { endpoints.MapPost("/", async context => { logger.LogInformation("Reading event"); var cloudEvent = await eventReader.Read(context); logger.LogInformation("Getting Bucket"); var(bucket, name) = bucketEventDataReader.Read(cloudEvent); // This is only needed in Cloud Run (Managed) when the // events are not filtered by bucket yet. if (bucket != bucketExpected) { logger.LogInformation($"Input bucket '{bucket}' does not match with expected bucket '{bucketExpected}'"); return; } var storageUrl = $"gs://{bucket}/{name}"; logger.LogInformation($"Storage url: {storageUrl}"); var safe = await IsPictureSafe(storageUrl); logger.LogInformation($"Is the picture safe? {safe}"); if (!safe) { return; } var replyData = JsonConvert.SerializeObject(new { bucket = bucket, name = name }); await eventWriter.Write(replyData, context); }); }); }
// Token: 0x06003234 RID: 12852 RVA: 0x001470DC File Offset: 0x001452DC private void ProcessEvents(WritingSettings settings, Action <IEventWriter, MidiEvent, bool> eventHandler) { byte?b = null; bool flag = true; bool flag2 = true; bool flag3 = true; foreach (MidiEvent midiEvent in this.Events.Concat(new EndOfTrackEvent[] { new EndOfTrackEvent() })) { if (!(midiEvent is UnknownMetaEvent) || !settings.CompressionPolicy.HasFlag(CompressionPolicy.DeleteUnknownMetaEvents)) { if (settings.CompressionPolicy.HasFlag(CompressionPolicy.NoteOffAsSilentNoteOn)) { NoteOffEvent noteOffEvent = midiEvent as NoteOffEvent; if (noteOffEvent != null) { midiEvent = new NoteOnEvent { DeltaTime = noteOffEvent.DeltaTime, Channel = noteOffEvent.Channel, NoteNumber = noteOffEvent.NoteNumber }; } } if ((!settings.CompressionPolicy.HasFlag(CompressionPolicy.DeleteDefaultSetTempo) || !TrackChunk.TrySkipDefaultSetTempo(midiEvent, ref flag)) && (!settings.CompressionPolicy.HasFlag(CompressionPolicy.DeleteDefaultKeySignature) || !TrackChunk.TrySkipDefaultKeySignature(midiEvent, ref flag2)) && (!settings.CompressionPolicy.HasFlag(CompressionPolicy.DeleteDefaultTimeSignature) || !TrackChunk.TrySkipDefaultTimeSignature(midiEvent, ref flag3))) { IEventWriter writer = EventWriterFactory.GetWriter(midiEvent); bool arg; if (midiEvent is ChannelEvent) { byte statusByte = writer.GetStatusByte(midiEvent); byte?b2 = b; int? num = (b2 != null) ? new int?((int)b2.GetValueOrDefault()) : null; int num2 = (int)statusByte; arg = (!(num.GetValueOrDefault() == num2 & num != null) || !settings.CompressionPolicy.HasFlag(CompressionPolicy.UseRunningStatus)); b = new byte?(statusByte); } else { b = null; arg = true; } eventHandler(writer, midiEvent, arg); } } } }
/// <summary> /// Initializes a new instance of the <see cref="ScheduleController" /> class. /// </summary> /// <exception cref="System.ArgumentNullException">eventLoader /// or /// eventWriter</exception> public ScheduleController(IEventLoader eventLoader, IEventWriter eventWriter) { if (eventLoader == null) { throw new ArgumentNullException(nameof(eventLoader)); } if (eventWriter == null) { throw new ArgumentNullException(nameof(eventWriter)); } _eventLoader = eventLoader; }
private EventStoreContext(IEventStoreConnection connection, IStreamNamer streamNamer, IEventReader reader, IEventWriter writer, IDomainObjectActivator activator) { Precondition.For(connection, nameof(connection)).NotNull(); Precondition.For(streamNamer, nameof(streamNamer)).NotNull(); Precondition.For(reader, nameof(reader)).NotNull(); Precondition.For(writer, nameof(writer)).NotNull(); Precondition.For(activator, nameof(activator)).NotNull(); Connection = connection; Reader = reader; Writer = writer; Activator = activator; StreamNamer = streamNamer; }
public EventStore(JsonSerializer jsonSerializer, string path) { if (jsonSerializer == null) { throw new ArgumentNullException(nameof(jsonSerializer)); } if (string.IsNullOrWhiteSpace(path)) { throw new ArgumentNullException(nameof(path)); } this.writer = new EventWriter(jsonSerializer, path, readWriteSemaphore); this.reader = new EventReader(jsonSerializer, path, readWriteSemaphore); }
public PlantUmlTypeWriter( IQueryType queryType, ITypeNameWriter typeNameWriter, ITypeNameWriter escapedTypeNameWriter, IEventWriter eventWriter, IMethodWriter methodWriter, IFieldWriter fieldWriter, IPropertyWriter propertyWriter) { _queryType = queryType; _typeNameWriter = typeNameWriter; _escapedTypeNameWriter = escapedTypeNameWriter; _eventWriter = eventWriter; _methodWriter = methodWriter; _fieldWriter = fieldWriter; _propertyWriter = propertyWriter; }
public override void OnStop(IEventWriter eventWriter) { foreach (SharedDirectoryMapperConfig config in _entries) { if (config.EnableMapping) { try { _mapper.UnmapDirectory(config.Label); } catch (MapperException ex) { HandleMappingError(config, eventWriter, ex); } } } }
public SimpleTypeWriter( ITypeQueryFactory typeQueryFactory, ITypeNameWriter typeNameWriter, ITypeNameConverter typeNameConverter, IEventWriter eventWriter, IMethodWriter methodWriter, IFieldWriter fieldWriter, IPropertyWriter propertyWriter) { _typeQueryFactory = typeQueryFactory; _typeNameWriter = typeNameWriter; _typeNameConverter = typeNameConverter; _eventWriter = eventWriter; _methodWriter = methodWriter; _fieldWriter = fieldWriter; _propertyWriter = propertyWriter; }
public override void Configure(ServiceDescriptor descriptor, XmlNode node, IEventWriter logger) { var nodes = XmlHelper.SingleNode(node, "mapping", false).SelectNodes("map"); if (nodes != null) { foreach (XmlNode mapNode in nodes) { var mapElement = mapNode as XmlElement; if (mapElement != null) { var config = SharedDirectoryMapperConfig.FromXml(mapElement); _entries.Add(config); } } } }
public static IEventWriter Load() { IEventWriter writer = null; switch (eXtensibleConfig.LoggingStrategy) { case LoggingStrategyOption.None: break; case LoggingStrategyOption.Output: writer = new DebugEventWriter(); break; case LoggingStrategyOption.CommonServices: writer = new CommonServicesWriter(); break; case LoggingStrategyOption.WindowsEventLog: writer = new EventLogWriter(); break; case LoggingStrategyOption.Silent: writer = new EventLogWriter(); break; case LoggingStrategyOption.XFTool: writer = new XFToolWriter(); break; case LoggingStrategyOption.Plugin: writer = PluginLoader.LoadReferencedAssembly <IEventWriter>().FirstOrDefault() as IEventWriter; break; case LoggingStrategyOption.Datastore: writer = new DatastoreEventWriter(); break; default: break; } //return new EventLogWriter() as IEventWriter; return(writer); }
public static IDisposable SetupLogging(EventLevel level, IEventWriter writer) { var eventListener = new TextWriterEventListener(eventSource: Events.Log, writer: writer, baseTime: DateTime.UtcNow, level: level); var primarySource = bxl.ETWLogger.Log; if (primarySource.ConstructionException != null) { // Rethrow an exception preserving the original stack trace. var edi = ExceptionDispatchInfo.Capture(primarySource.ConstructionException); edi.Throw(); // This code is unreachable, but compiler doesn't know about it. throw null; } eventListener.RegisterEventSource(primarySource); eventListener.EnableTaskDiagnostics(BuildXL.Tracing.ETWLogger.Tasks.CommonInfrastructure); AriaV2StaticState.Enable(AriaTenantToken.Key); var eventSources = new EventSource[] { bxl.ETWLogger.Log, BuildXL.Engine.Cache.ETWLogger.Log, BuildXL.Engine.ETWLogger.Log, BuildXL.Scheduler.ETWLogger.Log, BuildXL.Tracing.ETWLogger.Log, bxlScriptAnalyzer.ETWLogger.Log, BuildXL.Ide.LanguageServer.ETWLogger.Log, BuildXL.FrontEnd.Core.ETWLogger.Log, BuildXL.FrontEnd.Script.ETWLogger.Log, BuildXL.FrontEnd.Nuget.ETWLogger.Log, }; using (var listener = new TrackingEventListener(Events.Log)) { foreach (var eventSource in eventSources) { Events.Log.RegisterMergedEventSource(eventSource); } } return(eventListener); }
public static async Task <AppendEventsResult> Store <T>( this IEventWriter eventWriter, StreamName streamName, T aggregate, Func <StreamEvent, StreamEvent> amendEvent, CancellationToken cancellationToken ) where T : Aggregate { Ensure.NotNull(aggregate); if (aggregate.Changes.Count == 0) { return(AppendEventsResult.NoOp); } var originalVersion = aggregate.OriginalVersion; var expectedVersion = new ExpectedStreamVersion(originalVersion); try { var result = await eventWriter.AppendEvents( streamName, expectedVersion, aggregate.Changes.Select((o, i) => ToStreamEvent(o, i + originalVersion)).ToArray(), cancellationToken ) .NoContext(); return(result); } catch (Exception e) { Log.UnableToStoreAggregate(aggregate, e); throw e.InnerException?.Message.Contains("WrongExpectedVersion") == true ? new OptimisticConcurrencyException <T>(aggregate, e) : e; } StreamEvent ToStreamEvent(object evt, int position) { var streamEvent = new StreamEvent(Guid.NewGuid(), evt, new Metadata(), "", position); return(amendEvent(streamEvent)); } }
public void EmitEvents(IEventWriter eventWriter) { if (_states.Count > 0) { var list = new List<EmittedEvent>(); foreach (var entry in _states) { var partition = entry.Key; var streamId = _namingBuilder.MakePartitionCheckpointStreamName(partition); var data = entry.Value.Data; var causedBy = entry.Value.CausedByTag; var expectedTag = entry.Value.ExpectedTag; list.Add(new EmittedEvent(streamId, Guid.NewGuid(), "Checkpoint", data, causedBy, expectedTag)); } //NOTE: order yb is required to satisfy internal emit events validation // whih ensures that events are ordered by causeby tag. // it is too strong check, but ... eventWriter.ValidateOrderAndEmitEvents(list.OrderBy(v => v.CausedByTag).ToArray()); } }
private static IEventWriter LoadDatastoreEventWriter() { IEventWriter provider = null; List <string> list = new List <string>() { AppDomain.CurrentDomain.BaseDirectory, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bin"), }; if (Directory.Exists(eXtensibleConfig.ConfigurationProviderPlugins)) { list.Add(eXtensibleConfig.ConfigurationProviderPlugins); } try { EventWriterModule module = null; ModuleLoader <EventWriterModule> loader = new ModuleLoader <EventWriterModule>() { Folderpaths = list }; if (loader.Load(out module) && module.Providers != null && module.Providers.Count > 0) { provider = module.Providers.Find(x => !x.GetType().Equals(typeof(DatastoreEventWriter))); } } catch (Exception ex) { string message = ex.InnerException != null ? ex.InnerException.Message : ex.Message; IEventWriter writer = new EventLogWriter(); writer.WriteError(message, SeverityType.Critical, "EventWriterModule"); } if (provider == null) { provider = new DatastoreEventWriter(); } return(provider); }
public override void OnStart(IEventWriter eventWriter) { foreach (SharedDirectoryMapperConfig config in _entries) { if (config.EnableMapping) { eventWriter.LogEvent(DisplayName + ": Mapping shared directory " + config.UNCPath + " to " + config.Label, EventLogEntryType.Information); try { _mapper.MapDirectory(config.Label, config.UNCPath); } catch (MapperException ex) { HandleMappingError(config, eventWriter, ex); } } else { eventWriter.LogEvent(DisplayName + ": Mapping of " + config.Label + " is disabled", EventLogEntryType.Warning); } } }
static ITypeWriter CreatePlantUmlTypeWriter() { bool writeMembers = true; var queryType = new QueryType(new TypeQueryOptions()); var normalTypeNameConverter = new SimpleTypeNameConverter(); var escapingTypeNameConverter = new EscapingTypenameConverter(); var normalTypeNameWriter = new SimpleTypeNameWriter(normalTypeNameConverter); var escapedTypeNameWriter = new SimpleTypeNameWriter(escapingTypeNameConverter); IPropertyWriter propertyWriter = writeMembers ? new PropertyWriter(normalTypeNameWriter) : new EmptyPropertyWriter(); IMethodWriter methodWriter = writeMembers ? new MethodWriter(normalTypeNameConverter, normalTypeNameWriter) : new EmptyMethodWriter(); IFieldWriter fieldWriter = writeMembers ? new FieldWriter(normalTypeNameWriter) : new EmptyFieldWriter(); IEventWriter eventWriter = writeMembers ? new EventWriter(normalTypeNameWriter) : new EmptyEventWriter(); return(new PlantUmlTypeWriter( queryType, normalTypeNameWriter, escapedTypeNameWriter, eventWriter, methodWriter, fieldWriter, propertyWriter)); }
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger <Startup> logger) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } logger.LogInformation("Service is starting..."); app.UseRouting(); var eventReader = new CloudEventReader(logger); var configReader = new ConfigReader(logger); var projectId = configReader.Read("PROJECT_ID"); IEventWriter eventWriter = configReader.ReadEventWriter(CloudEventSource, CloudEventType); app.UseEndpoints(endpoints => { endpoints.MapPost("/", async context => { var client = await BigQueryClient.CreateAsync(projectId); var cloudEvent = await eventReader.Read(context); var country = ReadCountry(cloudEvent); _tableId = country.Replace(" ", "").ToLowerInvariant(); var results = await RunQuery(client, country, logger); logger.LogInformation("Executed query"); var replyData = JsonConvert.SerializeObject(new { datasetId = DatasetId, tableId = _tableId, country = country }); await eventWriter.Write(replyData, context); }); }); }
public void EmitEvents(IEventWriter eventWriter) { if (_states.Count > 0) { var list = new List<EmittedEventEnvelope>(); foreach (var entry in _states) { var partition = entry.Key; var streamId = _namingBuilder.MakePartitionCheckpointStreamName(partition); var data = entry.Value.PartitionState.Serialize(); var causedBy = entry.Value.PartitionState.CausedBy; var expectedTag = entry.Value.ExpectedTag; list.Add( new EmittedEventEnvelope( new EmittedDataEvent( streamId, Guid.NewGuid(), ProjectionEventTypes.PartitionCheckpoint, true, data, null, causedBy, expectedTag), _partitionCheckpointStreamMetadata)); } //NOTE: order yb is required to satisfy internal emit events validation // which ensures that events are ordered by causedBy tag. // it is too strong check, but ... eventWriter.ValidateOrderAndEmitEvents(list.OrderBy(v => v.Event.CausedByTag).ToArray()); } }
public ProtocolChoicePromptHandler(IEventWriter eventWriter) { this.eventWriter = eventWriter; }
public ProtocolPromptHandlerContext(IEventWriter eventWriter) { this.eventWriter = eventWriter; }
private void ProcessEvents(WritingSettings settings, Action <IEventWriter, MidiEvent, bool> eventHandler) { byte?runningStatus = null; var writeStatusByte = true; var skipSetTempo = true; var skipKeySignature = true; var skipTimeSignature = true; foreach (var midiEvent in Events.Concat(new[] { new EndOfTrackEvent() })) { var eventToWrite = midiEvent; if (eventToWrite is UnknownMetaEvent && settings.CompressionPolicy.HasFlag(CompressionPolicy.DeleteUnknownMetaEvents)) { continue; } // if (settings.CompressionPolicy.HasFlag(CompressionPolicy.NoteOffAsSilentNoteOn)) { var noteOffEvent = eventToWrite as NoteOffEvent; if (noteOffEvent != null) { eventToWrite = new NoteOnEvent { DeltaTime = noteOffEvent.DeltaTime, Channel = noteOffEvent.Channel, NoteNumber = noteOffEvent.NoteNumber } } ; } // if (settings.CompressionPolicy.HasFlag(CompressionPolicy.DeleteDefaultSetTempo) && TrySkipDefaultSetTempo(eventToWrite, ref skipSetTempo)) { continue; } if (settings.CompressionPolicy.HasFlag(CompressionPolicy.DeleteDefaultKeySignature) && TrySkipDefaultKeySignature(eventToWrite, ref skipKeySignature)) { continue; } if (settings.CompressionPolicy.HasFlag(CompressionPolicy.DeleteDefaultTimeSignature) && TrySkipDefaultTimeSignature(eventToWrite, ref skipTimeSignature)) { continue; } // IEventWriter eventWriter = EventWriterFactory.GetWriter(eventToWrite); if (eventToWrite is ChannelEvent) { var statusByte = eventWriter.GetStatusByte(eventToWrite); writeStatusByte = runningStatus != statusByte || !settings.CompressionPolicy.HasFlag(CompressionPolicy.UseRunningStatus); runningStatus = statusByte; } else { runningStatus = null; writeStatusByte = true; } // eventHandler(eventWriter, eventToWrite, writeStatusByte); } }
public EventReaderWriterPair(IEventReader reader, IEventWriter writer) : this() { Reader = reader; Writer = writer; }
public EventService(IEventContextResolverService eventContextResolverService, IEventWriter eventWriter) { _eventContextResolverService = eventContextResolverService ?? throw new ArgumentNullException(nameof(eventContextResolverService)); _eventWriter = eventWriter ?? throw new ArgumentNullException(nameof(eventWriter)); }
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger <Startup> logger) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } logger.LogInformation("Service is starting..."); app.UseRouting(); var eventReader = new CloudEventReader(logger); var configReader = new ConfigReader(logger, CloudEventSource, CloudEventType); var outputBucket = configReader.Read("BUCKET"); IEventWriter eventWriter = configReader.ReadEventWriter(); app.UseEndpoints(endpoints => { endpoints.MapPost("/", async context => { try { var(bucket, name) = await eventReader.ReadCloudStorageData(context); using (var inputStream = new MemoryStream()) { var client = await StorageClient.CreateAsync(); await client.DownloadObjectAsync(bucket, name, inputStream); logger.LogInformation($"Downloaded '{name}' from bucket '{bucket}'"); using (var outputStream = new MemoryStream()) { inputStream.Position = 0; // Reset to read using (Image image = Image.Load(inputStream)) { image.Mutate(x => x .Resize(ThumbWidth, ThumbHeight) ); logger.LogInformation($"Resized image '{name}' to {ThumbWidth}x{ThumbHeight}"); image.SaveAsPng(outputStream); } var outputObjectName = $"{Path.GetFileNameWithoutExtension(name)}-{ThumbWidth}x{ThumbHeight}.png"; await client.UploadObjectAsync(outputBucket, outputObjectName, "image/png", outputStream); logger.LogInformation($"Uploaded '{outputObjectName}' to bucket '{outputBucket}'"); var replyData = new { bucket = outputBucket, name = outputObjectName }; await eventWriter.Write(replyData, context); } } } catch (Exception e) { logger.LogError($"Error processing: " + e.Message); throw e; } }); }); }
public RiakStorer(IEventWriter eventWriter) { if (eventWriter == null) throw new ArgumentNullException("eventWriter"); _eventWriter = eventWriter; }