private EventDocument Convert(
object evt,
IStreamMetadata metadata,
long version,
string?correlationId,
string?causationId,
DateTimeOffset timestamp)
{
var eventId = eventIdProvider.CreateUniqueId(metadata);
var streamId = metadata.StreamId.Value;
var name = nameProvider.GetName(evt);
return(new EventDocument <object>
{
Id = eventId,
PartitionKey = streamId,
Data = evt,
Properties = new EventMetadata
{
CausationId = causationId,
CorrelationId = correlationId,
EventId = eventId,
StreamId = streamId,
Version = version,
Timestamp = timestamp,
Name = name,
},
});
}
/// <summary>
/// Updates a stream binding in response to a session being opened or closed.
/// </summary>
/// <param name="session">The session to attempt to bind to.</param>
/// <returns>The result of the binding update operation.</returns>
public StreamBindingResult Update(Session session)
{
// If there's no session, then we have nothing to bind to
if (session != null)
{
// Check that a partition with the required name exists in the session
IPartition partition = session.Partitions.FirstOrDefault(p => p.Name == this.PartitionName);
if (partition != null)
{
// Check that the partition contains a stream with the same name as this binding object
IStreamMetadata streamMetadata = partition.AvailableStreams.FirstOrDefault(s => s.Name == this.StreamName);
if (streamMetadata != null)
{
// Check if the binding has actually changed
if ((this.StoreName == partition.StoreName) && (this.StorePath == partition.StorePath) && (this.StreamMetadata == streamMetadata))
{
return(StreamBindingResult.BindingUnchanged);
}
this.StoreName = partition.StoreName;
this.StorePath = partition.StorePath;
this.StreamMetadata = streamMetadata;
return(StreamBindingResult.BoundToNewSource);
}
}
}
this.StoreName = null;
this.StorePath = null;
this.StreamMetadata = null;
return(StreamBindingResult.NoSourceToBindTo);
}
public StreamBatch FromEvents(
IReadOnlyCollection <object> events,
IStreamMetadata metadata,
StreamWriteOptions?options)
{
var timestamp = dateTimeProvider.GetDateTime();
var version = metadata.Version.Value;
var documents = events
.Select(evt => Convert(
evt,
metadata,
++version, // increment version for event
options?.CorrelationId,
options?.CausationId,
timestamp))
.ToArray();
return(new StreamBatch(
new StreamMetadata(
StreamMetadata.StreamMetadataId,
metadata.StreamId.Value,
metadata.StreamId,
version,
StreamState.Active,
timestamp)
{
ETag = metadata.ETag,
},
documents));
}
public virtual void ReportStreamMetadata(TimeSpan timestamp, IStreamMetadata streamMetadata)
{
Debug.WriteLine(string.Concat(new object[4]
{
(object)"MetadataSink.ReportStreamMetadata() ",
(object)timestamp,
(object)" ",
(object)streamMetadata
}));
bool lockTaken = false;
object obj = null;
try
{
Monitor.Enter(obj = this._lock, ref lockTaken);
this._metadataState.StreamTimestamp = timestamp;
this._metadataState.StreamMetadata = streamMetadata;
this._metadataState.SegmentMetadata = (ISegmentMetadata)null;
this._metadataState.TrackMetadata = (ITrackMetadata)null;
}
finally
{
if (lockTaken)
{
Monitor.Exit(obj);
}
}
}
private void AddPath(string[] path, IStreamMetadata streamMetadata, int depth)
{
var child = this.InternalChildren.FirstOrDefault(p => p.Name == path[depth - 1]) as StreamTreeNode;
if (child == null)
{
child = new StreamTreeNode(this.Partition)
{
Path = string.Join(".", path.Take(depth)),
Name = path[depth - 1],
};
this.InternalChildren.Add(child);
}
// if we are at the last segement of the path name then we are at the leaf node
if (path.Length == depth)
{
Debug.Assert(child.StreamMetadata == null, "There should never be two leaf nodes");
child.StreamMetadata = streamMetadata;
child.TypeName = streamMetadata.TypeName;
child.StreamName = streamMetadata.Name;
return;
}
// we are not at the last segment so recurse in
child.AddPath(path, streamMetadata, depth + 1);
}
public void JsonGeneratorTest()
{
List <Message <SimpleObject> > stream1 = new List <Message <SimpleObject> >();
List <Message <SimpleObject> > stream2 = new List <Message <SimpleObject> >();
IStreamMetadata metadata1 = null;
IStreamMetadata metadata2 = null;
using (var p = Pipeline.Create("JsonGeneratorTest"))
{
var generator = JsonStore.Open(p, StoreName, InputPath);
generator.OpenStream <SimpleObject>("Stream1").Do((d, e) => stream1.Add(new Message <SimpleObject>(d, e.OriginatingTime, e.Time, e.SourceId, e.SequenceId)));
generator.OpenStream <SimpleObject>("Stream2").Do((d, e) => stream2.Add(new Message <SimpleObject>(d, e.OriginatingTime, e.Time, e.SourceId, e.SequenceId)));
metadata1 = generator.GetMetadata("Stream1");
ValidateMetadata(metadata1, "Stream1", 1, TypeName, PartitionName, PartitionPath, FirstTime, LastTime, FirstTime, LastTime, 388, 0, 2);
metadata2 = generator.GetMetadata("Stream2");
ValidateMetadata(metadata2, "Stream2", 2, TypeName, PartitionName, PartitionPath, FirstTime, LastTime, FirstTime, LastTime, 388, 0, 2);
p.Run();
}
Assert.AreEqual(stream1.Count, 2);
Assert.AreEqual(stream2.Count, 2);
ValidateMessage(stream1[0], FirstTime, (data) => ValidateSimpleObject(data, Data));
ValidateMessage(stream1[1], LastTime, (data) => ValidateSimpleObject(data, Data));
ValidateMessage(stream2[0], FirstTime, (data) => ValidateSimpleObject(data, Data));
ValidateMessage(stream2[1], LastTime, (data) => ValidateSimpleObject(data, Data));
}
public void Validate(IStreamMetadata metadata, StreamVersion version)
{
if (metadata.State == StreamState.Closed)
{
throw new StreamClosedException(metadata.StreamId);
}
}
private static void ValidateMetadata(
IStreamMetadata metadata,
string name,
int id,
string typeName,
string partitionName,
string partitionPath,
DateTime firstMessageTime,
DateTime lastMessageTime,
DateTime firstMessageOriginatingTime,
DateTime lastMessageOriginatingTime,
int averageMessageSize,
int averageMessageLatency,
int messageCount)
{
Assert.AreEqual(metadata.Name, name);
Assert.AreEqual(metadata.Id, id);
Assert.AreEqual(metadata.TypeName, typeName);
Assert.AreEqual(metadata.PartitionName, partitionName);
Assert.AreEqual(metadata.PartitionPath, partitionPath);
Assert.AreEqual(metadata.FirstMessageTime, firstMessageTime);
Assert.AreEqual(metadata.LastMessageTime, lastMessageTime);
Assert.AreEqual(metadata.FirstMessageOriginatingTime, firstMessageOriginatingTime);
Assert.AreEqual(metadata.LastMessageOriginatingTime, lastMessageOriginatingTime);
Assert.AreEqual(metadata.AverageMessageSize, averageMessageSize);
Assert.AreEqual(metadata.AverageLatency, averageMessageLatency);
Assert.AreEqual(metadata.MessageCount, messageCount);
}
public void JsonSimpleReaderTest()
{
List <Message <SimpleObject> > stream1 = new List <Message <SimpleObject> >();
List <Message <SimpleObject> > stream2 = new List <Message <SimpleObject> >();
IStreamMetadata metadata1 = null;
IStreamMetadata metadata2 = null;
using (var reader = new JsonSimpleReader())
{
reader.OpenStore(StoreName, InputPath);
metadata1 = reader.AvailableStreams.First((m) => m.Name == "Stream1");
ValidateMetadata(metadata1, "Stream1", 1, TypeName, PartitionName, PartitionPath, FirstTime, LastTime, FirstTime, LastTime, 388, 0, 2);
metadata2 = reader.AvailableStreams.First((m) => m.Name == "Stream2");
ValidateMetadata(metadata2, "Stream2", 2, TypeName, PartitionName, PartitionPath, FirstTime, LastTime, FirstTime, LastTime, 388, 0, 2);
reader.OpenStream <SimpleObject>("Stream1", (d, e) => stream1.Add(new Message <SimpleObject>(d, e.OriginatingTime, e.Time, e.SourceId, e.SequenceId)));
reader.OpenStream <SimpleObject>("Stream2", (d, e) => stream2.Add(new Message <SimpleObject>(d, e.OriginatingTime, e.Time, e.SourceId, e.SequenceId)));
reader.ReadAll(ReplayDescriptor.ReplayAll);
}
Assert.AreEqual(stream1.Count, 2);
Assert.AreEqual(stream2.Count, 2);
ValidateMessage(stream1[0], 1, 0, FirstTime, FirstTime, (data) => ValidateSimpleObject(data, Data));
ValidateMessage(stream1[1], 1, 1, LastTime, LastTime, (data) => ValidateSimpleObject(data, Data));
ValidateMessage(stream2[0], 2, 0, FirstTime, FirstTime, (data) => ValidateSimpleObject(data, Data));
ValidateMessage(stream2[1], 2, 1, LastTime, LastTime, (data) => ValidateSimpleObject(data, Data));
}
void EncodeImageStreams(IStreamMetadata streamInfo, PsiImporter importer, Exporter exporter)
{
importer
.OpenStream <Shared <Image> >(streamInfo.Name)
.Convert(PixelFormat.BGRA_32bpp)
.EncodeJpeg(quality)
.Write(streamInfo.Name, exporter, true);
}
public virtual TimeSpan?Update(MetadataState state, TimeSpan position)
{
bool lockTaken = false;
object obj = null;
try
{
Monitor.Enter(obj = this._lock, ref lockTaken);
this._position = position;
TimeSpan? nullable1 = this.ProcessPendingTracks();
IStreamMetadata streamMetadata = this._metadataState.StreamMetadata;
ISegmentMetadata segmentMetadata = this._metadataState.SegmentMetadata;
state.SegmentMetadata = segmentMetadata;
state.SegmentTimestamp = this._metadataState.SegmentTimestamp;
state.StreamMetadata = streamMetadata;
state.StreamTimestamp = this._metadataState.StreamTimestamp;
state.TrackMetadata = this._metadataState.TrackMetadata;
state.ConfigurationMetadata = this._metadataState.ConfigurationMetadata;
int num1;
if (this._metadataState.StreamTimestamp > this._position)
{
TimeSpan streamTimestamp = this._metadataState.StreamTimestamp;
TimeSpan?nullable2 = nullable1;
num1 = (nullable2.HasValue ? (streamTimestamp < nullable2.GetValueOrDefault() ? 1 : 0) : 0) == 0 ? 1 : 0;
}
else
{
num1 = 1;
}
if (num1 == 0)
{
nullable1 = new TimeSpan?(this._metadataState.StreamTimestamp);
}
int num2;
if (this._metadataState.SegmentTimestamp > this._position)
{
TimeSpan segmentTimestamp = this._metadataState.SegmentTimestamp;
TimeSpan?nullable2 = nullable1;
num2 = (nullable2.HasValue ? (segmentTimestamp < nullable2.GetValueOrDefault() ? 1 : 0) : 0) == 0 ? 1 : 0;
}
else
{
num2 = 1;
}
if (num2 == 0)
{
nullable1 = new TimeSpan?(this._metadataState.SegmentTimestamp);
}
return(nullable1);
}
finally
{
if (lockTaken)
{
Monitor.Exit(obj);
}
}
}
internal async Task Should_Return_Info_On_GetStreamInfo(
[Frozen] IStreamInfoReader reader,
EventStoreClient sut,
StreamId streamId,
IStreamMetadata expectedResult,
CancellationToken cancellationToken)
{
reader
.ReadAsync(default, default)
public virtual void ReportStreamMetadata(TimeSpan timestamp, IStreamMetadata streamMetadata)
{
Debug.WriteLine("MetadataSink.ReportStreamMetadata() " + timestamp + " " + streamMetadata);
lock (_lock)
{
_metadataState.StreamTimestamp = timestamp;
_metadataState.StreamMetadata = streamMetadata;
_metadataState.SegmentMetadata = null;
_metadataState.TrackMetadata = null;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DerivedReceiverDiagnosticsStreamTreeNode{T}"/> class.
/// </summary>
/// <param name="partitionViewModel">The partition where this stream tree node can be found.</param>
/// <param name="path">The path to the stream tree node.</param>
/// <param name="name">The name of the stream tree node.</param>
/// <param name="sourceStreamMetadata">The source stream metadata.</param>
/// <param name="receiverId">The receiver id.</param>
/// <param name="memberFunc">A function that given the receiver diagnostics provides the statistic of interest.</param>
public DerivedReceiverDiagnosticsStreamTreeNode(
PartitionViewModel partitionViewModel,
string path,
string name,
IStreamMetadata sourceStreamMetadata,
int receiverId,
Func <PipelineDiagnostics.ReceiverDiagnostics, T> memberFunc)
: base(partitionViewModel, path, name, sourceStreamMetadata)
{
this.DataTypeName = typeof(T?).FullName;
this.ReceiverId = receiverId;
this.memberFunc = memberFunc;
}
internal void Should_Validate_When_Expected_Version_IsNot_StartOfStream(
IStreamMetadata metadata,
StreamEmptyValidator sut)
{
metadata
.State
.Returns(StreamState.Active);
FluentActions.Invoking(
() => sut.Validate(metadata, StreamVersion.Any))
.Should()
.NotThrow();
}
private void OpenStream <T>(IStreamMetadata meta, Action <T, Envelope> target, Func <T> allocator = null)
{
// Get the deserialization handler for this stream type
var handler = this.context.Serializers.GetHandler <T>();
var isDynamic = typeof(T).FullName == typeof(object).FullName;
var isRaw = typeof(T).FullName == typeof(Message <BufferReader>).FullName;
if (!isDynamic && !isRaw)
{
// check that the requested type matches the stream type
var streamType = meta.TypeName;
var handlerType = handler.Name;
if (streamType != handlerType)
{
// check if the handler is able to handle the stream type
if (handlerType != streamType)
{
if (this.context.Serializers.Schemas.TryGetValue(streamType, out var streamTypeSchema) &&
this.context.Serializers.Schemas.TryGetValue(handlerType, out var handlerTypeSchema))
{
// validate compatibility - will throw if types are incompatible
handlerTypeSchema.ValidateCompatibleWith(streamTypeSchema);
}
}
}
}
// If there's no list of targets for this stream, create it now
if (!this.targets.ContainsKey(meta.Id))
{
this.targets[meta.Id] = new List <Delegate>();
}
// Add the target to the list to call when this stream has new data
this.targets[meta.Id].Add(target);
// Update the code to execute when this stream receives new data
this.outputs[meta.Id] = (br, e) =>
{
// Deserialize the data
var data = this.Deserialize <T>(handler, br, e, isDynamic, isRaw, (allocator == null) ? default(T) : allocator(), meta.TypeName, this.context.Serializers.Schemas);
// Call each of the targets
foreach (Delegate action in this.targets[meta.Id])
{
(action as Action <T, Envelope>)(data, e);
}
};
}
internal void Should_Validate_When_Stream_IsActive(
IStreamMetadata metadata,
StreamVersion version,
StreamClosedValidator sut)
{
metadata
.State
.Returns(StreamState.Active);
FluentActions.Invoking(
() => sut.Validate(metadata, version))
.Should()
.NotThrow();
}
internal void Should_Throw_When_Stream_IsClosed(
IStreamMetadata metadata,
StreamVersion version,
StreamClosedValidator sut)
{
metadata
.State
.Returns(StreamState.Closed);
FluentActions.Invoking(
() => sut.Validate(metadata, version))
.Should()
.Throw <StreamClosedException>();
}
private async Task <M3U8Parser> FetchPlaylistAsync(CancellationToken cancellationToken)
{
var urls = Urls;
if (urls == null || urls.Count < 1)
{
return(null);
}
foreach (Uri playlist in urls)
{
UpdateSubPlaylistCache(playlist);
cancellationToken.ThrowIfCancellationRequested();
WebResponse webResponse = null;
if (null == StreamMetadata)
{
webResponse = new WebResponse();
}
var parsedPlaylist = await _subPlaylistCache.ReadAsync((actualUri, bytes) =>
{
cancellationToken.ThrowIfCancellationRequested();
if (bytes.Length < 1)
{
return(null);
}
var parser = new M3U8Parser();
using (var memoryStream = new MemoryStream(bytes))
{
parser.Parse(actualUri, memoryStream);
}
return(parser);
}, cancellationToken, webResponse).ConfigureAwait(false);
if (null != parsedPlaylist)
{
if (null != webResponse)
{
StreamMetadata = _webMetadataFactory.CreateStreamMetadata(webResponse);
}
return(parsedPlaylist);
}
}
return(null);
}
internal void Should_Throw_When_Stream_IsRequired_ToBe_StartOfStream_But_Stream_IsNot_StartOfStream(
IStreamMetadata metadata,
StreamEmptyValidator sut)
{
metadata
.State
.Returns(StreamState.Active);
metadata
.Version
.Returns(StreamVersion.FromStreamVersion(1));
FluentActions.Invoking(
() => sut.Validate(metadata, StreamVersion.StartOfStream))
.Should()
.Throw <StreamVersionConflictException>();
}
internal void Should_Throw_When_Stream_Exceeds_ExpectedVersion(
IStreamMetadata metadata,
StreamExpectedVersionValidator sut)
{
metadata
.State
.Returns(StreamState.Active);
metadata
.Version
.Returns(StreamVersion.FromStreamVersion(3));
FluentActions.Invoking(
() => sut.Validate(metadata, 1))
.Should()
.Throw <StreamVersionConflictException>();
}
internal void Should_Validate_When_StreamVersion_Is_ExpectedVersion(
IStreamMetadata metadata,
StreamExpectedVersionValidator sut)
{
metadata
.State
.Returns(StreamState.Active);
metadata
.Version
.Returns(StreamVersion.FromStreamVersion(3));
FluentActions.Invoking(
() => sut.Validate(metadata, 3))
.Should()
.NotThrow();
}
public void Validate(IStreamMetadata metadata, StreamVersion version)
{
// Pass validation if the required version is not start of stream.
if (version != StreamVersion.StartOfStream)
{
return;
}
if (metadata.Version != StreamVersion.StartOfStream)
{
throw new StreamVersionConflictException(
metadata.StreamId,
metadata.Version,
version,
StreamConflictReason.StreamIsNotEmpty,
"Stream is expected to be empty.");
}
}
public void Validate(IStreamMetadata metadata, StreamVersion version)
{
// Pass validation if the required version is not NotEmpty.
if (version != StreamVersion.NotEmpty)
{
return;
}
if (metadata.Version <= StreamVersion.StartOfStream)
{
throw new StreamVersionConflictException(
metadata.StreamId,
metadata.Version,
version,
StreamConflictReason.StreamIsEmpty,
$"Stream is expected to be empty but found {metadata.Version} events.");
}
}
internal void Should_Validate(
long version,
StreamState state,
IStreamMetadata metadata,
StreamNotEmptyValidator sut)
{
metadata
.State
.Returns(state);
metadata
.Version
.Returns(version);
FluentActions.Invoking(
() => sut.Validate(metadata, StreamVersion.NotEmptyValue))
.Should()
.NotThrow();
}
internal void Should_Throw_When_StreamVersion_Is_Not_StartOfStream(
long version,
StreamState state,
IStreamMetadata metadata,
StreamNotEmptyValidator sut)
{
metadata
.State
.Returns(state);
metadata
.Version
.Returns(version);
FluentActions.Invoking(
() => sut.Validate(metadata, StreamVersion.NotEmptyValue))
.Should()
.Throw <StreamVersionConflictException>();
}
public void Validate(IStreamMetadata metadata, StreamVersion version)
{
if (version == StreamVersion.Any || version == StreamVersion.NotEmpty)
{
return;
}
// If the stream version is not equal to the required version required, then throw.
if (metadata.Version != version)
{
throw new StreamVersionConflictException(
metadata.StreamId,
metadata.Version,
version,
StreamConflictReason.ExpectedVersion,
$"Stream version was expected to be {version.Value} but is at {metadata.Version.Value}.");
}
}
internal void Should_Throw_On_Validate(
StreamState streamState,
long expectedVersion,
long actualVersion,
StreamReadValidator sut,
IStreamMetadata metadata)
{
metadata
.State
.Returns(streamState);
metadata
.Version
.Returns(actualVersion);
FluentActions.Invoking(
() => sut.Validate(metadata, expectedVersion))
.Should()
.Throw <Exception>();
}
/// <summary>
/// Initializes a new instance of the <see cref="StreamSource"/> class.
/// </summary>
/// <param name="partitionViewModel">The partition that is the stream's data source.</param>
/// <param name="streamReaderType">The type of stream reader that should be used to read data from the store.</param>
/// <param name="streamName">The name of the stream.</param>
/// <param name="streamMetadata">The metadata for the stream.</param>
/// <param name="streamAdapter">The stream adapter to use when reading stream data.</param>
/// <param name="summarizer">The summarizer to use when reading the stream.</param>
public StreamSource(
PartitionViewModel partitionViewModel,
Type streamReaderType,
string streamName,
IStreamMetadata streamMetadata,
IStreamAdapter streamAdapter,
ISummarizer summarizer)
{
this.StoreName = partitionViewModel.StoreName;
this.StorePath = partitionViewModel.StorePath;
this.StreamReaderType = streamReaderType;
this.StreamName = streamName;
this.StreamMetadata = streamMetadata;
this.StreamAdapter = streamAdapter;
this.Summarizer = summarizer;
this.IsLive = partitionViewModel.IsLivePartition;
partitionViewModel.PropertyChanged += this.PartitionPropertyChanged;
}
internal void Should_Validate(
StreamState streamState,
long streamVersion,
long expectedVersion,
StreamWriteValidator sut,
IStreamMetadata metadata)
{
metadata
.State
.Returns(streamState);
metadata
.Version
.Returns(streamVersion);
FluentActions.Invoking(
() => sut.Validate(metadata, expectedVersion))
.Should()
.NotThrow();
}
private void ZoomToPanel()
{
// Get a list of time intervals for all stream visualization objects in this panel
List <TimeInterval> streamIntervals = new List <TimeInterval>();
foreach (VisualizationObject visualizationObject in this.VisualizationObjects)
{
IStreamVisualizationObject streamVisualizationObject = visualizationObject as IStreamVisualizationObject;
IStreamMetadata streamMetadata = streamVisualizationObject?.StreamBinding?.StreamMetadata;
if (streamMetadata != null)
{
streamIntervals.Add(new TimeInterval(streamMetadata.FirstMessageOriginatingTime, streamMetadata.LastMessageOriginatingTime));
}
}
// Zoom to the coverage of the stream visualization objects
if (streamIntervals.Count > 0)
{
TimeInterval panelInterval = TimeInterval.Coverage(streamIntervals);
this.Container.Navigator.Zoom(panelInterval.Left, panelInterval.Right);
}
}
public override void ReportStreamMetadata(TimeSpan timestamp, IStreamMetadata streamMetadata)
{
base.ReportStreamMetadata(timestamp, streamMetadata);
_updateAction();
}
public void InitializeStream(IStreamMetadata streamMetadata)
{ }
async Task<M3U8Parser> FetchPlaylistAsync(CancellationToken cancellationToken)
{
var urls = Urls;
if (null == urls || urls.Count < 1)
return null;
foreach (var playlist in urls)
{
UpdateSubPlaylistCache(playlist);
cancellationToken.ThrowIfCancellationRequested();
WebResponse webResponse = null;
if (null == StreamMetadata)
webResponse = new WebResponse();
var parsedPlaylist = await _subPlaylistCache.ReadAsync(
(actualUri, bytes) =>
{
cancellationToken.ThrowIfCancellationRequested();
if (bytes.Length < 1)
return null;
var parser = new M3U8Parser();
using (var ms = new MemoryStream(bytes))
{
parser.Parse(actualUri, ms);
}
return parser;
}, cancellationToken, webResponse)
.ConfigureAwait(false);
if (null != parsedPlaylist)
{
if (null != webResponse)
StreamMetadata = _webMetadataFactory.CreateStreamMetadata(webResponse);
return parsedPlaylist;
}
}
return null;
}
