Exemplo n.º 1
0
        internal static void SaveNodeData(Node node, NodeSaveSettings settings, out IndexDocumentData indexDocument)
        {
            indexDocument = null;

            var isNewNode     = node.Id == 0;
            var data          = node.Data;
            var deadlockCount = 0;
            var isDeadlock    = false;

            while (deadlockCount++ < maxDeadlockIterations)
            {
                isDeadlock = !SaveNodeDataTransactional(node, settings, out indexDocument);
                if (!isDeadlock)
                {
                    break;
                }
                Logger.WriteWarning("Deadlock detected in SaveNodeData",
                                    new Dictionary <string, object> {
                    { "Id: ", node.Id }, { "Path: ", node.Path }, { "Version: ", node.Version }
                });
                System.Threading.Thread.Sleep(sleepIfDeadlock);
            }

            if (isNewNode)
            {
                Logger.WriteVerbose("Node created.", CollectLoggerProperties, data);
            }
            else
            {
                Logger.WriteVerbose("Node updated.", CollectLoggerProperties, data);
            }
        }
Exemplo n.º 2
0
 public override void Save(NodeSaveSettings settings)
 {
     var thisUser = this.User;
     if (thisUser != null) // skip when importing
     {
         this.NodeCreatedBy = thisUser;
         this.NodeModifiedBy = thisUser;
         this.CreatedBy = thisUser;
         this.ModifiedBy = thisUser;
     }
     base.Save(settings);
 }
Exemplo n.º 3
0
        //================================================================================= Methods

        public override void Save(NodeSaveSettings settings)
        {
            var isNew = this.IsNew;
            bool import = RepositoryConfiguration.SpecialWorkingMode == "Import";
            if (isNew && !import)
            {
                Name = GenerateName();
            }

            base.Save(settings);

            if (isNew && !this.CopyInProgress && !import)
                SendMail();
        }
Exemplo n.º 4
0
        internal static void SaveNodeData(Node node, NodeSaveSettings settings, IIndexPopulator populator, string originalPath, string newPath)
        {
            var isNewNode     = node.Id == 0;
            var data          = node.Data;
            var deadlockCount = 0;
            var isDeadlock    = false;

            while (deadlockCount++ < maxDeadlockIterations)
            {
                var stopper = Stopwatch.StartNew();
                isDeadlock = !SaveNodeDataTransactional(node, settings, populator, originalPath, newPath);
                Debug.WriteLine("<? SaveNodeDataTransactional: " + node.Path + ", " + stopper.Elapsed);
                stopper.Stop();

                if (!isDeadlock)
                {
                    break;
                }

                Logger.WriteWarning(Logger.EventId.NotDefined, "Deadlock detected in SaveNodeData",
                                    properties: new Dictionary <string, object> {
                    { "Id: ", node.Id }, { "Path: ", node.Path }, { "Version: ", node.Version }
                });

                System.Threading.Thread.Sleep(sleepIfDeadlock);
            }

            if (isNewNode)
            {
                Logger.WriteVerbose("Node created.", CollectLoggerProperties, data);
            }
            else
            {
                Logger.WriteVerbose("Node updated.", CollectLoggerProperties, data);
            }
        }
Exemplo n.º 5
0
 public override void Save(NodeSaveSettings settings)
 {
     AssertUserName();
     base.Save(settings);
 }
Exemplo n.º 6
0
 //==================================================================================== Overrides
 public override void Save(NodeSaveSettings settings)
 {
     base.Save(settings);
     this.MoveToFolder();
 }
Exemplo n.º 7
0
 // caller: Node.Save, Node.SaveCopied
 public object BeginPopulateNode(Node node, NodeSaveSettings settings, string originalPath, string newPath)
 {
     var populatorData = new DocumentPopulatorData
     {
         Node = node,
         Settings = settings,
         OriginalPath = originalPath,
         NewPath = newPath,
         NodeHead = settings.NodeHead,
         IsNewNode = node.Id == 0,
     };
     return populatorData;
 }
Exemplo n.º 8
0
        private static bool SaveNodeDataTransactional(Node node, NodeSaveSettings settings, out IndexDocumentData indexDocument)
        {
            indexDocument = null;

            var data = node.Data;
            var isNewNode = data.Id == 0;
            var isLocalTransaction = !TransactionScope.IsActive;
            if (isLocalTransaction)
                TransactionScope.Begin();
            try
            {
                data.CreateSnapshotData();
                var participant = new NodeDataParticipant { Data = data, Settings = settings, IsNewNode = isNewNode };
                TransactionScope.Participate(participant);

                int lastMajorVersionId, lastMinorVersionId;
                DataProvider.Current.SaveNodeData(data, settings, out lastMajorVersionId, out lastMinorVersionId);

                //-- here we re-create the node head to insert it into the cache and refresh the version info
                if (lastMajorVersionId > 0 || lastMinorVersionId > 0)
                {
                    var head = NodeHead.CreateFromNode(node, lastMinorVersionId, lastMajorVersionId);
                    if (MustCache(node.NodeType))
                    {
                        //-- participate cache items
                        var idKey = CreateNodeHeadIdCacheKey(head.Id);
                        var participant2 = new InsertCacheParticipant { CacheKey = idKey };
                        TransactionScope.Participate(participant2);
                        var pathKey = CreateNodeHeadPathCacheKey(head.Path);
                        var participant3 = new InsertCacheParticipant { CacheKey = pathKey };
                        TransactionScope.Participate(participant3);

                        CacheNodeHead(head, idKey, pathKey);
                    }

                    node.RefreshVersionInfo(head);

                    if (!settings.DeletableVersionIds.Contains(node.VersionId))
                        indexDocument = SaveIndexDocument(node);
                }

                if (isLocalTransaction)
                    TransactionScope.Commit();
            }
            catch (System.Data.Common.DbException dbe)
            {
                if (isLocalTransaction && IsDeadlockException(dbe))
                    return false;
                throw SavingExceptionHelper(data, dbe);
            }
            catch (Exception e)
            {
                var ee = SavingExceptionHelper(data, e);
                if (ee == e)
                    throw;
                else
                    throw ee;
            }
            finally
            {
                if (isLocalTransaction && TransactionScope.IsActive)
                    TransactionScope.Rollback();
            }
            return true;
        }
Exemplo n.º 9
0
        internal static void SaveNodeData(Node node, NodeSaveSettings settings, out IndexDocumentData indexDocument)
        {
            indexDocument = null;

            var isNewNode = node.Id == 0;
            var data = node.Data;
            var deadlockCount = 0;
            var isDeadlock = false;
            while (deadlockCount++ < maxDeadlockIterations)
            {
                isDeadlock = !SaveNodeDataTransactional(node, settings, out indexDocument);
                if (!isDeadlock)
                    break;
                Logger.WriteWarning("Deadlock detected in SaveNodeData",
                    new Dictionary<string, object> { { "Id: ", node.Id }, { "Path: ", node.Path }, { "Version: ", node.Version } });
                System.Threading.Thread.Sleep(sleepIfDeadlock);
            }

            if (isNewNode)
                Logger.WriteVerbose("Node created.", CollectLoggerProperties, data);
            else
                Logger.WriteVerbose("Node updated.", CollectLoggerProperties, data);
        }
Exemplo n.º 10
0
        public override void Save(NodeSaveSettings settings)
        {
            // Check uniqueness first
            CheckUniqueUser();

            Domain = GenerateDomain();

            var originalId = this.Id;

            // save current password to the list of old passwords
            this.SaveCurrentPassword();

            base.Save(settings);

            // AD Sync
            SynchUser(originalId);

            // set creator for performant self permission setting
            // creator of the user will always be the user itself. this way setting permissions to the creators group on /Root/IMS will be adequate for user permissions
            // if you need the original creator, use the auditlog
            if (originalId == 0)
            {
                this.CreatedBy = this;
                this.NodeCreatedBy = this;
                base.SaveSameVersion();
            }
            
            // create profiles
            if (originalId == 0 && Repository.UserProfilesEnabled)
                CreateProfile();
        }
Exemplo n.º 11
0
        internal static void SaveNodeData(Node node, NodeSaveSettings settings, IIndexPopulator populator, string originalPath, string newPath)
        {
            var isNewNode      = node.Id == 0;
            var isOwnerChanged = node.Data.IsPropertyChanged("OwnerId");

            if (!isNewNode && isOwnerChanged)
            {
                node.Security.Assert(PermissionType.TakeOwnership);
            }

            var data    = node.Data;
            var attempt = 0;

            using (var op = SnTrace.Database.StartOperation("SaveNodeData"))
            {
                while (true)
                {
                    attempt++;

                    var deadlockException = SaveNodeDataTransactional(node, settings, populator, originalPath, newPath);
                    if (deadlockException == null)
                    {
                        break;
                    }

                    SnTrace.Database.Write("DEADLOCK detected. Attempt: {0}/{1}, NodeId:{2}, Version:{3}, Path:{4}",
                                           attempt, maxDeadlockIterations, node.Id, node.Version, node.Path);

                    if (attempt >= maxDeadlockIterations)
                    {
                        throw new Exception(string.Format("Error saving node. Id: {0}, Path: {1}", node.Id, node.Path), deadlockException);
                    }

                    SnLog.WriteWarning("Deadlock detected in SaveNodeData", properties:
                                       new Dictionary <string, object>
                    {
                        { "Id: ", node.Id },
                        { "Path: ", node.Path },
                        { "Version: ", node.Version },
                        { "Attempt: ", attempt }
                    });

                    System.Threading.Thread.Sleep(sleepIfDeadlock);
                }
                op.Successful = true;
            }

            try
            {
                if (isNewNode)
                {
                    SecurityHandler.CreateSecurityEntity(node.Id, node.ParentId, node.OwnerId);
                }
                else if (isOwnerChanged)
                {
                    SecurityHandler.ModifyEntityOwner(node.Id, node.OwnerId);
                }
            }
            catch (EntityNotFoundException e)
            {
                SnLog.WriteException(e, $"Error during creating or modifying security entity: {node.Id}. Original message: {e}",
                                     EventId.Security);
            }
            catch (SecurityStructureException) // suppressed
            {
                // no need to log this: somebody else already created or modified this security entity
            }

            if (isNewNode)
            {
                SnTrace.ContentOperation.Write("Node created. Id:{0}, Path:{1}", data.Id, data.Path);
            }
            else
            {
                SnTrace.ContentOperation.Write("Node updated. Id:{0}, Path:{1}", data.Id, data.Path);
            }
        }
Exemplo n.º 12
0
        private static bool SaveNodeDataTransactional(Node node, NodeSaveSettings settings, IIndexPopulator populator, string originalPath, string newPath)
        {
            IndexDocumentData indexDocument = null;
            bool hasBinary = false;

            var data      = node.Data;
            var isNewNode = data.Id == 0;
            NodeDataParticipant participant = null;
            var isLocalTransaction          = !TransactionScope.IsActive;

            if (isLocalTransaction)
            {
                TransactionScope.Begin();
            }
            Logger.WriteVerbose("Transaction: " + TransactionScope.CurrentId + " SAVING " + node.Id + ", " + node.Path);

            try
            {
                //-- collect data for populator
                var populatorData = populator.BeginPopulateNode(node, settings, originalPath, newPath);

                data.CreateSnapshotData();

                participant = new NodeDataParticipant {
                    Data = data, Settings = settings, IsNewNode = isNewNode
                };

                TransactionScope.Participate(participant);

                int lastMajorVersionId, lastMinorVersionId;
                DataProvider.Current.SaveNodeData(data, settings, out lastMajorVersionId, out lastMinorVersionId);

                //-- here we re-create the node head to insert it into the cache and refresh the version info);
                if (lastMajorVersionId > 0 || lastMinorVersionId > 0)
                {
                    var head = NodeHead.CreateFromNode(node, lastMinorVersionId, lastMajorVersionId);
                    if (MustCache(node.NodeType))
                    {
                        //-- participate cache items
                        var idKey        = CreateNodeHeadIdCacheKey(head.Id);
                        var participant2 = new InsertCacheParticipant {
                            CacheKey = idKey
                        };
                        TransactionScope.Participate(participant2);
                        var pathKey      = CreateNodeHeadPathCacheKey(head.Path);
                        var participant3 = new InsertCacheParticipant {
                            CacheKey = pathKey
                        };
                        TransactionScope.Participate(participant3);

                        CacheNodeHead(head, idKey, pathKey);
                    }

                    node.RefreshVersionInfo(head);

                    if (!settings.DeletableVersionIds.Contains(node.VersionId))
                    {
                        // Elevation: we need to create the index document with full
                        // control to avoid field access errors (indexing must be independent
                        // from the current users permissions).
                        using (new SystemAccount())
                        {
                            indexDocument = SaveIndexDocument(node, true, out hasBinary);
                        }
                    }
                }

                if (isLocalTransaction)
                {
                    TransactionScope.Commit();
                }

                //-- populate
                using (new SystemAccount())
                    populator.CommitPopulateNode(populatorData, indexDocument);

                if (indexDocument != null && hasBinary)
                {
                    using (new SystemAccount())
                    {
                        indexDocument = SaveIndexDocument(node, indexDocument);
                        populator.FinalizeTextExtracting(populatorData, indexDocument);
                    }
                }
            }
            catch (NodeIsOutOfDateException)
            {
                RemoveFromCache(participant);
                throw;
            }
            catch (System.Data.Common.DbException dbe)
            {
                Logger.WriteException(new Exception(string.Format("Error saving node. Id: {0}, Path: {1}", node.Id, node.Path), dbe));

                if (isLocalTransaction && IsDeadlockException(dbe))
                {
                    return(false);
                }
                throw SavingExceptionHelper(data, dbe);
            }
            catch (Exception e)
            {
                Logger.WriteException(new Exception(string.Format("Error saving node. Id: {0}, Path: {1}", node.Id, node.Path), e));

                var ee = SavingExceptionHelper(data, e);
                if (ee == e)
                {
                    throw;
                }
                else
                {
                    throw ee;
                }
            }
            finally
            {
                if (isLocalTransaction && TransactionScope.IsActive)
                {
                    TransactionScope.Rollback();
                }
            }
            return(true);
        }
Exemplo n.º 13
0
 public override void Save(NodeSaveSettings settings)
 {
     base.Save(settings);
 }
Exemplo n.º 14
0
        private static bool SaveNodeDataTransactional(Node node, NodeSaveSettings settings, out IndexDocumentData indexDocument)
        {
            indexDocument = null;

            var data               = node.Data;
            var isNewNode          = data.Id == 0;
            var isLocalTransaction = !TransactionScope.IsActive;

            if (isLocalTransaction)
            {
                TransactionScope.Begin();
            }
            try
            {
                data.CreateSnapshotData();
                var participant = new NodeDataParticipant {
                    Data = data, Settings = settings, IsNewNode = isNewNode
                };
                TransactionScope.Participate(participant);

                int lastMajorVersionId, lastMinorVersionId;
                DataProvider.Current.SaveNodeData(data, settings, out lastMajorVersionId, out lastMinorVersionId);

                //-- here we re-create the node head to insert it into the cache and refresh the version info
                if (lastMajorVersionId > 0 || lastMinorVersionId > 0)
                {
                    var head = NodeHead.CreateFromNode(node, lastMinorVersionId, lastMajorVersionId);
                    if (MustCache(node.NodeType))
                    {
                        //-- participate cache items
                        var idKey        = CreateNodeHeadIdCacheKey(head.Id);
                        var participant2 = new InsertCacheParticipant {
                            CacheKey = idKey
                        };
                        TransactionScope.Participate(participant2);
                        var pathKey      = CreateNodeHeadPathCacheKey(head.Path);
                        var participant3 = new InsertCacheParticipant {
                            CacheKey = pathKey
                        };
                        TransactionScope.Participate(participant3);

                        CacheNodeHead(head, idKey, pathKey);
                    }

                    node.RefreshVersionInfo(head);

                    if (!settings.DeletableVersionIds.Contains(node.VersionId))
                    {
                        indexDocument = SaveIndexDocument(node);
                    }
                }

                if (isLocalTransaction)
                {
                    TransactionScope.Commit();
                }
            }
            catch (System.Data.Common.DbException dbe)
            {
                if (isLocalTransaction && IsDeadlockException(dbe))
                {
                    return(false);
                }
                throw SavingExceptionHelper(data, dbe);
            }
            catch (Exception e)
            {
                var ee = SavingExceptionHelper(data, e);
                if (ee == e)
                {
                    throw;
                }
                else
                {
                    throw ee;
                }
            }
            finally
            {
                if (isLocalTransaction && TransactionScope.IsActive)
                {
                    TransactionScope.Rollback();
                }
            }
            return(true);
        }
Exemplo n.º 15
0
 public override void Save(NodeSaveSettings settings)
 {
     AssertTimeSpan();
     base.Save(settings);
 }
Exemplo n.º 16
0
        public override void Save(NodeSaveSettings settings)
        {
            // copy abortonrelatedcontentchange info from definition to instance
            var workflowDefinition = Node.Load<WorkflowDefinitionHandler>(GetWorkflowDefinitionPath());
            if (workflowDefinition != null)
                this.AbortOnRelatedContentChange = workflowDefinition.AbortOnRelatedContentChange;

            base.Save(settings);
        }
Exemplo n.º 17
0
 public override void Save(NodeSaveSettings settings)
 {
     base.Save(settings);
     DeviceManager.Reset();
 }
Exemplo n.º 18
0
        private static Exception SaveNodeDataTransactional(Node node, NodeSaveSettings settings, IIndexPopulator populator, string originalPath, string newPath)
        {
            IndexDocumentData indexDocument = null;
            bool hasBinary = false;

            var data      = node.Data;
            var isNewNode = data.Id == 0;
            NodeDataParticipant participant = null;

            var msg = "Saving Node#" + node.Id + ", " + node.ParentPath + "/" + node.Name;
            var isLocalTransaction = !TransactionScope.IsActive;

            using (var op = SnTrace.Database.StartOperation(msg))
            {
                if (isLocalTransaction)
                {
                    TransactionScope.Begin();
                }

                try
                {
                    // collect data for populator
                    var populatorData = populator.BeginPopulateNode(node, settings, originalPath, newPath);

                    data.CreateSnapshotData();

                    participant = new NodeDataParticipant {
                        Data = data, Settings = settings, IsNewNode = isNewNode
                    };

                    TransactionScope.Participate(participant);

                    if (settings.NodeHead != null)
                    {
                        settings.LastMajorVersionIdBefore = settings.NodeHead.LastMajorVersionId;
                        settings.LastMinorVersionIdBefore = settings.NodeHead.LastMinorVersionId;
                    }

                    int lastMajorVersionId, lastMinorVersionId;
                    DataProvider.Current.SaveNodeData(data, settings, out lastMajorVersionId, out lastMinorVersionId);

                    settings.LastMajorVersionIdAfter = lastMajorVersionId;
                    settings.LastMinorVersionIdAfter = lastMinorVersionId;

                    // here we re-create the node head to insert it into the cache and refresh the version info);
                    if (lastMajorVersionId > 0 || lastMinorVersionId > 0)
                    {
                        var head = NodeHead.CreateFromNode(node, lastMinorVersionId, lastMajorVersionId);
                        if (MustCache(node.NodeType))
                        {
                            // participate cache items
                            var idKey        = CreateNodeHeadIdCacheKey(head.Id);
                            var participant2 = new InsertCacheParticipant {
                                CacheKey = idKey
                            };
                            TransactionScope.Participate(participant2);
                            var pathKey      = CreateNodeHeadPathCacheKey(head.Path);
                            var participant3 = new InsertCacheParticipant {
                                CacheKey = pathKey
                            };
                            TransactionScope.Participate(participant3);

                            CacheNodeHead(head, idKey, pathKey);
                        }

                        node.RefreshVersionInfo(head);

                        if (!settings.DeletableVersionIds.Contains(node.VersionId))
                        {
                            // Elevation: we need to create the index document with full
                            // control to avoid field access errors (indexing must be independent
                            // from the current users permissions).
                            using (new SystemAccount())
                            {
                                indexDocument = SaveIndexDocument(node, true, isNewNode, out hasBinary);
                            }
                        }
                    }

                    if (isLocalTransaction)
                    {
                        TransactionScope.Commit();
                    }

                    // populate index only if it is enabled on this content (e.g. preview images will be skipped)
                    using (var op2 = SnTrace.Index.StartOperation("Indexing node"))
                    {
                        if (node.IsIndexingEnabled)
                        {
                            using (new SystemAccount())
                                populator.CommitPopulateNode(populatorData, indexDocument);
                        }

                        if (indexDocument != null && hasBinary)
                        {
                            using (new SystemAccount())
                            {
                                indexDocument = SaveIndexDocument(node, indexDocument);
                                populator.FinalizeTextExtracting(populatorData, indexDocument);
                            }
                        }
                        op2.Successful = true;
                    }
                }
                catch (NodeIsOutOfDateException)
                {
                    RemoveFromCache(participant);
                    throw;
                }
                catch (System.Data.Common.DbException dbe)
                {
                    if (isLocalTransaction && IsDeadlockException(dbe))
                    {
                        return(dbe);
                    }
                    throw SavingExceptionHelper(data, dbe);
                }
                catch (Exception e)
                {
                    var ee = SavingExceptionHelper(data, e);
                    if (ee == e)
                    {
                        throw;
                    }
                    else
                    {
                        throw ee;
                    }
                }
                finally
                {
                    if (isLocalTransaction && TransactionScope.IsActive)
                    {
                        TransactionScope.Rollback();
                    }
                }
                op.Successful = true;
            }
            return(null);
        }
Exemplo n.º 19
0
 public override void Save(NodeSaveSettings settings)
 {
     Security.Assert(PermissionType.ManageListsAndWorkspaces);
     base.Save(settings);
 }
Exemplo n.º 20
0
        //====================================================================== Helper methods

        private static void SavingAssert(NodeSaveSettings action, string currentversion, int currentVersionId,
            string expectedVersion, int expectedVersionId, int? lockerId,
            ICollection<int> deletableVersionIds)
        {
            Assert.IsTrue(action.CurrentVersion != null, String.Concat("action.CurrentVersion is null"));
            Assert.IsTrue(action.CurrentVersion.ToString() == currentversion, String.Concat("action.CurrentVersion is ", action.CurrentVersion, ". Expected: ", currentversion));
            Assert.IsTrue(action.CurrentVersionId == currentVersionId, String.Concat("action.CurrentVersion is ", action.CurrentVersionId, ". Expected: ", currentVersionId));
            Assert.IsTrue(action.ExpectedVersion != null, String.Concat("action.ExpectedVersion is null"));
            Assert.IsTrue(action.ExpectedVersion.ToString() == expectedVersion, String.Concat("action.CurrentVersion is ", action.ExpectedVersion, ". Expected: ", expectedVersion));
            Assert.IsTrue(action.ExpectedVersionId == expectedVersionId, String.Concat("action.ExpectedVersionId is ", action.ExpectedVersionId, ". Expected: ", expectedVersionId));
            Assert.IsTrue(action.LockerUserId == lockerId, String.Concat("action.LockerUserId is '", action.LockerUserId, "', Expected: ", lockerId));
            Assert.IsTrue(action.DeletableVersionIds.Count == deletableVersionIds.Count, String.Concat("action..DeletableVersions.Count is ", action.DeletableVersionIds.Count, ". Expected: ", deletableVersionIds.Count));

            foreach (var versionId in deletableVersionIds)
            {
                Assert.IsTrue(action.DeletableVersionIds.Contains(versionId), String.Concat("DeletableVersionIds does not contain ", versionId));
            }
        }