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