Moving to root below branch label

git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@2005 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261

source/java/org/alfresco/repo/node/index/FtsIndexRecoveryComponent.java

@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2005 Alfresco, Inc.
+ *
+ * Licensed under the Mozilla Public License version 1.1 
+ * with a permitted attribution clause. You may obtain a
+ * copy of the License at
+ *
+ *   http://www.alfresco.org/legal/license.txt
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.
+ */
+package org.alfresco.repo.node.index;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.alfresco.repo.search.impl.lucene.fts.FullTextSearchIndexer;
+import org.alfresco.repo.transaction.TransactionUtil;
+import org.alfresco.repo.transaction.TransactionUtil.TransactionWork;
+import org.alfresco.service.cmr.repository.NodeService;
+import org.alfresco.service.cmr.repository.StoreRef;
+import org.alfresco.service.cmr.search.SearchService;
+import org.alfresco.service.transaction.TransactionService;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * Ensures that the FTS indexing picks up on any outstanding documents that
+ * require indexing.
+ * <p>
+ * FTS indexing is a background process.  It is therefore possible that
+ * certain documents don't get indexed when the server shuts down.
+ * 
+ * @author Derek Hulley
+ */
+public class FtsIndexRecoveryComponent implements IndexRecovery
+{
+    private static Log logger = LogFactory.getLog(FtsIndexRecoveryComponent.class);
+    
+    /** provides transactions to atomically index each missed transaction */
+    private TransactionService transactionService;
+    /** the FTS indexer that we will prompt to pick up on any un-indexed text */
+    private FullTextSearchIndexer ftsIndexer;
+    /** the component providing searches of the indexed nodes */
+    private SearchService searcher;
+    /** the component giving direct access to <b>node</b> instances */
+    private NodeService nodeService;
+    /** the workspaces to reindex */
+    private List<StoreRef> storeRefs;
+    
+    public FtsIndexRecoveryComponent()
+    {
+        this.storeRefs = new ArrayList<StoreRef>(2);
+    }
+    
+    /**
+     * @param transactionService provide transactions to index each missed transaction
+     */
+    public void setTransactionService(TransactionService transactionService)
+    {
+        this.transactionService = transactionService;
+    }
+
+    /**
+     * @param ftsIndexer the FTS background indexer
+     */
+    public void setFtsIndexer(FullTextSearchIndexer ftsIndexer)
+    {
+        this.ftsIndexer = ftsIndexer;
+    }
+
+    /**
+     * @param nodeService provides information about nodes for indexing
+     */
+    public void setNodeService(NodeService nodeService)
+    {
+        this.nodeService = nodeService;
+    }
+    
+    /**
+     * Set the workspaces that need reindexing
+     * 
+     * @param storeRefStrings a list of strings representing store references
+     */
+    public void setStores(List<String> storeRefStrings)
+    {
+        storeRefs.clear();
+        for (String storeRefStr : storeRefStrings)
+        {
+            StoreRef storeRef = new StoreRef(storeRefStr);
+            storeRefs.add(storeRef);
+        }
+    }
+    
+    /**
+     * Ensures that the FTS indexing is activated for any outstanding full text searches.
+     */
+    public void reindex()
+    {
+        TransactionWork<Object> reindexWork = new TransactionWork<Object>()
+        {
+            public Object doWork()
+            {
+                // reindex each store
+                for (StoreRef storeRef : storeRefs)
+                {
+                    // check if the store exists
+                    if (!nodeService.exists(storeRef))
+                    {
+                        // store does not exist
+                        if (logger.isDebugEnabled())
+                        {
+                            logger.debug("Skipping reindex of non-existent store: " + storeRef);
+                        }
+                        continue;
+                    }
+                    
+                    // prompt FTS to reindex the store
+                    ftsIndexer.requiresIndex(storeRef);
+                }
+                // done
+                return null;
+            }
+        };
+        TransactionUtil.executeInUserTransaction(transactionService, reindexWork);
+        // done
+        if (logger.isDebugEnabled())
+        {
+            logger.debug("Prompted FTS index on stores: " + storeRefs);
+        }
+    }
+}

source/java/org/alfresco/repo/node/index/FtsIndexRecoveryComponentTest.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2005 Alfresco, Inc.
+ *
+ * Licensed under the Mozilla Public License version 1.1 
+ * with a permitted attribution clause. You may obtain a
+ * copy of the License at
+ *
+ *   http://www.alfresco.org/legal/license.txt
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.
+ */
+package org.alfresco.repo.node.index;
+
+import junit.framework.TestCase;
+
+import org.alfresco.repo.search.Indexer;
+import org.alfresco.repo.transaction.TransactionUtil;
+import org.alfresco.repo.transaction.TransactionUtil.TransactionWork;
+import org.alfresco.service.cmr.repository.NodeService;
+import org.alfresco.service.transaction.TransactionService;
+import org.alfresco.util.ApplicationContextHelper;
+import org.springframework.context.ApplicationContext;
+
+/**
+ * Checks that the FTS index recovery component is working
+ * 
+ * @author Derek Hulley
+ */
+public class FtsIndexRecoveryComponentTest extends TestCase
+{
+    private static ApplicationContext ctx = ApplicationContextHelper.getApplicationContext();
+    
+    private IndexRecovery indexRecoverer;
+    private NodeService nodeService;
+    private TransactionService txnService;
+    private Indexer indexer;
+    
+    public void setUp() throws Exception
+    {
+        indexRecoverer = (IndexRecovery) ctx.getBean("indexRecoveryComponent");
+        txnService = (TransactionService) ctx.getBean("transactionComponent");
+        nodeService = (NodeService) ctx.getBean("nodeService");
+        indexer = (Indexer) ctx.getBean("indexerComponent");
+    }
+    
+    public void testReindexing() throws Exception
+    {
+        // performs a reindex
+        TransactionWork<Object> reindexWork = new TransactionWork<Object>()
+        {
+            public Object doWork()
+            {
+                indexRecoverer.reindex();
+                return null;
+            }
+        };
+        
+        // reindex
+        TransactionUtil.executeInNonPropagatingUserTransaction(txnService, reindexWork);
+    }
+}

source/java/org/alfresco/repo/node/index/IndexRecovery.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2005 Alfresco, Inc.
+ *
+ * Licensed under the Mozilla Public License version 1.1 
+ * with a permitted attribution clause. You may obtain a
+ * copy of the License at
+ *
+ *   http://www.alfresco.org/legal/license.txt
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.
+ */
+package org.alfresco.repo.node.index;
+
+/**
+ * Interface for components able to recover indexes.
+ * 
+ * @author Derek Hulley
+ */
+public interface IndexRecovery
+{
+    /**
+     * Forces a reindex
+     */
+    public void reindex();
+}

source/java/org/alfresco/repo/node/index/IndexRecoveryJob.java

@@ -0,0 +1,33 @@
+package org.alfresco.repo.node.index;
+
+import org.quartz.Job;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+
+/**
+ * Forces a index recovery using the {@link IndexRecovery recovery component} passed
+ * in via the job detail.
+ * 
+ * @author Derek Hulley
+ */
+public class IndexRecoveryJob implements Job
+{
+    /** KEY_INDEX_RECOVERY_COMPONENT = 'indexRecoveryComponent' */
+    public static final String KEY_INDEX_RECOVERY_COMPONENT = "indexRecoveryComponent";
+    
+    /**
+     * Forces a full index recovery using the {@link IndexRecovery recovery component} passed
+     * in via the job detail.
+     */
+    public void execute(JobExecutionContext context) throws JobExecutionException
+    {
+        IndexRecovery indexRecoveryComponent = (IndexRecovery) context.getJobDetail()
+                .getJobDataMap().get(KEY_INDEX_RECOVERY_COMPONENT);
+        if (indexRecoveryComponent == null)
+        {
+            throw new JobExecutionException("Missing job data: " + KEY_INDEX_RECOVERY_COMPONENT);
+        }
+        // reindex
+        indexRecoveryComponent.reindex();
+    }
+}

source/java/org/alfresco/repo/node/index/NodeIndexer.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2005 Alfresco, Inc.
+ *
+ * Licensed under the Mozilla Public License version 1.1 
+ * with a permitted attribution clause. You may obtain a
+ * copy of the License at
+ *
+ *   http://www.alfresco.org/legal/license.txt
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.
+ */
+package org.alfresco.repo.node.index;
+
+import org.alfresco.model.ContentModel;
+import org.alfresco.repo.node.NodeServicePolicies;
+import org.alfresco.repo.policy.JavaBehaviour;
+import org.alfresco.repo.policy.PolicyComponent;
+import org.alfresco.repo.search.Indexer;
+import org.alfresco.service.cmr.repository.ChildAssociationRef;
+import org.alfresco.service.cmr.repository.NodeRef;
+import org.alfresco.service.cmr.repository.StoreRef;
+import org.alfresco.service.namespace.NamespaceService;
+import org.alfresco.service.namespace.QName;
+
+/**
+ * Handles the node policy callbacks to ensure that the node hierarchy is properly
+ * indexed.
+ * 
+ * @author Derek Hulley
+ */
+public class NodeIndexer
+        implements NodeServicePolicies.BeforeCreateStorePolicy,
+                   NodeServicePolicies.OnCreateNodePolicy,
+                   NodeServicePolicies.OnUpdateNodePolicy,
+                   NodeServicePolicies.OnDeleteNodePolicy,
+                   NodeServicePolicies.OnCreateChildAssociationPolicy,
+                   NodeServicePolicies.OnDeleteChildAssociationPolicy
+{
+    /** the component to register the behaviour with */
+    private PolicyComponent policyComponent;
+    /** the component to index the node hierarchy */
+    private Indexer indexer;
+    
+    /**
+     * @param policyComponent used for registrations
+     */
+    public void setPolicyComponent(PolicyComponent policyComponent)
+    {
+        this.policyComponent = policyComponent;
+    }
+
+    /**
+     * @param indexer the indexer that will be index
+     */
+    public void setIndexer(Indexer indexer)
+    {
+        this.indexer = indexer;
+    }
+
+    /**
+     * Registers the policy behaviour methods
+     */
+    private void init()
+    {
+        policyComponent.bindClassBehaviour(
+                QName.createQName(NamespaceService.ALFRESCO_URI, "beforeCreateStore"),
+                ContentModel.TYPE_STOREROOT,
+                new JavaBehaviour(this, "beforeCreateStore"));   
+        policyComponent.bindClassBehaviour(
+                QName.createQName(NamespaceService.ALFRESCO_URI, "onCreateNode"),
+                this,
+                new JavaBehaviour(this, "onCreateNode"));   
+        policyComponent.bindClassBehaviour(
+                QName.createQName(NamespaceService.ALFRESCO_URI, "onUpdateNode"),
+                this,
+                new JavaBehaviour(this, "onUpdateNode"));   
+        policyComponent.bindClassBehaviour(
+                QName.createQName(NamespaceService.ALFRESCO_URI, "onDeleteNode"),
+                this,
+                new JavaBehaviour(this, "onDeleteNode"));   
+        policyComponent.bindAssociationBehaviour(
+                QName.createQName(NamespaceService.ALFRESCO_URI, "onCreateChildAssociation"),
+                this,
+                new JavaBehaviour(this, "onCreateChildAssociation"));   
+        policyComponent.bindAssociationBehaviour(
+                QName.createQName(NamespaceService.ALFRESCO_URI, "onDeleteChildAssociation"),
+                this,
+                new JavaBehaviour(this, "onDeleteChildAssociation"));   
+    }
+
+    public void beforeCreateStore(QName nodeTypeQName, StoreRef storeRef)
+    {
+        // indexer can perform some cleanup here, if required
+    }
+
+    public void onCreateNode(ChildAssociationRef childAssocRef)
+    {
+        indexer.createNode(childAssocRef);
+    }
+
+    public void onUpdateNode(NodeRef nodeRef)
+    {
+        indexer.updateNode(nodeRef);
+    }
+
+    public void onDeleteNode(ChildAssociationRef childAssocRef)
+    {
+        indexer.deleteNode(childAssocRef);
+    }
+
+    public void onCreateChildAssociation(ChildAssociationRef childAssocRef)
+    {
+        indexer.createChildRelationship(childAssocRef);
+    }
+
+    public void onDeleteChildAssociation(ChildAssociationRef childAssocRef)
+    {
+        indexer.deleteChildRelationship(childAssocRef);
+    }
+}

source/java/org/alfresco/repo/node/index/NodeIndexerTest.java

@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2005 Alfresco, Inc.
+ *
+ * Licensed under the Mozilla Public License version 1.1 
+ * with a permitted attribution clause. You may obtain a
+ * copy of the License at
+ *
+ *   http://www.alfresco.org/legal/license.txt
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.
+ */
+package org.alfresco.repo.node.index;
+
+import java.io.Serializable;
+import java.util.List;
+
+import org.alfresco.repo.node.BaseNodeServiceTest;
+import org.alfresco.service.cmr.repository.NodeRef;
+import org.alfresco.service.cmr.repository.NodeService;
+import org.alfresco.service.cmr.repository.StoreRef;
+import org.alfresco.service.cmr.search.ResultSet;
+import org.alfresco.service.cmr.search.SearchService;
+import org.alfresco.service.namespace.DynamicNamespacePrefixResolver;
+import org.alfresco.service.namespace.NamespaceService;
+import org.alfresco.util.perf.PerformanceMonitor;
+
+/**
+ * Checks that the indexing of the node hierarchy is working
+ * 
+ * @see org.alfresco.repo.node.index.NodeIndexer
+ * 
+ * @author Derek Hulley
+ */
+public class NodeIndexerTest extends BaseNodeServiceTest
+{
+    private SearchService searchService;
+    private static StoreRef localStoreRef;
+    private static NodeRef localRootNode;
+
+    @Override
+    protected NodeService getNodeService()
+    {
+        return (NodeService) applicationContext.getBean("nodeService");
+    }
+    
+    @Override
+    protected void onSetUpInTransaction() throws Exception
+    {
+        super.onSetUpInTransaction();
+        searchService = (SearchService) applicationContext.getBean("searchService");
+
+        if (localStoreRef == null)
+        {
+            localStoreRef = nodeService.createStore(StoreRef.PROTOCOL_WORKSPACE, "Test_Persisted" + System.currentTimeMillis());
+            localRootNode = nodeService.getRootNode(localStoreRef);
+        }
+    }
+
+    public void testCommitQueryData() throws Exception
+    {
+        rootNodeRef = localRootNode;
+        buildNodeGraph();
+        setComplete();
+    }
+
+    public void testQuery() throws Exception
+    {
+        rootNodeRef = localRootNode;
+        ResultSet results = searchService.query(rootNodeRef.getStoreRef(), "lucene", "PATH:\"" + BaseNodeServiceTest.TEST_PREFIX + ":root_p_n1\"", null, null);
+        assertEquals(1, results.length());
+        results.close();
+    }
+
+    public void testLikeAndContains() throws Exception
+    {
+        rootNodeRef = localRootNode;
+        
+        DynamicNamespacePrefixResolver namespacePrefixResolver = new DynamicNamespacePrefixResolver(null);
+        namespacePrefixResolver.registerNamespace(NamespaceService.SYSTEM_MODEL_PREFIX, NamespaceService.SYSTEM_MODEL_1_0_URI);
+        namespacePrefixResolver.registerNamespace(NamespaceService.CONTENT_MODEL_PREFIX, NamespaceService.CONTENT_MODEL_1_0_URI);
+        namespacePrefixResolver.registerNamespace(BaseNodeServiceTest.TEST_PREFIX, BaseNodeServiceTest.NAMESPACE);
+   
+        PerformanceMonitor selectNodesPerf = new PerformanceMonitor(getClass().getSimpleName(), "selectNodes");
+        PerformanceMonitor selectPropertiesPerf = new PerformanceMonitor(getClass().getSimpleName(), "selectProperties");
+        
+        List<NodeRef> answer;
+        
+        selectNodesPerf.start();
+        answer =  searchService.selectNodes(rootNodeRef, "//*[like(@test:animal, 'm_nkey')]", null, namespacePrefixResolver, false);
+        assertEquals(1, answer.size());
+        selectNodesPerf.stop();
+        
+        selectNodesPerf.start();
+        answer =  searchService.selectNodes(rootNodeRef, "//*[like(@test:animal, 'm%key')]", null, namespacePrefixResolver, false);
+        assertEquals(1, answer.size());
+        selectNodesPerf.stop();
+        
+        selectNodesPerf.start();
+        answer =  searchService.selectNodes(rootNodeRef, "//*[like(@test:animal, 'monk__')]", null, namespacePrefixResolver, false);
+        assertEquals(1, answer.size());
+        selectNodesPerf.stop();
+        
+        selectNodesPerf.start();
+        answer =  searchService.selectNodes(rootNodeRef, "//*[like(@test:animal, 'monk%')]", null, namespacePrefixResolver, false);
+        assertEquals(1, answer.size());
+        selectNodesPerf.stop();
+        
+        selectNodesPerf.start();
+        answer =  searchService.selectNodes(rootNodeRef, "//*[like(@test:animal, 'monk\\%')]", null, namespacePrefixResolver, false);
+        assertEquals(0, answer.size());
+        selectNodesPerf.stop();
+        
+        selectNodesPerf.start();
+        answer =  searchService.selectNodes(rootNodeRef, "//*[contains('monkey')]", null, namespacePrefixResolver, false);
+        assertEquals(1, answer.size());
+        selectNodesPerf.stop();
+        
+        selectPropertiesPerf.start();
+        List<Serializable> result =  searchService.selectProperties(rootNodeRef, "//@*[contains('monkey')]", null, namespacePrefixResolver, false);
+        assertEquals(2, result.size());
+        selectPropertiesPerf.stop();
+        
+        selectNodesPerf.start();
+        answer =  searchService.selectNodes(rootNodeRef, "//*[contains('mon?ey')]", null, namespacePrefixResolver, false);
+        assertEquals(1, answer.size());
+        selectNodesPerf.stop();
+        
+        selectPropertiesPerf.start();
+        result =  searchService.selectProperties(rootNodeRef, "//@*[contains('mon?ey')]", null, namespacePrefixResolver, false);
+        assertEquals(2, result.size());
+        selectPropertiesPerf.stop();
+        
+        selectNodesPerf.start();
+        answer =  searchService.selectNodes(rootNodeRef, "//*[contains('m*y')]", null, namespacePrefixResolver, false);
+        assertEquals(1, answer.size());
+        selectNodesPerf.stop();
+        
+        selectPropertiesPerf.start();
+        result =  searchService.selectProperties(rootNodeRef, "//@*[contains('mon*')]", null, namespacePrefixResolver, false);
+        assertEquals(2, result.size());
+        selectPropertiesPerf.stop();
+        
+        selectNodesPerf.start();
+        answer =  searchService.selectNodes(rootNodeRef, "//*[contains('*nkey')]", null, namespacePrefixResolver, false);
+        assertEquals(1, answer.size());
+        selectNodesPerf.stop();
+        
+        selectPropertiesPerf.start();
+        result =  searchService.selectProperties(rootNodeRef, "//@*[contains('?onkey')]", null, namespacePrefixResolver, false);
+        assertEquals(2, result.size());
+        selectPropertiesPerf.stop();
+    }
+}