public void ExportData(Stream stream, string graphUri)
{
try
{
var triples = ReadStore.Match(null, null, null, graph: graphUri);
using (var sw = new StreamWriter(stream))
{
var nw = new BrightstarTripleSinkAdapter(new NTriplesWriter(sw));
foreach (var triple in triples)
{
nw.Triple(triple);
}
sw.Flush();
}
}
catch (ReadWriteStoreModifiedException)
{
Logging.LogError(BrightstarEventId.ExportDataError, "Store was modified while export was running.");
}
catch (Exception ex)
{
Logging.LogError(BrightstarEventId.ExportDataError, "Error Exporting Data {0} {1}", ex.Message,
ex.StackTrace);
}
}
public static async Task <AuctionItemReadModel> GetAuctionItemAsync(this ReadStore store,
string auctionId, string name)
{
return(await store.GetAll <AuctionItemReadModel>()
.Where(i => i.AuctionId == auctionId)
.SingleAsync(i => i.Name == name));
}
/// <summary>
/// Setup the dependency injection
/// </summary>
/// <returns>Initialised dependency injection container</returns>
/// <param name="persistedApplicationStateRepository">Application state repository for access to the persisted application state</param>
/// <param name="applicationStateFactory">Factory for the current application state</param>
private IContainer CreateContainer(
IPersistedApplicationStateRepository persistedApplicationStateRepository,
ICurrentApplicationStateFactory applicationStateFactory)
{
var simpleInjector = new Container();
// Application state repository is required when we want to save current the application state
simpleInjector.RegisterSingleton <IPersistedApplicationStateRepository>(persistedApplicationStateRepository);
simpleInjector.RegisterSingleton <ICurrentApplicationStateFactory>(applicationStateFactory);
// Event store only exists once (the state can be exchanged at runtime though)
this.EventStore = new EventStore();
simpleInjector.RegisterSingleton <IEventStore>(this.EventStore);
simpleInjector.RegisterSingleton <IReadOnlyEventStore>(this.EventStore);
// Device Id
var deviceId = new DeviceId();
this.DeviceId = deviceId;
simpleInjector.RegisterSingleton <IDeviceId>(this.DeviceId);
simpleInjector.RegisterSingleton <IReadOnlyDeviceId>(this.DeviceId);
// Vector clock
this.VectorClock = new MasterVectorClock(deviceId);
simpleInjector.RegisterSingleton <IVectorClock>(this.VectorClock);
// Core messaging infrastructure
this.EventBus = new EventBus();
simpleInjector.RegisterSingleton <IEventBus>(this.EventBus);
// Initialise the command bus last because it depends on many other objects
this.CommandBus = new CommandBus(
simpleInjector,
this.EventBus,
this.DeviceId,
this.VectorClock,
this.EventStore);
simpleInjector.RegisterSingleton <ICommandBus>(this.CommandBus);
// Read store (for read side repositories)
// same singleton for read and reset
var readStore = new ReadStore();
simpleInjector.RegisterSingleton <IReadStore>(readStore);
simpleInjector.RegisterSingleton <IResetableReadStore>(readStore);
simpleInjector.RegisterSingleton <IReadStoreResetBroadcast>(readStore);
// Must also register container itself because infrastructure needs it
simpleInjector.RegisterSingleton <IContainer>(simpleInjector);
// Sub-registrations (must not depend on each other)
this.RegisterCommandHandlers(simpleInjector);
this.RegisterProjectionRepositories(simpleInjector);
this.RegisterProjections(simpleInjector, this.EventBus);
simpleInjector.Verify();
return(simpleInjector);
}
/// <summary>
/// Preload index and resource pages for this store
/// </summary>
/// <param name="pageCacheRatio">The fractional amount of the number of available cache pages to use in the preload</param>
public void WarmupStore(decimal pageCacheRatio)
{
if (pageCacheRatio > 1.0m)
{
pageCacheRatio = 1.0m;
}
#if PORTABLE || WINDOWS_PHONE
var pagesToPreload = (int)Math.Floor(PageCache.Instance.FreePages * (float)pageCacheRatio);
#else
var pagesToPreload = (int)Math.Floor(PageCache.Instance.FreePages * pageCacheRatio);
#endif
ReadStore.WarmupPageCache(pagesToPreload);
}
public IEnumerable <Triple> GetResourceStatements(string resourceUri)
{
Logging.LogDebug("GetResourceStatements {0}", resourceUri);
try
{
return(ReadStore.GetResourceStatements(resourceUri));
}
catch (ReadWriteStoreModifiedException)
{
Logging.LogDebug("Read/Write store was concurrently modified. Attempting retry.");
InvalidateReadStore();
return(GetResourceStatements(resourceUri));
}
}
public BrightstarSparqlResultsType Query(SparqlQuery query, ISerializationFormat targetFormat, Stream resultsStream, string[] defaultGraphUris)
{
Logging.LogDebug("Query {0}", query);
try
{
return(ReadStore.ExecuteSparqlQuery(query, targetFormat, resultsStream, defaultGraphUris));
}
catch (ReadWriteStoreModifiedException)
{
Logging.LogDebug("Read/Write store was concurrently modified. Attempting a retry");
InvalidateReadStore();
return(Query(query, targetFormat, resultsStream, defaultGraphUris));
}
}
public string Query(string queryExpression, SparqlResultsFormat resultsFormat)
{
Logging.LogDebug("Query {0}", queryExpression);
try
{
return(ReadStore.ExecuteSparqlQuery(queryExpression, resultsFormat));
}
catch (ReadWriteStoreModifiedException)
{
Logging.LogDebug("Read/Write store was concurrently modified. Attempting a retry");
InvalidateReadStore();
return(Query(queryExpression, resultsFormat));
}
}
public void Query(string queryExpression, SparqlResultsFormat resultsFormat, Stream resultsStream)
{
Logging.LogDebug("Query {0}", queryExpression);
try
{
BrightstarSparqlResultsType resultsType;
ReadStore.ExecuteSparqlQuery(queryExpression, resultsFormat, resultsStream, out resultsType);
}
catch (ReadWriteStoreModifiedException)
{
Logging.LogDebug("Read/Write store was concurrently modified. Attempting a retry");
InvalidateReadStore();
Query(queryExpression, resultsFormat, resultsStream);
}
}
public override async Task <bool> Save(AggregateRootWithEvents aggregateRoot)
{
if (aggregateRoot is DHCPv4RootScope == false)
{
return(await base.Save(aggregateRoot));
}
PseudoDHCPv4RootScope pseudoRootScope = new();
var events = aggregateRoot.GetChanges();
List <AggregateRootWithEvents> aggregatesToSave = new();
aggregatesToSave.Add(pseudoRootScope);
HashSet <Guid> scopesToDelete = new();
HashSet <Guid> leasesToDelete = new();
foreach (var item in events)
{
switch (item)
{
case DHCPv4ScopeAddedEvent e:
{
pseudoRootScope.AddScope(e.Instructions.Id);
var pseudoScope = new PseudoDHCPv4Scope(e.Instructions.Id);
pseudoScope.AddChange(e);
aggregatesToSave.Add(pseudoScope);
}
break;
case DHCPv4ScopeDeletedEvent e:
{
pseudoRootScope.RemoveScope(e.EntityId);
scopesToDelete.Add(e.EntityId);
}
break;
case EntityBasedDomainEvent e when
item is DHCPv4ScopePropertiesUpdatedEvent ||
item is DHCPv4ScopeNameUpdatedEvent ||
item is DHCPv4ScopeDescriptionUpdatedEvent ||
item is DHCPv4ScopeResolverUpdatedEvent ||
item is DHCPv4ScopeAddressPropertiesUpdatedEvent ||
item is DHCPv4ScopeParentUpdatedEvent ||
item is DHCPv4ScopeAddressesAreExhaustedEvent ||
item is DHCPv4ScopeSuspendedEvent ||
item is DHCPv4ScopeReactivedEvent:
{
var pseudoScope = new PseudoDHCPv4Scope(e.EntityId);
pseudoScope.AddChange(e);
aggregatesToSave.Add(pseudoScope);
}
break;
case DHCPv4LeaseCreatedEvent e:
{
pseudoRootScope.AddLease(e.EntityId);
var pseudoScope = new PseudoDHCPv4Lease(e.EntityId);
pseudoScope.AddChange(e);
aggregatesToSave.Add(pseudoScope);
}
break;
case DHCPv4LeaseRemovedEvent e:
{
pseudoRootScope.RemoveLease(e.EntityId);
leasesToDelete.Add(e.EntityId);
}
break;
case DHCPv4ScopeRelatedEvent e:
{
var pseudoLease = new PseudoDHCPv4Lease(e.EntityId);
pseudoLease.AddChange(e);
aggregatesToSave.Add(pseudoLease);
}
break;
default:
break;
}
}
foreach (var item in aggregatesToSave)
{
await EventStore.Save(item, 20);
if (item is PseudoDHCPv4Lease)
{
var propertyResolver = Provider.GetService <IDHCPv6ServerPropertiesResolver>();
await EventStore.ApplyMetaValuesForStream <PseudoDHCPv4Lease>(
item.Id,
new EventStoreStreamMetaValues(EventStoreStreamMetaValues.DoNotTruncate, propertyResolver.GetLeaseLifeTime()));
}
}
foreach (var item in scopesToDelete)
{
await EventStore.DeleteAggregateRoot <PseudoDHCPv4Scope>(item);
}
foreach (var item in leasesToDelete)
{
await EventStore.DeleteAggregateRoot <PseudoDHCPv4Lease>(item);
}
aggregateRoot.ClearChanges();
Boolean projectResult = await ReadStore.Project(events);
return(projectResult);
}
public Task <Boolean> LogFilteredDHCPv4Packet(DHCPv4Packet packet, String filterName) => ReadStore.LogFilteredDHCPv4Packet(packet, filterName);
public Task <Boolean> LogInvalidDHCPv4Packet(DHCPv4Packet packet) => ReadStore.LogInvalidDHCPv4Packet(packet);
public Task <IEnumerable <DHCPv4Listener> > GetDHCPv4Listener() => ReadStore.GetDHCPv4Listener();
public static async Task <AuctionReadModel> GetAuctionAsync(this ReadStore store, string auctionId)
{
return(await store.GetAll <AuctionReadModel>()
.SingleAsync(a => a.Id == auctionId));
}
public AuctionItemAddedEventHandler(ReadStore readStore)
{
_readStore = readStore;
}
public GetAuctionsListQueryHandler(ReadStore readStore)
{
_readStore = readStore;
}
/// <summary>
/// Get the identifiers of the named graphs in the store
/// </summary>
/// <returns>An enumeration of the identifiers of the named graphs in the store</returns>
public IEnumerable <string> ListNamedGraphs()
{
return(ReadStore.GetGraphUris().Where(x => x != Constants.DefaultGraphUri));
}
public AuctionCreatedEventHandler(ReadStore readStore)
{
_readStore = readStore;
}
