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