public RemotingPackage CreateRemotingPackage(string configurationName, DateTime ifModifiedSince)
{
Assert.ArgumentCondition(ifModifiedSince < DateTime.UtcNow, "ifModifiedSince", "ifModifiedSince was in the future. No no no.");
var configuration = UnicornConfigurationManager.Configurations.FirstOrDefault(x => x.Name.Equals(configurationName, StringComparison.Ordinal));
Assert.IsNotNull(configuration, "Invalid configuration specified.");
var logger = configuration.Resolve<ILogger>();
var package = new RemotingPackage(configuration);
if (ifModifiedSince == Constants.NotSyncedDateTime || (DateTime.UtcNow - ifModifiedSince) > Factory.GetDatabase("master").Engines.HistoryEngine.Storage.EntryLifeTime)
{
// load using full sync strategy - either we have nothing local or the last sync was too long ago to rely on history engine
logger.Info("Remoting full serialization: Processing Unicorn configuration " + configuration.Name);
ProcessFullSyncPackage(package, configuration, logger);
logger.Info("Remoting full serialization: Finished reserializing Unicorn configuration " + configuration.Name);
}
else
{
// load using history engine methodology (differential)
logger.Info("Remoting history engine serialization: Processing Unicorn configuration " + configuration.Name);
ProcessHistoryEnginePackage(package, configuration, ifModifiedSince);
logger.Info("Remoting history engine serialization: Finished Unicorn configuration " + configuration.Name);
}
return package;
}
private static void ProcessHistoryEnginePackage(RemotingPackage package, IConfiguration configuration, DateTime ifModifiedSince)
{
// TODO: need to "coalesce" history so we are not replaying more events than we need to
// e.g. create then move in one sync will cause the created item to not be present as a serialized item
// in the package because it was moved so the create fails
package.Manifest.Strategy = RemotingStrategy.Differential;
using (new SecurityDisabler())
{
var serializationProvider = package.SerializationProvider;
var roots = configuration.Resolve <PredicateRootPathResolver>().GetRootSourceItems();
var historyDatabases = roots.Select(x => x.DatabaseName).Distinct().Select(Factory.GetDatabase).ToArray();
foreach (var historyDatabase in historyDatabases)
{
var localHistory = GetMergedHistory(ifModifiedSince, historyDatabase);
foreach (var historyEntry in localHistory)
{
if (historyEntry.Action == HistoryAction.Moved)
{
var item = historyDatabase.GetItem(historyEntry.ItemId);
if (item == null)
{
continue; // invalid history entry - item deleted
}
var manifestEntry = RemotingPackageManifestEntry.FromEntry(historyEntry, historyDatabase.Name);
manifestEntry.OldItemPath = historyEntry.ItemPath; // on a moved entry, the itempath is the pre-move path
manifestEntry.ItemPath = item.Paths.Path; // the path from the Item is the post-move path
package.Manifest.AddEntry(manifestEntry);
}
else if (historyEntry.Action == HistoryAction.Deleted)
{
package.Manifest.AddEntry(RemotingPackageManifestEntry.FromEntry(historyEntry, historyDatabase.Name));
}
else
{
var item = historyDatabase.GetItem(historyEntry.ItemId);
if (item == null)
{
continue; // invalid history entry - item deleted
}
// serialize updated item to package directory
serializationProvider.SerializeItem(new SitecoreSourceItem(item));
package.Manifest.AddEntry(RemotingPackageManifestEntry.FromEntry(historyEntry, historyDatabase.Name));
}
}
}
package.Manifest.LastSynchronized = DateTime.UtcNow;
}
}
public RemotingPackage CreateRemotingPackage(string configurationName, DateTime ifModifiedSince)
{
Assert.ArgumentCondition(ifModifiedSince < DateTime.UtcNow, "ifModifiedSince", "ifModifiedSince was in the future. No no no.");
var configuration = UnicornConfigurationManager.Configurations.FirstOrDefault(x => x.Name.Equals(configurationName, StringComparison.Ordinal));
Assert.IsNotNull(configuration, "Invalid configuration specified.");
var logger = configuration.Resolve <ILogger>();
var package = new RemotingPackage(configuration);
if (ifModifiedSince == Constants.NotSyncedDateTime || (DateTime.UtcNow - ifModifiedSince) > Factory.GetDatabase("master").Engines.HistoryEngine.Storage.EntryLifeTime)
{
// load using full sync strategy - either we have nothing local or the last sync was too long ago to rely on history engine
logger.Info("Remoting full serialization: Processing Unicorn configuration " + configuration.Name);
ProcessFullSyncPackage(package, configuration, logger);
logger.Info("Remoting full serialization: Finished reserializing Unicorn configuration " + configuration.Name);
}
else
{
// load using history engine methodology (differential)
logger.Info("Remoting history engine serialization: Processing Unicorn configuration " + configuration.Name);
ProcessHistoryEnginePackage(package, configuration, ifModifiedSince);
logger.Info("Remoting history engine serialization: Finished Unicorn configuration " + configuration.Name);
}
return(package);
}
private void WriteDiffPackage(RemotingPackage package, string targetBasePath)
{
var actions = package.Manifest.HistoryEntries;
var packageBasePath = Path.Combine(package.TempDirectory, "serialization");
foreach (var action in actions)
{
var itemPath = SerializationPathUtility.GetSerializedItemPath(packageBasePath, action.Database, action.ItemPath);
switch (action.Action)
{
case HistoryAction.AddedVersion:
case HistoryAction.Created:
case HistoryAction.Saved:
// copy single item and overwrite existing if any
var targetCopyPath = SerializationPathUtility.GetSerializedItemPath(targetBasePath, action.Database, action.ItemPath);
Assert.IsTrue(File.Exists(itemPath), "Expected serialization item {0} missing from package!", itemPath);
Directory.CreateDirectory(Path.GetDirectoryName(targetCopyPath));
File.Copy(itemPath, targetCopyPath, true);
break;
case HistoryAction.Deleted:
// delete item + child references
var targetDeletePath = SerializationPathUtility.GetSerializedItemPath(targetBasePath, action.Database, action.ItemPath);
var targetChildrenDeletePath = SerializationPathUtility.GetSerializedReferencePath(targetBasePath, action.Database, action.ItemPath);
if (File.Exists(targetDeletePath)) File.Delete(targetDeletePath);
if (Directory.Exists(targetChildrenDeletePath)) Directory.Delete(targetChildrenDeletePath, true);
break;
case HistoryAction.Moved:
var targetOldPath = SerializationPathUtility.GetSerializedItemPath(targetBasePath, action.Database, action.OldItemPath);
var targetOldChildrenPath = SerializationPathUtility.GetSerializedReferencePath(targetBasePath, action.Database, action.ItemPath);
if (File.Exists(targetOldPath)) File.Delete(targetOldPath);
if (Directory.Exists(targetOldChildrenPath)) Directory.Delete(targetOldChildrenPath, true);
var targetNewPath = SerializationPathUtility.GetSerializedItemPath(targetBasePath, action.Database, action.ItemPath);
var targetNewChildrenPath = SerializationPathUtility.GetSerializedReferencePath(targetBasePath, action.Database, action.ItemPath);
var itemChildrenPath = SerializationPathUtility.GetSerializedReferencePath(packageBasePath, action.Database, action.ItemPath);
Directory.CreateDirectory(Path.GetDirectoryName(targetNewPath));
File.Copy(itemPath, targetNewPath, true);
if (Directory.Exists(itemChildrenPath))
{
Directory.CreateDirectory(targetNewChildrenPath);
CopyFilesRecursively(new DirectoryInfo(itemChildrenPath), new DirectoryInfo(targetNewChildrenPath));
}
break;
}
}
}
private static void ProcessHistoryEnginePackage(RemotingPackage package, IConfiguration configuration, DateTime ifModifiedSince)
{
// TODO: need to "coalesce" history so we are not replaying more events than we need to
// e.g. create then move in one sync will cause the created item to not be present as a serialized item
// in the package because it was moved so the create fails
package.Manifest.Strategy = RemotingStrategy.Differential;
using (new SecurityDisabler())
{
var serializationProvider = package.SerializationProvider;
var roots = configuration.Resolve<PredicateRootPathResolver>().GetRootSourceItems();
var historyDatabases = roots.Select(x => x.DatabaseName).Distinct().Select(Factory.GetDatabase).ToArray();
foreach (var historyDatabase in historyDatabases)
{
var localHistory = GetMergedHistory(ifModifiedSince, historyDatabase);
foreach (var historyEntry in localHistory)
{
if (historyEntry.Action == HistoryAction.Moved)
{
var item = historyDatabase.GetItem(historyEntry.ItemId);
if (item == null) continue; // invalid history entry - item deleted
var manifestEntry = RemotingPackageManifestEntry.FromEntry(historyEntry, historyDatabase.Name);
manifestEntry.OldItemPath = historyEntry.ItemPath; // on a moved entry, the itempath is the pre-move path
manifestEntry.ItemPath = item.Paths.Path; // the path from the Item is the post-move path
package.Manifest.AddEntry(manifestEntry);
}
else if (historyEntry.Action == HistoryAction.Deleted)
{
package.Manifest.AddEntry(RemotingPackageManifestEntry.FromEntry(historyEntry, historyDatabase.Name));
}
else
{
var item = historyDatabase.GetItem(historyEntry.ItemId);
if (item == null) continue; // invalid history entry - item deleted
// serialize updated item to package directory
serializationProvider.SerializeItem(new SitecoreSourceItem(item));
package.Manifest.AddEntry(RemotingPackageManifestEntry.FromEntry(historyEntry, historyDatabase.Name));
}
}
}
package.Manifest.LastSynchronized = DateTime.UtcNow;
}
}
public void WriteTo(RemotingPackage package, string path)
{
Assert.IsTrue(package.Manifest.Strategy != RemotingStrategy.Differential || Directory.Exists(path), "Invalid target directory! Must exist for differential strategy.");
if (package.Manifest.Strategy == RemotingStrategy.Full)
{
WriteFullPackage(package, path);
}
else
{
WriteDiffPackage(package, path);
}
}
public void WriteTo(RemotingPackage package, string path)
{
Assert.IsTrue(package.Manifest.Strategy != RemotingStrategy.Differential || Directory.Exists(path), "Invalid target directory! Must exist for differential strategy.");
if (package.Manifest.Strategy == RemotingStrategy.Full)
{
WriteFullPackage(package, path);
}
else
{
WriteDiffPackage(package, path);
}
}
public static RemotingPackage FromStream(Stream zipStream)
{
Assert.ArgumentNotNull(zipStream, "zipStream");
var tempDirectory = GenerateTempDirectory();
Compression.DecompressZipFileFromStream(zipStream, tempDirectory);
var manifest = JsonConvert.DeserializeObject <RemotingPackageManifest>(File.ReadAllText(Path.Combine(tempDirectory, "manifest.json")));
var package = new RemotingPackage(manifest, tempDirectory);
return(package);
}
public static RemotingPackage FromStream(Stream zipStream)
{
Assert.ArgumentNotNull(zipStream, "zipStream");
var tempDirectory = GenerateTempDirectory();
Compression.DecompressZipFileFromStream(zipStream, tempDirectory);
var manifest = JsonConvert.DeserializeObject<RemotingPackageManifest>(File.ReadAllText(Path.Combine(tempDirectory, "manifest.json")));
var package = new RemotingPackage(manifest, tempDirectory);
return package;
}
private void ProcessFullSyncPackage(RemotingPackage package, IConfiguration configuration, ILogger logger)
{
package.Manifest.Strategy = RemotingStrategy.Full;
using (new SecurityDisabler())
{
var predicate = configuration.Resolve<IPredicate>();
var roots = configuration.Resolve<PredicateRootPathResolver>().GetRootSourceItems();
foreach (var root in roots)
{
logger.Info("[U] Serializing included items under root {0}".FormatWith(root.DisplayIdentifier));
Serialize(root, predicate, package.SerializationProvider, logger);
}
}
}
private void ProcessFullSyncPackage(RemotingPackage package, IConfiguration configuration, ILogger logger)
{
package.Manifest.Strategy = RemotingStrategy.Full;
using (new SecurityDisabler())
{
var predicate = configuration.Resolve <IPredicate>();
var roots = configuration.Resolve <PredicateRootPathResolver>().GetRootSourceItems();
foreach (var root in roots)
{
logger.Info("[U] Serializing included items under root {0}".FormatWith(root.DisplayIdentifier));
Serialize(root, predicate, package.SerializationProvider, logger);
}
}
}
private void WriteFullPackage(RemotingPackage package, string path)
{
// get rid of any existing serialized items before we overwrite them
var roots = _pathResolver.GetRootSourceItems();
foreach (var root in roots)
{
var rootReference = _serializationProvider.GetReference(root);
if (rootReference != null)
{
rootReference.Delete();
}
}
var sourcePath = new DirectoryInfo(Path.Combine(package.TempDirectory, "serialization"));
var targetPath = new DirectoryInfo(path);
targetPath.Create();
CopyFilesRecursively(sourcePath, targetPath);
}
private void WriteFullPackage(RemotingPackage package, string path)
{
// get rid of any existing serialized items before we overwrite them
var roots = _pathResolver.GetRootSourceItems();
foreach (var root in roots)
{
var rootReference = _serializationProvider.GetReference(root);
if (rootReference != null)
{
rootReference.Delete();
}
}
var sourcePath = new DirectoryInfo(Path.Combine(package.TempDirectory, "serialization"));
var targetPath = new DirectoryInfo(path);
targetPath.Create();
CopyFilesRecursively(sourcePath, targetPath);
}
public DifferentialPackageReplayer(RemotingPackage package)
{
_package = package;
Assert.ArgumentNotNull(package, "package");
Assert.IsTrue(package.Manifest.Strategy == RemotingStrategy.Differential, "Package must be differential to use the replayer.");
}
private void WriteDiffPackage(RemotingPackage package, string targetBasePath)
{
var actions = package.Manifest.HistoryEntries;
var packageBasePath = Path.Combine(package.TempDirectory, "serialization");
foreach (var action in actions)
{
var itemPath = SerializationPathUtility.GetSerializedItemPath(packageBasePath, action.Database, action.ItemPath);
switch (action.Action)
{
case HistoryAction.AddedVersion:
case HistoryAction.Created:
case HistoryAction.Saved:
// copy single item and overwrite existing if any
var targetCopyPath = SerializationPathUtility.GetSerializedItemPath(targetBasePath, action.Database, action.ItemPath);
Assert.IsTrue(File.Exists(itemPath), "Expected serialization item {0} missing from package!", itemPath);
Directory.CreateDirectory(Path.GetDirectoryName(targetCopyPath));
File.Copy(itemPath, targetCopyPath, true);
break;
case HistoryAction.Deleted:
// delete item + child references
var targetDeletePath = SerializationPathUtility.GetSerializedItemPath(targetBasePath, action.Database, action.ItemPath);
var targetChildrenDeletePath = SerializationPathUtility.GetSerializedReferencePath(targetBasePath, action.Database, action.ItemPath);
if (File.Exists(targetDeletePath))
{
File.Delete(targetDeletePath);
}
if (Directory.Exists(targetChildrenDeletePath))
{
Directory.Delete(targetChildrenDeletePath, true);
}
break;
case HistoryAction.Moved:
var targetOldPath = SerializationPathUtility.GetSerializedItemPath(targetBasePath, action.Database, action.OldItemPath);
var targetOldChildrenPath = SerializationPathUtility.GetSerializedReferencePath(targetBasePath, action.Database, action.ItemPath);
if (File.Exists(targetOldPath))
{
File.Delete(targetOldPath);
}
if (Directory.Exists(targetOldChildrenPath))
{
Directory.Delete(targetOldChildrenPath, true);
}
var targetNewPath = SerializationPathUtility.GetSerializedItemPath(targetBasePath, action.Database, action.ItemPath);
var targetNewChildrenPath = SerializationPathUtility.GetSerializedReferencePath(targetBasePath, action.Database, action.ItemPath);
var itemChildrenPath = SerializationPathUtility.GetSerializedReferencePath(packageBasePath, action.Database, action.ItemPath);
Directory.CreateDirectory(Path.GetDirectoryName(targetNewPath));
File.Copy(itemPath, targetNewPath, true);
if (Directory.Exists(itemChildrenPath))
{
Directory.CreateDirectory(targetNewChildrenPath);
CopyFilesRecursively(new DirectoryInfo(itemChildrenPath), new DirectoryInfo(targetNewChildrenPath));
}
break;
}
}
}
public DifferentialPackageReplayer(RemotingPackage package)
{
_package = package;
Assert.ArgumentNotNull(package, "package");
Assert.IsTrue(package.Manifest.Strategy == RemotingStrategy.Differential, "Package must be differential to use the replayer.");
}
