Source code

001/*
002 * (C) Copyright 2006-2016 Nuxeo SA (http://nuxeo.com/) and others.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 *     http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 *
016 * Contributors:
017 *     Thomas Roger
018 *     Florent Guillaume
019 */
020package org.nuxeo.ecm.quota.count;
021
022import static org.nuxeo.ecm.core.schema.FacetNames.FOLDERISH;
023import static org.nuxeo.ecm.quota.count.Constants.DOCUMENTS_COUNT_STATISTICS_CHILDREN_COUNT_PROPERTY;
024import static org.nuxeo.ecm.quota.count.Constants.DOCUMENTS_COUNT_STATISTICS_DESCENDANTS_COUNT_PROPERTY;
025import static org.nuxeo.ecm.quota.count.Constants.DOCUMENTS_COUNT_STATISTICS_FACET;
026
027import java.io.Serializable;
028import java.util.HashMap;
029import java.util.List;
030import java.util.Map;
031
032import org.apache.commons.logging.Log;
033import org.apache.commons.logging.LogFactory;
034import org.nuxeo.ecm.core.api.CoreSession;
035import org.nuxeo.ecm.core.api.DocumentModel;
036import org.nuxeo.ecm.core.api.DocumentNotFoundException;
037import org.nuxeo.ecm.core.api.IdRef;
038import org.nuxeo.ecm.core.api.IterableQueryResult;
039import org.nuxeo.ecm.core.api.model.DeltaLong;
040import org.nuxeo.ecm.core.event.Event;
041import org.nuxeo.ecm.quota.AbstractQuotaStatsUpdater;
042import org.nuxeo.ecm.quota.QuotaStatsInitialWork;
043import org.nuxeo.ecm.quota.QuotaUtils;
044import org.nuxeo.ecm.quota.size.QuotaExceededException;
045import org.nuxeo.runtime.transaction.TransactionHelper;
046
047/**
048 * {@link org.nuxeo.ecm.quota.QuotaStatsUpdater} counting the non folderish documents.
049 * <p>
050 * Store the descendant and children count on {@code Folderish} documents.
051 *
052 * @since 5.5
053 */
054public class DocumentsCountUpdater extends AbstractQuotaStatsUpdater {
055
056    private static final Log log = LogFactory.getLog(DocumentsCountUpdater.class);
057
058    public static final int BATCH_SIZE = 50;
059
060    @Override
061    protected void processDocumentCreated(CoreSession session, DocumentModel doc) {
062        if (doc.isVersion()) {
063            return;
064        }
065        List<DocumentModel> ancestors = getAncestors(session, doc);
066        long docCount = getCount(doc);
067        updateCountStatistics(session, doc, ancestors, docCount);
068    }
069
070    @Override
071    protected void processDocumentCopied(CoreSession session, DocumentModel doc) {
072        List<DocumentModel> ancestors = getAncestors(session, doc);
073        long docCount = getCount(doc);
074        updateCountStatistics(session, doc, ancestors, docCount);
075    }
076
077    @Override
078    protected void processDocumentCheckedIn(CoreSession session, DocumentModel doc) {
079        // NOP
080    }
081
082    @Override
083    protected void processDocumentCheckedOut(CoreSession session, DocumentModel doc) {
084        // NOP
085    }
086
087    @Override
088    protected void processDocumentUpdated(CoreSession session, DocumentModel doc) {
089    }
090
091    @Override
092    protected void processDocumentMoved(CoreSession session, DocumentModel doc, DocumentModel sourceParent) {
093        List<DocumentModel> ancestors = getAncestors(session, doc);
094        List<DocumentModel> sourceAncestors = getAncestors(session, sourceParent);
095        sourceAncestors.add(0, sourceParent);
096        long docCount = getCount(doc);
097        updateCountStatistics(session, doc, ancestors, docCount);
098        updateCountStatistics(session, doc, sourceAncestors, -docCount);
099    }
100
101    @Override
102    protected void processDocumentAboutToBeRemoved(CoreSession session, DocumentModel doc) {
103        List<DocumentModel> ancestors = getAncestors(session, doc);
104        long docCount = getCount(doc);
105        updateCountStatistics(session, doc, ancestors, -docCount);
106    }
107
108    @Override
109    protected void handleQuotaExceeded(QuotaExceededException e, Event event) {
110        // never rollback on Exceptions
111    }
112
113    @Override
114    protected boolean needToProcessEventOnDocument(Event event, DocumentModel doc) {
115        return true;
116    }
117
118    @Override
119    protected void processDocumentBeforeUpdate(CoreSession session, DocumentModel doc) {
120        // NOP
121    }
122
123    protected void updateCountStatistics(CoreSession session, DocumentModel doc, List<DocumentModel> ancestors,
124            long count) {
125        if (ancestors == null || ancestors.isEmpty()) {
126            return;
127        }
128        if (count == 0) {
129            return;
130        }
131
132        if (!doc.hasFacet(FOLDERISH)) {
133            DocumentModel parent = ancestors.get(0);
134            updateParentChildrenCount(session, parent, count);
135        }
136
137        for (DocumentModel ancestor : ancestors) {
138            Number previous;
139            if (ancestor.hasFacet(DOCUMENTS_COUNT_STATISTICS_FACET)) {
140                previous = (Number) ancestor.getPropertyValue(DOCUMENTS_COUNT_STATISTICS_DESCENDANTS_COUNT_PROPERTY);
141            } else {
142                ancestor.addFacet(DOCUMENTS_COUNT_STATISTICS_FACET);
143                previous = null;
144            }
145            DeltaLong descendantsCount = DeltaLong.valueOf(previous, count);
146            ancestor.setPropertyValue(DOCUMENTS_COUNT_STATISTICS_DESCENDANTS_COUNT_PROPERTY, descendantsCount);
147            // do not send notifications
148            QuotaUtils.disableListeners(ancestor);
149            DocumentModel origAncestor = ancestor;
150            session.saveDocument(ancestor);
151            QuotaUtils.clearContextData(origAncestor);
152        }
153
154        session.save();
155    }
156
157    protected void updateParentChildrenCount(CoreSession session, DocumentModel parent, long count) {
158        Number previous;
159        if (parent.hasFacet(DOCUMENTS_COUNT_STATISTICS_FACET)) {
160            previous = (Number) parent.getPropertyValue(DOCUMENTS_COUNT_STATISTICS_CHILDREN_COUNT_PROPERTY);
161        } else {
162            parent.addFacet(DOCUMENTS_COUNT_STATISTICS_FACET);
163            previous = null;
164        }
165        DeltaLong childrenCount = DeltaLong.valueOf(previous, count);
166        parent.setPropertyValue(DOCUMENTS_COUNT_STATISTICS_CHILDREN_COUNT_PROPERTY, childrenCount);
167        // do not send notifications
168        QuotaUtils.disableListeners(parent);
169        DocumentModel origParent = parent;
170        session.saveDocument(parent);
171        QuotaUtils.clearContextData(origParent);
172    }
173
174    protected long getCount(DocumentModel doc) {
175        if (doc.hasFacet(FOLDERISH)) {
176            if (doc.hasFacet(DOCUMENTS_COUNT_STATISTICS_FACET)) {
177                Number count = (Number) doc.getPropertyValue(DOCUMENTS_COUNT_STATISTICS_DESCENDANTS_COUNT_PROPERTY);
178                return count == null ? 0 : count.longValue();
179            } else {
180                return 0;
181            }
182        } else {
183            return 1;
184        }
185    }
186
187    @Override
188    public void computeInitialStatistics(CoreSession session, QuotaStatsInitialWork currentWorker) {
189        Map<String, String> folders = getFolders(session);
190        Map<String, Count> documentsCountByFolder = computeDocumentsCountByFolder(session, folders);
191        saveDocumentsCount(session, documentsCountByFolder);
192    }
193
194    protected Map<String, String> getFolders(CoreSession session) {
195        IterableQueryResult res = session.queryAndFetch(
196                "SELECT ecm:uuid, ecm:parentId FROM Document WHERE ecm:mixinType = 'Folderish'", "NXQL");
197        try {
198            Map<String, String> folders = new HashMap<String, String>();
199
200            for (Map<String, Serializable> r : res) {
201                folders.put((String) r.get("ecm:uuid"), (String) r.get("ecm:parentId"));
202            }
203            return folders;
204        } finally {
205            if (res != null) {
206                res.close();
207            }
208        }
209    }
210
211    protected Map<String, Count> computeDocumentsCountByFolder(CoreSession session, Map<String, String> folders) {
212        IterableQueryResult res = session.queryAndFetch("SELECT ecm:uuid, ecm:parentId FROM Document", "NXQL");
213        try {
214            Map<String, Count> foldersCount = new HashMap<String, Count>();
215            for (Map<String, Serializable> r : res) {
216                String uuid = (String) r.get("ecm:uuid");
217                if (folders.containsKey(uuid)) {
218                    // a folder
219                    continue;
220                }
221
222                String folderId = (String) r.get("ecm:parentId");
223                if (!foldersCount.containsKey(folderId)) {
224                    foldersCount.put(folderId, new Count());
225                }
226                Count count = foldersCount.get(folderId);
227                count.childrenCount++;
228                count.descendantsCount++;
229
230                updateParentsDocumentsCount(folders, foldersCount, folderId);
231            }
232            return foldersCount;
233        } finally {
234            if (res != null) {
235                res.close();
236            }
237        }
238    }
239
240    protected void updateParentsDocumentsCount(Map<String, String> folders, Map<String, Count> foldersCount,
241            String folderId) {
242        String parent = folders.get(folderId);
243        while (parent != null) {
244            if (!foldersCount.containsKey(parent)) {
245                foldersCount.put(parent, new Count());
246            }
247            Count c = foldersCount.get(parent);
248            c.descendantsCount++;
249            parent = folders.get(parent);
250        }
251    }
252
253    protected void saveDocumentsCount(CoreSession session, Map<String, Count> foldersCount) {
254        long docsCount = 0;
255        for (Map.Entry<String, Count> entry : foldersCount.entrySet()) {
256            String folderId = entry.getKey();
257            if (folderId == null) {
258                continue;
259            }
260            DocumentModel folder;
261            try {
262                folder = session.getDocument(new IdRef(folderId));
263            } catch (DocumentNotFoundException e) {
264                log.warn(e);
265                log.debug(e, e);
266                continue;
267            }
268            if (folder.getPath().isRoot()) {
269                // Root document
270                continue;
271            }
272            saveDocumentsCount(session, folder, entry.getValue());
273            docsCount++;
274            if (docsCount % BATCH_SIZE == 0) {
275                session.save();
276                if (TransactionHelper.isTransactionActive()) {
277                    TransactionHelper.commitOrRollbackTransaction();
278                    TransactionHelper.startTransaction();
279                }
280            }
281        }
282        session.save();
283    }
284
285    protected void saveDocumentsCount(CoreSession session, DocumentModel folder, Count count) {
286        if (!folder.hasFacet(DOCUMENTS_COUNT_STATISTICS_FACET)) {
287            folder.addFacet(DOCUMENTS_COUNT_STATISTICS_FACET);
288        }
289        folder.setPropertyValue(DOCUMENTS_COUNT_STATISTICS_CHILDREN_COUNT_PROPERTY, Long.valueOf(count.childrenCount));
290        folder.setPropertyValue(DOCUMENTS_COUNT_STATISTICS_DESCENDANTS_COUNT_PROPERTY,
291                Long.valueOf(count.descendantsCount));
292        // do not send notifications
293        QuotaUtils.disableListeners(folder);
294        DocumentModel origFolder = folder;
295        session.saveDocument(folder);
296        QuotaUtils.clearContextData(origFolder);
297    }
298
299    /**
300     * Object to store documents count for a folder
301     */
302    private static class Count {
303
304        public long childrenCount = 0;
305
306        public long descendantsCount = 0;
307    }
308
309    @Override
310    protected void processDocumentTrashOp(CoreSession session, DocumentModel doc, String transition) {
311        // do nothing for count
312    }
313
314    @Override
315    protected void processDocumentRestored(CoreSession session, DocumentModel doc) {
316        // do nothing
317    }
318
319    @Override
320    protected void processDocumentBeforeRestore(CoreSession session, DocumentModel doc) {
321        // do nothing
322    }
323}