public void Base()
{
Converts.Repository
.AddJsonEnumSearchHandler()
.AddJsonPrimitivesSearchHandler()
.AddJsonObjectSearchHandler()
.AddJsonKey()
.AddJsonTimeSpan();
CompositeEventFormatter formatter = new CompositeEventFormatter(
new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory()),
Factory.Default <JsonCompositeStorage>()
);
MockEventStore eventStore = new MockEventStore();
// Creation of state.
Order order = new Order(KeyFactory.Create(typeof(Order)));
order.AddItem(KeyFactory.Create(typeof(T_EventSourcing_ReadModels_Rebuilder)), 2);
order.AddItem(KeyFactory.Create(typeof(Rebuilder)), 5);
eventStore.Save(order.Events.Select(e => new EventModel(order.Key, e.Key, formatter.Serialize(e), e.Version)));
// Rebuilding model.
Rebuilder rebuilder = new Rebuilder(eventStore, formatter);
ReadModelHandler handler = new ReadModelHandler();
rebuilder.AddAll(handler);
rebuilder.RunAsync().Wait();
Assert.AreEqual(1, handler.Totals.Count);
Assert.AreEqual(
order.Events.OfType <OrderTotalRecalculated>().Last().TotalPrice,
handler.Totals.FirstOrDefault().Value
);
}
public BackupContents(Rebuilder rebuilder, IUrlGenerator urlGenerator)
{
Guard.NotNull(rebuilder, nameof(rebuilder));
Guard.NotNull(urlGenerator, nameof(urlGenerator));
this.rebuilder = rebuilder;
this.urlGenerator = urlGenerator;
}
public RebuildRunner(
IOptions <RebuildOptions> rebuildOptions,
Rebuilder rebuilder,
RebuildFiles rebuildFiles)
{
this.rebuildFiles = rebuildFiles;
this.rebuilder = rebuilder;
this.rebuildOptions = rebuildOptions.Value;
}
static void Main(string[] args)
{
Console.WriteLine("Starting in thread: {0}", Thread.CurrentThread.ManagedThreadId);
var config = LocalConfig.CreateNew(ConfigurationManager.AppSettings["fileStore"]);
//where to send commands: this command sender is used by "processes" (things that receive events and
//publish commands). It makes sense to do it "locally", avoiding any queues.
//So it would look: got an event -> produced a command -> dispatched/executed it immediately.
var whereToSendLocalCommands = new ToDispatcherCommandSender(CommandDispatcher);
//spin up a commands receiver, it will receive commands and dispatch them to the CommandDispatcher
var commandsReceiver = config.CreateIncomingMessagesDispatcher(IncommingCommandsQueue, DispatchCommand);
var eventsReceiver = config.CreateIncomingMessagesDispatcher(IncommingEventsQueue, x => DispatchEvent((Envelope)x));
using (var host = new Host())
{
using (var eventStore = config.CreateEventStore("ZigguratES"))
{
var eventsFromEventSourceToQueueDistributor =
new EventStoreToQueueDistributor(IncommingEventsQueue, config.QueueFactory, eventStore, config.ProjectionsStore, config.Serializer);
var appServices = DomainBoundedContext.BuildApplicationServices(eventStore, config.ProjectionsStore);
var processes = DomainBoundedContext.BuildEventProcessors(whereToSendLocalCommands);
Func<IDocumentStore, IEnumerable<object>> getProjectionsFunction =
factory =>
{
var domainProjections = DomainBoundedContext.BuildProjections(factory);
var clientProjections = ClientBoundedContext.BuildProjections(factory);
return domainProjections.Concat(clientProjections);
};
var projectionRebuilder = new Rebuilder(
"definition",
eventStore,
config.ProjectionsStore,
getProjectionsFunction);
host.AddStartupTask(c => projectionRebuilder.Run());
var projections = getProjectionsFunction(config.ProjectionsStore);
foreach (var appService in appServices) CommandDispatcher.Subscribe(appService);
foreach (var projection in projections) EventsDispatcher.Subscribe(projection);
foreach (var process in processes) EventsDispatcher.Subscribe(process);
host.AddTask(c => commandsReceiver.Run(c));
host.AddTask(c => eventsFromEventSourceToQueueDistributor.Run(c));
host.AddTask(c => eventsReceiver.Run(c));
host.Run();
Thread.Sleep(400);
Console.ReadKey();
}
}
}
public BackupAssets(Rebuilder rebuilder, IAssetFileStore assetFileStore, ITagService tagService)
{
Guard.NotNull(rebuilder, nameof(rebuilder));
Guard.NotNull(assetFileStore, nameof(assetFileStore));
Guard.NotNull(tagService, nameof(tagService));
this.rebuilder = rebuilder;
this.assetFileStore = assetFileStore;
this.tagService = tagService;
}
public RebuildRunner(Rebuilder rebuilder, IOptions <RebuildOptions> rebuildOptions, PopulateGrainIndexes populateGrainIndexes)
{
Guard.NotNull(rebuilder, nameof(rebuilder));
Guard.NotNull(rebuildOptions, nameof(rebuildOptions));
Guard.NotNull(populateGrainIndexes, nameof(populateGrainIndexes));
this.rebuilder = rebuilder;
this.rebuildOptions = rebuildOptions.Value;
this.populateGrainIndexes = populateGrainIndexes;
}
public Boolean SyncronizeDatabases(ConnectionData gold, ConnectionData toUpdate, bool continueOnFailure)
{
DatabaseDiffer diff = new DatabaseDiffer();
DatabaseRunHistory toBeRun = diff.GetDatabaseHistoryDifference(gold, toUpdate);
PushInfo(string.Format("{0} database packages found to run on {1}.{2}", toBeRun.BuildFileHistory.Count, toUpdate.SQLServerName, toUpdate.DatabaseName));
if (toBeRun.BuildFileHistory.Count == 0) //already in sync
{
return(true);
}
//Make temp directory for rebuild packages...
string tempPath = System.IO.Path.GetTempPath() + System.Guid.NewGuid();
Directory.CreateDirectory(tempPath);
List <string> rebuiltPackages = new List <string>();
//Create SBM packages for each
foreach (var buildFileHistory in toBeRun.BuildFileHistory)
{
PushInfo(string.Format("Rebuilding Package {0} (Hash:{1})", buildFileHistory.BuildFileName, buildFileHistory.BuildFileHash));
var fileName = tempPath + "\\" + Path.GetFileNameWithoutExtension(buildFileHistory.BuildFileName) + ".sbm"; //Make sure it creates and SBM and not an SBX
var rebuildData = Rebuilder.RetreiveBuildData(gold, buildFileHistory.BuildFileHash, buildFileHistory.CommitDate);
rebuildData.ForEach(h => h.ScriptFileName = Path.GetFileName(h.ScriptFileName)); //trim off the path, we just want the file name
bool success = Rebuilder.RebuildBuildManagerFile(500, fileName, rebuildData);
if (!success)
{
PushInfo(string.Format("Error creating package {0} (Hash:{1}) see error log for details.", buildFileHistory.BuildFileName, buildFileHistory.BuildFileHash));
ProcessDirectoryCleanup(tempPath);
return(false);
}
rebuiltPackages.Add(fileName);
}
bool syncronized = ProcessSyncronizationPackages(rebuiltPackages, toUpdate, false, continueOnFailure);
if (syncronized)
{
PushInfo(string.Format("Syncronized database {0}.{1} to source {2}.{3}", toUpdate.SQLServerName,
toUpdate.DatabaseName, gold.SQLServerName, gold.DatabaseName));
}
else
{
PushInfo(string.Format("Syncronize failed to {0}.{1} from source {2}.{3}. See log for details.", toUpdate.SQLServerName,
toUpdate.DatabaseName, gold.SQLServerName, gold.DatabaseName));
}
ProcessDirectoryCleanup(tempPath);
return(syncronized);
}
public RebuildRunner(
IOptions <RebuildOptions> rebuildOptions,
Rebuilder rebuilder,
RebuildFiles rebuildFiles,
PopulateGrainIndexes populateGrainIndexes)
{
this.rebuildFiles = rebuildFiles;
this.rebuilder = rebuilder;
this.rebuildOptions = rebuildOptions.Value;
this.populateGrainIndexes = populateGrainIndexes;
}
public BackupApps(
Rebuilder rebuilder,
IAppImageStore appImageStore,
IAppsIndex appsIndex,
IAppUISettings appUISettings)
{
this.appsIndex = appsIndex;
this.rebuilder = rebuilder;
this.appImageStore = appImageStore;
this.appUISettings = appUISettings;
}
public void LoadSave(Rebuilder data)
{
try
{
Globals.Player = data.BuildPlayer();
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Could not load save data.\nError: ");
Console.ResetColor();
Console.WriteLine(e.StackTrace);
}
}
private Task RecreateReadModelContext()
{
using (var readModels = new ReadModelContext())
{
readModels.Database.EnsureDeleted();
readModels.Database.EnsureCreated();
}
// Should match with ReadModels.
Rebuilder rebuilder = new Rebuilder(eventStore, eventFormatter);
rebuilder.AddAll(new CategoryBuilder());
rebuilder.AddAll(new OutcomeBuilder(domainFacade.PriceFactory));
return(rebuilder.RunAsync());
}
public override bool ProcessFeatures(Dictionary <string, Feature> features)
{
// If the base fails, just fail out
if (!base.ProcessFeatures(features))
{
return(false);
}
// Get feature flags
bool copy = GetBoolean(features, CopyValue);
string outdat = GetString(features, OutStringValue);
// Verify the filenames
Dictionary <string, string> foundDats = GetValidDats(Inputs);
// Ensure the output directory is set
if (string.IsNullOrWhiteSpace(outdat))
{
outdat = "out";
}
// Now that we have the dictionary, we can loop through and output to a new folder for each
foreach (string key in foundDats.Keys)
{
// Get the DAT file associated with the key
DatFile datFile = Parser.CreateAndParse(Path.Combine(_dats, foundDats[key]));
// Set the depot values
datFile.Header.InputDepot = new DepotInformation(true, 4);
datFile.Header.OutputDepot = new DepotInformation(true, 4);
// Create the new output directory if it doesn't exist
string outputFolder = Path.Combine(outdat, Path.GetFileNameWithoutExtension(foundDats[key]));
outputFolder.Ensure(create: true);
// Get all online depots
List <string> onlineDepots = _depots.Where(d => d.Value.Item2).Select(d => d.Key).ToList();
// Now scan all of those depots and rebuild
Rebuilder.RebuildDepot(
datFile,
onlineDepots,
outDir: outputFolder,
outputFormat: copy ? OutputFormat.TorrentGzipRomba : OutputFormat.TorrentZip);
}
return(true);
}
internal async Task RecreateReadModelContextAsync()
{
using (var readModels = readModelContextFactory.Create())
{
await readModels.Database.EnsureDeletedAsync();
await readModels.Database.EnsureCreatedAsync();
}
// Should match with ReadModels.
Rebuilder rebuilder = new Rebuilder(eventStore, eventFormatter);
DefaultQueryDispatcher queryDispatcher = new DefaultQueryDispatcher();
Models.Builders.BootstrapTask bootstrapTask = new Models.Builders.BootstrapTask(queryDispatcher, rebuilder, readModelContextFactory, priceConverter);
bootstrapTask.Initialize();
await rebuilder.RunAsync();
}
public static Task RebuildRulesAsync(this Rebuilder rebuilder, CancellationToken ct = default)
{
return(rebuilder.RebuildAsync <RuleDomainObject, RuleState>("^rule\\-", ct));
}
public static Task RebuildSchemasAsync(this Rebuilder rebuilder, CancellationToken ct = default)
{
return(rebuilder.RebuildAsync <SchemaDomainObject, SchemaState>("^schema\\-", ct));
}
public static Task RebuildAppsAsync(this Rebuilder rebuilder, CancellationToken ct = default)
{
return(rebuilder.RebuildAsync <AppDomainObject, AppState>("^app\\-", ct));
}
public BackupContents(Rebuilder rebuilder)
{
Guard.NotNull(rebuilder);
this.rebuilder = rebuilder;
}
public RebuildSnapshots(Rebuilder rebuilder)
{
this.rebuilder = rebuilder;
}
public RebuildContents(Rebuilder rebuilder)
{
this.rebuilder = rebuilder;
}
public RebuildAssetFolders(Rebuilder rebuilder,
IOptions <RebuildOptions> rebuildOptions)
{
this.rebuilder = rebuilder;
this.rebuildOptions = rebuildOptions.Value;
}
public static Task RebuildAssetsAsync(this Rebuilder rebuilder, int batchSize, CancellationToken ct = default)
{
return(rebuilder.RebuildAsync <AssetDomainObject, AssetDomainObject.State>("^asset\\-", batchSize, ct));
}
public static Task RebuildAssetFoldersAsync(this Rebuilder rebuilder, CancellationToken ct = default)
{
return(rebuilder.RebuildAsync <AssetFolderDomainObject, AssetFolderState>("^assetFolder\\-", ct));
}
public RebuildAssets(Rebuilder rebuilder)
{
this.rebuilder = rebuilder;
}
public BackupAssets(Rebuilder rebuilder, IAssetFileStore assetFileStore, ITagService tagService)
{
this.rebuilder = rebuilder;
this.assetFileStore = assetFileStore;
this.tagService = tagService;
}
public override bool ProcessFeatures(Dictionary <string, SabreTools.Help.Feature> features)
{
// If the base fails, just fail out
if (!base.ProcessFeatures(features))
{
return(false);
}
// Get the archive scanning level
// TODO: Remove usage
int sevenzip = GetInt32(features, Include7ZipsInt32Value);
int gz = GetInt32(features, IncludeGZipsInt32Value);
int zip = GetInt32(features, IncludeZipsInt32Value);
// Get feature flags
bool noDb = GetBoolean(features, NoDbValue);
bool onlyNeeded = GetBoolean(features, OnlyNeededValue);
// First we want to get just all directories from the inputs
List <string> onlyDirs = new List <string>();
foreach (string input in Inputs)
{
if (Directory.Exists(input))
{
onlyDirs.Add(Path.GetFullPath(input));
}
}
// Then process all of the input directories into an internal DAT
DatFile df = DatFile.Create();
foreach (string dir in onlyDirs)
{
DatFromDir.PopulateFromDir(df, dir, asFiles: TreatAsFile.NonArchive, hashes: Hash.Standard);
DatFromDir.PopulateFromDir(df, dir, asFiles: TreatAsFile.All, hashes: Hash.Standard);
}
// Create an empty Dat for files that need to be rebuilt
DatFile need = DatFile.Create();
// Open the database connection
SqliteConnection dbc = new SqliteConnection(_connectionString);
dbc.Open();
// Now that we have the Dats, add the files to the database
string crcquery = "INSERT OR IGNORE INTO crc (crc) VALUES";
string md5query = "INSERT OR IGNORE INTO md5 (md5) VALUES";
string sha1query = "INSERT OR IGNORE INTO sha1 (sha1, depot) VALUES";
string crcsha1query = "INSERT OR IGNORE INTO crcsha1 (crc, sha1) VALUES";
string md5sha1query = "INSERT OR IGNORE INTO md5sha1 (md5, sha1) VALUES";
foreach (string key in df.Items.Keys)
{
ConcurrentList <DatItem> datItems = df.Items[key];
foreach (Rom rom in datItems)
{
// If we care about if the file exists, check the databse first
if (onlyNeeded && !noDb)
{
string query = "SELECT * FROM crcsha1 JOIN md5sha1 ON crcsha1.sha1=md5sha1.sha1"
+ $" WHERE crcsha1.crc=\"{rom.CRC}\""
+ $" OR md5sha1.md5=\"{rom.MD5}\""
+ $" OR md5sha1.sha1=\"{rom.SHA1}\"";
SqliteCommand slc = new SqliteCommand(query, dbc);
SqliteDataReader sldr = slc.ExecuteReader();
if (sldr.HasRows)
{
// Add to the queries
if (!string.IsNullOrWhiteSpace(rom.CRC))
{
crcquery += $" (\"{rom.CRC}\"),";
}
if (!string.IsNullOrWhiteSpace(rom.MD5))
{
md5query += $" (\"{rom.MD5}\"),";
}
if (!string.IsNullOrWhiteSpace(rom.SHA1))
{
sha1query += $" (\"{rom.SHA1}\", \"{_depots.Keys.ToList()[0]}\"),";
if (!string.IsNullOrWhiteSpace(rom.CRC))
{
crcsha1query += $" (\"{rom.CRC}\", \"{rom.SHA1}\"),";
}
if (!string.IsNullOrWhiteSpace(rom.MD5))
{
md5sha1query += $" (\"{rom.MD5}\", \"{rom.SHA1}\"),";
}
}
// Add to the Dat
need.Items.Add(key, rom);
}
}
// Otherwise, just add the file to the list
else
{
// Add to the queries
if (!noDb)
{
if (!string.IsNullOrWhiteSpace(rom.CRC))
{
crcquery += $" (\"{rom.CRC}\"),";
}
if (!string.IsNullOrWhiteSpace(rom.MD5))
{
md5query += $" (\"{rom.MD5}\"),";
}
if (!string.IsNullOrWhiteSpace(rom.SHA1))
{
sha1query += $" (\"{rom.SHA1}\", \"{_depots.Keys.ToList()[0]}\"),";
if (!string.IsNullOrWhiteSpace(rom.CRC))
{
crcsha1query += $" (\"{rom.CRC}\", \"{rom.SHA1}\"),";
}
if (!string.IsNullOrWhiteSpace(rom.MD5))
{
md5sha1query += $" (\"{rom.MD5}\", \"{rom.SHA1}\"),";
}
}
}
// Add to the Dat
need.Items.Add(key, rom);
}
}
}
// Now run the queries, if they're populated
if (crcquery != "INSERT OR IGNORE INTO crc (crc) VALUES")
{
SqliteCommand slc = new SqliteCommand(crcquery.TrimEnd(','), dbc);
slc.ExecuteNonQuery();
slc.Dispose();
}
if (md5query != "INSERT OR IGNORE INTO md5 (md5) VALUES")
{
SqliteCommand slc = new SqliteCommand(md5query.TrimEnd(','), dbc);
slc.ExecuteNonQuery();
slc.Dispose();
}
if (sha1query != "INSERT OR IGNORE INTO sha1 (sha1, depot) VALUES")
{
SqliteCommand slc = new SqliteCommand(sha1query.TrimEnd(','), dbc);
slc.ExecuteNonQuery();
slc.Dispose();
}
if (crcsha1query != "INSERT OR IGNORE INTO crcsha1 (crc, sha1) VALUES")
{
SqliteCommand slc = new SqliteCommand(crcsha1query.TrimEnd(','), dbc);
slc.ExecuteNonQuery();
slc.Dispose();
}
if (md5sha1query != "INSERT OR IGNORE INTO md5sha1 (md5, sha1) VALUES")
{
SqliteCommand slc = new SqliteCommand(md5sha1query.TrimEnd(','), dbc);
slc.ExecuteNonQuery();
slc.Dispose();
}
// Create the sorting object to use and rebuild the needed files
Rebuilder.RebuildGeneric(
need,
onlyDirs,
outDir: _depots.Keys.ToList()[0],
outputFormat: OutputFormat.TorrentGzipRomba,
asFiles: TreatAsFile.NonArchive);
return(true);
}
public static Task RebuildContentAsync(this Rebuilder rebuilder, CancellationToken ct = default)
{
return(rebuilder.RebuildAsync <ContentDomainObject, ContentState>("^content\\-", ct));
}
public BackupSchemas(Rebuilder rebuilder)
{
this.rebuilder = rebuilder;
}
public RebuildContents(Rebuilder rebuilder,
IOptions <RebuildOptions> rebuildOptions)
{
this.rebuilder = rebuilder;
this.rebuildOptions = rebuildOptions.Value;
}
public BackupRules(Rebuilder rebuilder)
{
this.rebuilder = rebuilder;
}
public BackupContents(Rebuilder rebuilder, IUrlGenerator urlGenerator)
{
this.rebuilder = rebuilder;
this.urlGenerator = urlGenerator;
}
public RebuildApps(Rebuilder rebuilder)
{
this.rebuilder = rebuilder;
}
