public async Task <TimeSpan?> Age(string channel)
{
var streamName = $"DELAY.{Assembly.GetEntryAssembly().FullName}.{channel}";
Logger.Write(LogLevel.Debug, () => $"Getting age of delayed channel [{channel}]");
var read = await _store.GetEventsBackwards($"{streamName}.SNAP", StreamPosition.End, 1).ConfigureAwait(false);
if (read != null && read.Any())
{
var snapshot = read.Single().Event as Snapshot;
return(DateTime.UtcNow - snapshot.Created);
}
return(null);
}
public async Task <Tuple <long, T> > Get <T>(string bucket, Id streamId, Id[] parents) where T : class
{
var streamName = _streamGen(typeof(T), StreamTypes.Poco, bucket, streamId, parents);
Logger.DebugEvent("Get", "[{Stream:l}] bucket [{Bucket:l}]", streamName);
if (_shouldCache)
{
var cached = _cache.Retreive(streamName) as Tuple <long, T>;
if (cached != null)
{
Logger.DebugEvent("Cached", "[{Stream:l}] version {Version}", streamName, cached.Item1);
return(new Tuple <long, T>(cached.Item1,
// An easy way to make a deep copy
_serializer.Deserialize <T>(_serializer.Serialize(cached.Item2))));
}
}
var read = await _store.GetEventsBackwards(streamName, StreamPosition.End, 1).ConfigureAwait(false);
if (read == null || !read.Any())
{
return(null);
}
var @event = read.Single();
if (_shouldCache)
{
_cache.Cache(streamName, @event.Event);
}
return(new Tuple <long, T>(@event.Descriptor.Version, @event.Event as T));
}
public async Task <T> Get <T>(string bucket, string stream) where T : class
{
var streamName = _streamGen(typeof(T), StreamTypes.Poco, bucket, stream);
Logger.Write(LogLevel.Debug, () => $"Getting stream [{streamName}]");
if (_shouldCache)
{
var cached = _cache.Retreive(streamName) as T;
if (cached != null)
{
HitMeter.Mark();
Logger.Write(LogLevel.Debug, () => $"Found poco [{stream}] bucket [{bucket}] in cache");
// An easy way to make a deep copy
return(JsonConvert.DeserializeObject <T>(JsonConvert.SerializeObject(cached)));
}
MissMeter.Mark();
}
var read = await _store.GetEventsBackwards(streamName, StreamPosition.End, 1).ConfigureAwait(false);
if (read == null || !read.Any())
{
return(null);
}
var @event = read.Single();
if (_shouldCache)
{
_cache.Cache(streamName, @event.Event);
}
return(@event.Event as T);
}
public async Task <Tuple <long, T> > Get <T>(string bucket, Id streamId, IEnumerable <Id> parents) where T : class
{
var streamName = _streamGen(typeof(T), StreamTypes.Poco, bucket, streamId, parents);
Logger.Write(LogLevel.Debug, () => $"Getting poco stream [{streamName}]");
if (_shouldCache)
{
var cached = _cache.Retreive(streamName) as Tuple <long, T>;
if (cached != null)
{
HitMeter.Mark();
Logger.Write(LogLevel.Debug, () => $"Found poco [{streamId}] bucket [{bucket}] version {cached.Item1} in cache");
return(new Tuple <long, T>(cached.Item1,
// An easy way to make a deep copy
JsonConvert.DeserializeObject <T>(JsonConvert.SerializeObject(cached.Item2))));
}
MissMeter.Mark();
}
var read = await _store.GetEventsBackwards(streamName, StreamPosition.End, 1).ConfigureAwait(false);
if (read == null || !read.Any())
{
return(null);
}
var @event = read.Single();
if (_shouldCache)
{
_cache.Cache(streamName, @event.Event);
}
return(new Tuple <long, T>(@event.Descriptor.Version, @event.Event as T));
}
public async Task <IEnumerable <IFullEvent> > GetEventsBackwards <T>(IEventStream stream, long start, int count, string oob = null) where T : class, IEventSource
{
if (string.IsNullOrEmpty(oob))
{
var streamName = _streamGen(typeof(T), StreamTypes.Domain, stream.Bucket, stream.StreamId, stream.Parents);
return(await _store.GetEventsBackwards(streamName, start : start, count : count).ConfigureAwait(false));
}
var oobName = _streamGen(typeof(T), StreamTypes.OOB, stream.Bucket, stream.StreamId, stream.Parents);
count = count / 10;
// if take is 100, take 10 from each of 10 streams - see above
var events = await Enumerable.Range(1, 10).ToArray()
.StartEachAsync(5,
(vary) => _store.GetEventsBackwards($"{oobName}-{oob}.{vary}", start, count))
.ConfigureAwait(false);
return(events.SelectMany(x => x));
}
public async Task <TEntity[]> GetChildren <TEntity, TParent>(TParent parent) where TEntity : IChildEntity <TParent> where TParent : IHaveEntities <TParent>
{
var uow = (Configuration.Settings.LocalContainer.Value ?? Configuration.Settings.Container).Resolve <Aggregates.UnitOfWork.IDomain>();
var streamGen = Configuration.Settings.Generator;
var parents = getParents(parent);
var parentEntityType = _registrar.GetVersionedName(typeof(TParent));
var childEntityType = _registrar.GetVersionedName(typeof(TEntity));
Logger.DebugEvent("Children", "Getting children for entity type {EntityType} stream id {Id}", parentEntityType, parent.Id);
var stream = streamGen(parentEntityType, StreamTypes.Children, parent.Bucket, parent.Id, parents?.Select(x => x.StreamId).ToArray());
// ES generated stream name
var fullStream = $"$projections-aggregates.net.children.{_version}-{stream}-result";
var stateEvents = await _eventstore.GetEventsBackwards(fullStream, count : 1).ConfigureAwait(false);
if (!stateEvents.Any())
{
return new TEntity[] { }
}
;
var state = stateEvents[0];
var children = state.Event as ChildrenProjection;
var desiredChildren = children?.Children.Where(x => x.EntityType == childEntityType).ToArray();
if (children == null || !desiredChildren.Any())
{
return new TEntity[] { }
}
;
Logger.DebugEvent("Hydrating", "Hydrating {Count} children of entity type {EntityType} stream id {Id}", desiredChildren.Length, parentEntityType, parent.Id);
var entities = new List <TEntity>();
foreach (var child in desiredChildren)
{
var childEntity = await uow.For <TEntity, TParent>(parent).Get(child.StreamId).ConfigureAwait(false);
entities.Add(childEntity);
}
return(entities.ToArray());
}
}
}
public async Task <ISnapshot> GetSnapshot <T>(string bucket, string streamId) where T : class, IEventSource
{
var streamName = $"{_streamGen(typeof(T), bucket + ".SNAP", streamId)}";
Logger.Write(LogLevel.Debug, () => $"Getting snapshot for stream [{streamName}]");
if (_shouldCache)
{
var cached = _cache.Retreive(streamName) as ISnapshot;
if (cached != null)
{
HitMeter.Mark();
Logger.Write(LogLevel.Debug, () => $"Found snapshot [{streamName}] in cache");
return(cached);
}
MissMeter.Mark();
}
Logger.Write(LogLevel.Debug, () => $"Reading snapshot for stream [{streamName}] from store");
var read = await _store.GetEventsBackwards(streamName, StreamPosition.End, 1).ConfigureAwait(false);
if (read == null || !read.Any())
{
return(null);
}
var @event = read.Single();
var snapshot = new Snapshot
{
EntityType = @event.Descriptor.EntityType,
Bucket = bucket,
Stream = streamId,
Timestamp = @event.Descriptor.Timestamp,
Version = @event.Descriptor.Version,
Payload = @event.Event
};
if (_shouldCache)
{
_cache.Cache(streamName, snapshot);
}
return(snapshot);
}
public async Task <ISnapshot> GetSnapshot <T>(string bucket, string streamId) where T : class, IEventSource
{
var streamName = _streamGen(typeof(T), StreamTypes.Snapshot, bucket, streamId);
Logger.Write(LogLevel.Debug, () => $"Getting snapshot for stream [{streamName}]");
{
var snapshot = await _snapshots.Retreive(streamName).ConfigureAwait(false);
if (snapshot != null)
{
HitMeter.Mark();
Logger.Write(LogLevel.Debug,
() => $"Found snapshot [{streamName}] version {snapshot.Version} from subscription");
return(snapshot);
}
}
// Check store directly (this might be a new instance which hasn't caught up to snapshot stream yet
Logger.Write(LogLevel.Debug, () => $"Checking for snapshot for stream [{streamName}] in store");
var read = await _store.GetEventsBackwards(streamName, StreamPosition.End, 1).ConfigureAwait(false);
if (read != null && read.Any())
{
var @event = read.Single();
var snapshot = new Snapshot
{
EntityType = @event.Descriptor.EntityType,
Bucket = bucket,
StreamId = streamId,
Timestamp = @event.Descriptor.Timestamp,
Version = @event.Descriptor.Version,
Payload = @event.Event
};
HitMeter.Mark();
Logger.Write(LogLevel.Debug, () => $"Found snapshot [{streamName}] version {snapshot.Version} from store");
return(snapshot);
}
MissMeter.Mark();
Logger.Write(LogLevel.Debug, () => $"Snapshot not found for stream [{streamName}]");
return(null);
}
public async Task <ISnapshot> GetSnapshot <T>(string bucket, Id streamId, Id[] parents) where T : IEntity
{
var streamName = _streamGen(_registrar.GetVersionedName(typeof(T)), StreamTypes.Snapshot, bucket, streamId, parents);
Logger.DebugEvent("Get", "[{Stream:l}]", streamName);
if (_snapshots != null)
{
var snapshot = await _snapshots.Retreive(streamName).ConfigureAwait(false);
if (snapshot != null)
{
_metrics.Mark("Snapshot Cache Hits", Unit.Items);
Logger.DebugEvent("Cached", "[{Stream:l}] version {Version}", streamName, snapshot.Version);
return(snapshot);
}
}
_metrics.Mark("Snapshot Cache Misses", Unit.Items);
// Check store directly (this might be a new instance which hasn't caught up to snapshot stream yet
var read = await _store.GetEventsBackwards(streamName, StreamPosition.End, 1).ConfigureAwait(false);
if (read != null && read.Any())
{
var @event = read.Single();
var snapshot = new Snapshot
{
EntityType = @event.Descriptor.EntityType,
Bucket = bucket,
StreamId = streamId,
Timestamp = @event.Descriptor.Timestamp,
Version = @event.Descriptor.Version,
Payload = @event.Event as IState
};
Logger.DebugEvent("Read", "[{Stream:l}] version {Version}", streamName, snapshot.Version);
return(snapshot);
}
Logger.DebugEvent("NotFound", "[{Stream:l}]", streamName);
return(null);
}
public Task <IFullEvent[]> GetEventsBackwards <TEntity>(string bucket, Id streamId, Id[] parents, string oobId, long?start = null, int?count = null) where TEntity : IEntity
{
var stream = _generator(typeof(TEntity), StreamTypes.OOB, $"{oobId}.{bucket}", streamId, parents);
return(_store.GetEventsBackwards(stream, start, count));
}
public Task <IEnumerable <IWritableEvent> > Retrieve <T>(string bucket, string streamId, int?skip = null, int?take = null, bool ascending = true) where T : class, IEventSource
{
var streamName = _streamGen(typeof(T), bucket + ".OOB", streamId);
return(!ascending?_store.GetEventsBackwards(streamName) : _store.GetEvents(streamName));
}
public Task <IEnumerable <IWritableEvent> > GetEventsBackwards <T>(string bucket, string streamId, long?start = null, int?count = null) where T : class, IEventSource
{
var streamName = _streamGen(typeof(T), StreamTypes.Domain, bucket, streamId);
return(_store.GetEventsBackwards(streamName, start: start, count: count));
}
