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 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); }
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; } } }