Exemplo n.º 1
0
        public virtual bool ReserializeConfigurations(IConfiguration[] configurations, IProgressStatus progress, ILogger additionalLogger)
        {
            int taskNumber = 1;

            try
            {
                var startArgs = new UnicornReserializeStartPipelineArgs(OperationType.FullReserialize, configurations, additionalLogger, null);
                MergePipelineArgs(startArgs);
                CorePipeline.Run("unicornReserializeStart", startArgs);

                foreach (var configuration in configurations)
                {
                    var logger = configuration.Resolve <ILogger>();

                    using (new LoggingContext(additionalLogger, configuration))
                    {
                        try
                        {
                            var timer = new Stopwatch();
                            timer.Start();

                            logger.Info(string.Empty);
                            logger.Info(configuration.Name + " is being reserialized.");

                            using (new TransparentSyncDisabler())
                            {
                                var targetDataStore = configuration.Resolve <ITargetDataStore>();
                                var helper          = configuration.Resolve <SerializationHelper>();

                                // nuke any existing items in the store before we begin. This is a full reserialize so we want to
                                // get rid of any existing stuff even if it's not part of existing configs
                                logger.Warn("[D] Clearing existing items from {0} (if any)".FormatWith(targetDataStore.FriendlyName));
                                targetDataStore.Clear();

                                var roots = configuration.Resolve <PredicateRootPathResolver>().GetRootSourceItems();

                                int index = 1;
                                foreach (var root in roots)
                                {
                                    helper.ReserializeTree(root, false, new[] { configuration });
                                    WebConsoleUtility.SetTaskProgress(progress, taskNumber, configurations.Length, (int)((index / (double)roots.Length) * 100));
                                    index++;
                                }
                            }

                            timer.Stop();

                            CorePipeline.Run("unicornReserializeComplete", MergePipelineArgs(new UnicornReserializeCompletePipelineArgs(configuration)));

                            logger.Info("{0} reserialization complete in {1}ms.".FormatWith(configuration.Name, timer.ElapsedMilliseconds));
                        }
                        catch (Exception ex)
                        {
                            logger.Error(ex);
                            return(false);
                        }

                        taskNumber++;
                    }
                }
            }
            finally
            {
                ReactorContext.Dispose();
            }

            return(true);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Reserializes an item and all of its children.
        /// </summary>
        /// <param name="item">Root item to reserialize</param>
        /// <param name="runReserializeStartPipeline">Whether this is a standalone reserialize (true) or part of a larger batch (false)</param>
        /// <param name="configurations">The configuration(s) to allow reserialization of</param>
        /// <returns>True if the tree was dumped, false if the root item was not included</returns>
        public virtual bool ReserializeTree(IItemData item, bool runReserializeStartPipeline = true, IConfiguration[] configurations = null)
        {
            using (new TransparentSyncDisabler())
            {
                if (configurations == null)
                {
                    configurations = GetConfigurationsForItem(item);
                }

                if (configurations.Length == 0)
                {
                    return(false);
                }

                // check if Dilithium was already running. If it was, we won't dispose it when we're done.
                bool dilithiumWasStarted = ReactorContext.IsActive;

                try
                {
                    if (runReserializeStartPipeline)
                    {
                        var startArgs = new UnicornReserializeStartPipelineArgs(OperationType.PartialReserializeTree, configurations, configurations.First().Resolve <ILogger>(), item);
                        MergePipelineArgs(startArgs);
                        CorePipeline.Run("unicornReserializeStart", startArgs);
                    }

                    foreach (var configuration in configurations)
                    {
                        if (configuration == null)
                        {
                            continue;
                        }

                        var logger = configuration.Resolve <ILogger>();

                        var predicate          = configuration.Resolve <IPredicate>();
                        var serializationStore = configuration.Resolve <ITargetDataStore>();
                        var sourceStore        = configuration.Resolve <ISourceDataStore>();
                        var dpConfig           = configuration.Resolve <IUnicornDataProviderConfiguration>();

                        var rootReference = serializationStore.GetByPathAndId(item.Path, item.Id, item.DatabaseName);
                        if (rootReference != null)
                        {
                            logger.Warn("[D] existing serialized items under {0}".FormatWith(rootReference.GetDisplayIdentifier()));
                            serializationStore.Remove(rootReference);
                        }

                        logger.Info("[A] Serializing included items under root {0}".FormatWith(item.GetDisplayIdentifier()));

                        if (!predicate.Includes(item).IsIncluded)
                        {
                            continue;
                        }

                        DumpTreeInternal(item, predicate, serializationStore, sourceStore, logger, dpConfig);
                    }
                }
                finally
                {
                    if (!dilithiumWasStarted)
                    {
                        ReactorContext.Dispose();
                    }
                }
            }

            return(true);
        }
Exemplo n.º 3
0
        /// <returns>True if the item was dumped, false if it was not included</returns>
        public virtual bool ReserializeItem(IItemData item, IConfiguration[] configurations = null)
        {
            using (new TransparentSyncDisabler())
            {
                if (configurations == null)
                {
                    configurations = GetConfigurationsForItem(item);
                }

                // return false; item not part of any configs
                if (configurations.Length == 0)
                {
                    return(false);
                }

                // check if Dilithium was already running. If it was, we won't dispose it when we're done.
                bool dilithiumWasStarted = ReactorContext.IsActive;

                try
                {
                    var startArgs = new UnicornReserializeStartPipelineArgs(OperationType.PartialReserializeItem, configurations, configurations.First().Resolve <ILogger>(), item);
                    MergePipelineArgs(startArgs);
                    CorePipeline.Run("unicornReserializeStart", startArgs);

                    foreach (var configuration in configurations)
                    {
                        if (configuration == null)
                        {
                            return(false);
                        }

                        var predicate          = configuration.Resolve <IPredicate>();
                        var serializationStore = configuration.Resolve <ITargetDataStore>();
                        var dpConfig           = configuration.Resolve <IUnicornDataProviderConfiguration>();

                        if (dpConfig.EnableTransparentSync)
                        {
                            CacheManager.ClearAllCaches();
                            // BOOM! This clears all caches before we begin;
                            // because for a TpSync configuration we could have TpSync items in the data cache which 'taint' the reserialize
                            // from being purely database
                        }

                        var result = DumpItemInternal(item, predicate, serializationStore).IsIncluded;

                        if (dpConfig.EnableTransparentSync)
                        {
                            CacheManager.ClearAllCaches();
                            // BOOM! And we clear everything again at the end, because now
                            // for a TpSync configuration we might have DATABASE items in cache where we want TpSync.
                        }

                        if (!result)
                        {
                            return(false);
                        }
                    }
                }
                finally
                {
                    if (!dilithiumWasStarted)
                    {
                        ReactorContext.Dispose();
                    }
                }

                return(true);
            }
        }
Exemplo n.º 4
0
 public void Process(UnicornReserializeStartPipelineArgs args)
 {
     ProcessInternal(args);
 }