internal StreamEventsSlice(SliceReadStatus status,
string stream,
int fromEventNumber,
ReadDirection readDirection,
ClientMessage.ResolvedIndexedEvent[] events,
int nextEventNumber,
int lastEventNumber,
bool isEndOfStream)
{
Ensure.NotNullOrEmpty(stream, "stream");
Status = status;
Stream = stream;
FromEventNumber = fromEventNumber;
ReadDirection = readDirection;
if (events == null || events.Length == 0)
Events = Empty.ResolvedEvents;
else
{
Events = new ResolvedEvent[events.Length];
for (int i = 0; i < Events.Length; ++i)
{
Events[i] = new ResolvedEvent(events[i]);
}
}
NextEventNumber = nextEventNumber;
LastEventNumber = lastEventNumber;
IsEndOfStream = isEndOfStream;
}
private void GotEvent(EventStoreCatchUpSubscription sub, ResolvedEvent evt)
{
try
{
//create local copies of state variables
var total = _total;
var checkpoint = evt.Event.EventNumber;
var amount = (string)JObject.Parse(Encoding.UTF8.GetString(evt.Event.Data))["amount"];
switch (evt.Event.EventType.ToUpperInvariant())
{
case "CREDIT":
total += int.Parse(amount);
break;
case "DEBIT":
total -= int.Parse(amount);
break;
default:
throw new Exception("Unknown Event Type");
}
File.WriteAllText(_localFile, checkpoint + "," + total);
//Update the common state after commit to disk
_total = total;
Checkpoint = checkpoint;
}
catch (Exception ex)
{
_view.ErrorMsg = "Event Exception: " + ex.Message;
}
//repaint screen
_view.Total = _total;
}
void EventAppeared(EventStoreCatchUpSubscription sub, ResolvedEvent evnt)
{
if (evnt.OriginalStreamId.StartsWith("$"))
return;
dynamic ev = _adapter.TryGetDomainEvent(evnt);
if (ev == null)
return;
try
{
lock (this)
{
Dispatch(ev);
_succeded++;
_checkPoint = evnt.OriginalPosition.GetValueOrDefault();
_lastEventNumber = evnt.OriginalEventNumber;
if(ev.Timestamp > LastUpdate)
LastUpdate = ev.Timestamp;
}
}
catch (Exception)
{
Debugger.Break();
}
}
private static void EventAppeared(EventStorePersistentSubscriptionBase eventStorePersistentSubscriptionBase,
ResolvedEvent resolvedEvent)
{
;
var data = Encoding.ASCII.GetString(resolvedEvent.Event.Data);
Console.WriteLine("Received: " + resolvedEvent.Event.EventStreamId + ":" + resolvedEvent.Event.EventNumber);
Console.WriteLine(data);
}
private void CommandResponseReceived(EventStoreSubscription subscription, ResolvedEvent resolvedEvent)
{
if (ResponseReceived == null) return;
var response = resolvedEvent.ParseJson<CommandResponse>();
ResponseReceived(this, new CommandResponseEventArgs(response));
}
public static object DeserializeEventData(
this ISerializer serializer,
ResolvedEvent resolvedEvent)
{
IDictionary<string, object> _;
return serializer.DeserializeEventData(resolvedEvent, out _);
}
private void ProcessEvent(EventStoreCatchUpSubscription subscribtion, ResolvedEvent resolvedEvent)
{
var alarm = resolvedEvent.ParseJson<IrresponsibleGamblerDetected>();
Publish(alarm);
StoreCheckpoint(resolvedEvent);
}
private void HandleNewEvent(EventStoreCatchUpSubscription subscription, ResolvedEvent @event)
{
// make sure the event fits the ones this handler cares about
if (!_eventFilter(@event)) { return; }
var _event = ProcessRawEvent(@event);
// filter for null event ( didn't have metadata or data )
if (_event == null) { return; }
HandleEvent(_event);
}
dynamic GetDomainEvent(ResolvedEvent evnt)
{
var metadata = evnt.Event.Metadata;
var data = evnt.Event.Data;
var jmeta = JObject.Parse(Encoding.UTF8.GetString(metadata));
var eventClrTypeName = jmeta.Property(EventClrTypeHeader).Value;
dynamic ev = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(data), Type.GetType((string)eventClrTypeName));
return ev;
}
private void EventAppeard(EventStoreSubscription subscription, ResolvedEvent @event)
{
var representation = _deserializer.GetRepresentation(_serializer, @event.OriginalEvent);
var payload = representation.Payload;
if (payload != null)
{
_self.Tell(payload);
}
}
public dynamic TryGetDomainEvent(ResolvedEvent evnt)
{
try
{
return GetDomainEvent(evnt);
}
catch
{
return null;
}
}
public IEnumerable<object> Deserialize(ResolvedEvent resolvedEvent)
{
var type = Type.GetType(resolvedEvent.Event.EventType + ", UserService.DomainModel", true);
using (var stream = new MemoryStream(resolvedEvent.Event.Data))
{
using (var reader = new StreamReader(stream))
{
yield return JsonSerializer.CreateDefault().Deserialize(reader, type);
}
}
}
private SyndicationItem MapToFeedItem(ResolvedEvent ev)
{
return new SyndicationItem(
"BeganFollowingEvent",
Encoding.UTF8.GetString(ev.Event.Data),
new Uri(RequestContext.Url.Content("/beganfollowing/" +
ev.Event.EventId)),
ev.Event.EventId.ToString(),
DateTime.Now // Event store client does not return timestamp yet
);
}
private static EventEnvelope Map(ResolvedEvent resolvedEvent)
{
var bytesAsString = Encoding.UTF8.GetString(resolvedEvent.Event.Data);
var a = JsonConvert.DeserializeObject(bytesAsString) as IEvent;
var jsonMetadata = Encoding.UTF8.GetString(resolvedEvent.Event.Metadata);
var metadata = JsonConvert.DeserializeObject<EventMetadata>(jsonMetadata);
var typeName = Type.GetType(metadata.Type);
var @event = (IEvent)JsonConvert.DeserializeObject(bytesAsString, typeName);
var envelope = new EventEnvelope(@event, metadata);
return envelope;
}
protected override void OnEventReceived(ResolvedEvent resolvedEvent)
{
switch (resolvedEvent.OriginalEvent.EventType)
{
case UserEventType.UserCreated:
AddAccount(resolvedEvent.OriginalEvent);
break;
case ContactEventType.AccountContactRefreshRequest:
ProcessRefreshRequest(resolvedEvent.OriginalEvent);
break;
}
}
public async Task PublishAsync(EventStorePersistentSubscriptionBase subscription, ResolvedEvent resolvedEvent) {
try {
object eventObject = resolvedEvent.Event.ToEventObject();
using (Container.BeginExecutionContextScope()) {
dynamic publisher = Container.GetInstance<IPublishEvent>();
await publisher.PublishAsync((dynamic)eventObject).ConfigureAwait(true);
}
subscription.Acknowledge(resolvedEvent);
} catch (Exception ex) {
subscription.Fail(resolvedEvent, PersistentSubscriptionNakEventAction.Unknown, ex.Message);
}
}
protected override void OnEventReceived(ResolvedEvent resolvedEvent)
{
switch (resolvedEvent.OriginalEvent.EventType)
{
case UserEventType.UserCreated:
AddUserToCache(resolvedEvent.OriginalEvent);
break;
case UserEventType.AccountRegistered:
AddAccountToCache(resolvedEvent.OriginalEvent);
break;
}
}
private static void Appeared(EventStoreCatchUpSubscription subscription, ResolvedEvent resolvedEvent)
{
if (resolvedEvent.Event.EventType.Contains("Question") || resolvedEvent.Event.EventType.Contains("Answer"))
{
Console.WriteLine("Read event {0} with data: {1}",
resolvedEvent.Event.EventType,
Encoding.UTF8.GetString(resolvedEvent.Event.Data));
var @event = EventDeserializer.Deserialize(resolvedEvent.Event.EventType, Encoding.UTF8.GetString(resolvedEvent.Event.Data));
_eventPublisher.Publish(@event);
}
}
private static void StoreCommandData(ResolvedEvent evt, EventContext deserializedEvent, IDocumentSession session)
{
var commandId = deserializedEvent.Headers["CommandId"] as string;
var commandModel = session.Load<CommandStatusModel>(commandId);
if (commandModel == null)
{
commandModel = new CommandStatusModel() { Id = commandId };
commandModel.Events = new List<EventStatusModel>();
session.Store(commandModel);
}
commandModel.Events.Add(new EventStatusModel() { StreamId = evt.Event.EventStreamId, EventNumber = evt.Event.EventNumber, Type = evt.Event.EventType});
}
public Snapshot Deserialize(ResolvedEvent resolvedEvent)
{
var type = Type.GetType(resolvedEvent.Event.EventType, true);
var instance = Activator.CreateInstance(type);
using (var stream = new MemoryStream(resolvedEvent.Event.Data))
{
using (var reader = new BinaryReader(stream))
{
((IBinaryDeserializer) instance).Read(reader);
return new Snapshot(BitConverter.ToInt32(resolvedEvent.Event.Metadata, 0), instance);
}
}
}
public static object DeserializeEventData(
this ISerializer serializer,
ResolvedEvent resolvedEvent,
out IDictionary<string, object> headers)
{
headers = (IDictionary<string, object>)serializer.Deserialize(Decode(resolvedEvent.Event.Metadata), typeof(Dictionary<string, object>));
var type = Type.GetType((string)headers[EventMessageHeaders.Type]);
var @event = serializer.Deserialize(Decode(resolvedEvent.Event.Data), type);
return @event;
}
private void EventAppeared(EventStoreSubscription sub, ResolvedEvent e)
{
Log.Debug(_adapterName + " received " + Encoding.UTF8.GetString(e.Event.Data));
var request = Json.From<SearchRequested>(Encoding.UTF8.GetString(e.Event.Data));
try
{
var response = _endpoint.GetQuoteFor(request);
Publish(request.ClientResponseStream, response);
}
catch (Exception ex)
{
Log.Exception(_adapterName + " endpoint caused exception", ex);
}
}
public object Deserialize(ResolvedEvent resolvedEvent)
{
var instance =
(IBinaryDeserializer)
Activator.CreateInstance(Type.GetType(resolvedEvent.OriginalEvent.EventType, true));
using (var stream = new MemoryStream(resolvedEvent.Event.Data))
{
using (var reader = new BinaryReader(stream))
{
instance.Read(reader);
}
}
return instance;
}
private void EventAppeared(EventStoreCatchUpSubscription subscription, ResolvedEvent re)
{
if (re.OriginalEvent.EventType.StartsWith("$")) return; //skip internal events
if (re.OriginalEvent.Metadata == null || re.OriginalEvent.Metadata.Any() == false) return;
try
{
var e = re.DeserializeEvent();
Dispatch(e).Wait();
}
catch (Exception exception)
{
_log.Error(string.Format("Could not deserialize event {0}", re.OriginalEvent.EventType), exception);
}
}
private void OnEventReceivedImpl(ResolvedEvent resolvedEvent)
{
_logger.Trace("{0} Received event and scheduling onto ELS - {1}[{2}] {{ EventType = '{3}'}}",
GetType().Name,
resolvedEvent.OriginalEvent.EventStreamId, resolvedEvent.OriginalEvent.EventNumber,
resolvedEvent.OriginalEvent.EventType);
_eventLoopScheduler.Schedule(() =>
{
_logger.Trace("{0}.OnEventReceived({1}[{2}] {{ EventType = '{3}'}}",
GetType().Name,
resolvedEvent.OriginalEvent.EventStreamId, resolvedEvent.OriginalEvent.EventNumber,
resolvedEvent.OriginalEvent.EventType);
OnEventReceived(resolvedEvent);
});
}
protected override void When()
{
_connection.ConnectToPersistentSubscription(TestStreamName, GroupName, (x, y) =>
{
replayedParkedEvent = y;
_eventParked.Set();
},
(x, y, z) => { },
DefaultData.AdminCredentials);
//Replayed parked messages
var response = MakePost(SubscriptionPath + "/replayParked", _admin);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
internal AllEventsSlice(ReadDirection readDirection, Position fromPosition, Position nextPosition, ClientMessage.ResolvedEvent[] events)
{
ReadDirection = readDirection;
FromPosition = fromPosition;
NextPosition = nextPosition;
if (events == null)
Events = EmptyEvents;
else
{
Events = new ResolvedEvent[events.Length];
for (int i = 0; i < Events.Length; ++i)
{
Events[i] = new ResolvedEvent(events[i]);
}
}
}
private void Appeared(EventStoreSubscription subscription, ResolvedEvent data)
{
var recordedEvent = data.Event;
if (IsSystemStream(recordedEvent.EventStreamId)) return;
var linkedStream = data.Link != null ? data.Link.EventStreamId : null;
if (IsSystemStream(linkedStream)) return;
var eventDefinition = _knownEventsProvider.Get(recordedEvent);
_console.Log(
eventDefinition.Color,
"{0}: {1} ({2})",
recordedEvent.EventType,
eventDefinition.Parse(),
FormatStream(linkedStream, recordedEvent));
}
public void OnEventAppeared(EventStoreCatchUpSubscription subscription, ResolvedEvent resolvedEvent, Action<object,DateTime> callback)
{
var type = _typeLocator.Locate(resolvedEvent.Event.EventType);
if (null == type) {
_logger.LogDebug("[{0}] unknown type", _streamName);
return;
}
callback(
JsonConvert.DeserializeObject(
Encoding.UTF8.GetString(resolvedEvent.Event.Data),
type
),
resolvedEvent.Event.Created
);
}
private static void SendToClient(ResolvedEvent e, string connectionId)
{
var context = GlobalHost.ConnectionManager.GetHubContext<LiveEmotivSessionHub>();
var theClient = context.Clients.Client(connectionId);
var data = Encoding.UTF8.GetString(e.Event.Data);
var metadata = Encoding.UTF8.GetString(e.Event.Metadata);
theClient.handleEvent(new
{
eventId = e.Event.EventId,
eventNumber = e.Event.EventNumber,
eventStreamId = e.Event.EventStreamId,
eventType = e.Event.EventType,
data,
metadata
});
}
public void should_be_able_to_subscribe_to_all_with_volatile_subscription()
{
var evnt = new EventData(Guid.NewGuid(), "EventType", false, new byte[10], new byte[15]);
EventStore.ClientAPI.ResolvedEvent receivedEvent = new EventStore.ClientAPI.ResolvedEvent();
var mre = new ManualResetEvent(false);
_store.SubscribeToAllAsync(true, (s, e) => {
receivedEvent = e;
mre.Set();
}, userCredentials: DefaultData.AdminCredentials).Wait();
_store.AppendToStreamAsync(_volatileStreamTwo, intMaxValue + 2, evnt).Wait();
Assert.That(mre.WaitOne(TimeSpan.FromSeconds(5)), "Timed out waiting for events to appear");
Assert.AreEqual(evnt.EventId, receivedEvent.Event.EventId);
}
private static void StoreViewBuilderData(ResolvedEvent evt, IDocumentSession session)
{
ViewBuilderData mainData;
mainData = session.Load<ViewBuilderData>("main");
if (mainData == null)
{
mainData = new ViewBuilderData();
session.Store(mainData, "main");
}
if (evt.OriginalPosition.HasValue)
{
var pos = evt.OriginalPosition.Value;
mainData.CommitPosition = pos.CommitPosition;
mainData.PreparePosition = pos.PreparePosition;
Debug.WriteLine("Position stored");
}
}
public async Task should_be_able_to_subscribe_to_stream_with_volatile_subscription()
{
var evnt = new EventData(Guid.NewGuid(), "EventType", false, new byte[10], new byte[15]);
EventStore.ClientAPI.ResolvedEvent receivedEvent = new EventStore.ClientAPI.ResolvedEvent();
var mre = new ManualResetEvent(false);
await _store.SubscribeToStreamAsync(_volatileStreamOne, true, (s, e) => {
receivedEvent = e;
mre.Set();
return(Task.CompletedTask);
});
await _store.AppendToStreamAsync(_volatileStreamOne, intMaxValue + 2, evnt);
Assert.That(mre.WaitOne(TimeSpan.FromSeconds(5)), "Timed out waiting for events to appear");
Assert.AreEqual(evnt.EventId, receivedEvent.Event.EventId);
}
private Task HandleEvent(EventStoreSubscription sub, ResolvedEvent resolvedEvent)
{
_receivedEvent = resolvedEvent;
_resetEvent.Set();
return(Task.CompletedTask);
}
/// <summary> /// Try to process a single <see cref="ResolvedEvent"/>. /// </summary> /// <param name="e">The <see cref="ResolvedEvent"/> to process.</param> protected abstract void TryProcess(ResolvedEvent e);
/// <summary>
///
/// </summary>
/// <param name="event"></param>
/// <param name="retryCount"></param>
internal PersistentSubscriptionResolvedEvent(ResolvedEvent @event, int?retryCount)
{
Event = @event;
RetryCount = retryCount;
}
/// <summary>
/// Mark a message failed processing. The server will be take action based upon the action paramter
/// </summary>
/// <param name="event">The event to mark as failed</param>
/// <param name="action">The <see cref="PersistentSubscriptionNakEventAction"></see> action to take</param>
/// <param name="reason">A string with a message as to why the failure is occurring</param>
public void Fail(ResolvedEvent @event, PersistentSubscriptionNakEventAction action, string reason)
{
_subscription.NotifyEventsFailed(new[] { @event.OriginalEvent.EventId }, action, reason);
}
/// <summary> /// Try to process a single <see cref="ResolvedEvent"/>. /// </summary> /// <param name="e">The <see cref="ResolvedEvent"/> to process.</param> protected abstract Task TryProcessAsync(ResolvedEvent e);
private void OnEventAppeared(EventStoreSubscription subscription, ResolvedEvent resolvedEvent)
{
Enqueue(resolvedEvent);
}
/// <summary>
/// Acknowledge that a message have completed processing (this will tell the server it has been processed)
/// </summary>
/// <remarks>There is no need to ack a message if you have Auto Ack enabled</remarks>
/// <param name="event">The <see cref="ResolvedEvent"></see> to acknowledge</param>
public void Acknowledge(ResolvedEvent @event)
{
_subscription.NotifyEventsProcessed(new[] { @event.OriginalEvent.EventId });
}
private void HandleEvent(EventStoreSubscription sub, ResolvedEvent resolvedEvent)
{
_receivedEvent = resolvedEvent;
_resetEvent.Set();
}
