chetanmeh/LuceneJcr.java

## LuceneJcr.java
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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.apache.jackrabbit.oak.jcr;

import java.io.File;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

import javax.jcr.Node;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.SimpleCredentials;
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;

import org.apache.jackrabbit.commons.JcrUtils;
import org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexEditorProvider;
import org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexProvider;
import org.apache.jackrabbit.oak.plugins.segment.SegmentNodeStore;
import org.apache.jackrabbit.oak.plugins.segment.file.FileStore;
import org.apache.jackrabbit.oak.spi.commit.Observer;
import org.apache.jackrabbit.oak.spi.query.QueryIndexProvider;
import org.apache.jackrabbit.oak.spi.state.NodeStore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import static org.junit.Assert.fail;

public class LuceneJcr {
    private final Logger log = LoggerFactory.getLogger(getClass());
    private NodeStore nodeStore;
    private Repository repository;

    public void initNodeStore() throws IOException {
        FileStore fileStore = FileStore.newFileStore(new File("target/"+System.currentTimeMillis())).create();
        nodeStore = new SegmentNodeStore(fileStore);
    }

    public void initRepository() {
        LuceneIndexProvider provider = new LuceneIndexProvider();
        Jcr jcr = new Jcr(nodeStore)
                .withAsyncIndexing()
                .with(new LuceneIndexEditorProvider())
                .with((QueryIndexProvider) provider)
                .with((Observer) provider)
                .withAsyncIndexing();
        repository = jcr.createRepository();
        log.info("Repository initialized");
    }

    public void createLuceneIndex() throws RepositoryException {
        Session session = createAdminSession();
        Node lucene = JcrUtils.getOrCreateByPath("/oak:index/lucene", "oak:Unstructured",
                "oak:QueryIndexDefinition", session, false);
        lucene.setProperty("compatVersion", 2);
        lucene.setProperty("type", "lucene");
        lucene.setProperty("async", "async");
        Node rules = lucene.addNode("indexRules", "nt:unstructured");
        Node allProps = rules.addNode("nt:base")
                .addNode("properties", "nt:unstructured")
                .addNode("allProps", "oak:Unstructured");
        allProps.setProperty("name", ".*");
        allProps.setProperty("isRegexp", true);
        allProps.setProperty("nodeScopeIndex", true);
        session.save();
        session.logout();
        log.info("Lucene index created");
    }

    private void createTestData() throws RepositoryException {
        Session session = createAdminSession();

        Node test = session.getRootNode().addNode("test");
        test.setProperty("name", "torgeir");

        session.save();
        session.logout();
        log.info("Testdata created");
    }

    private void performQuery() throws RepositoryException, InterruptedException {
        final Session session = createAdminSession();

        TimeUnit.SECONDS.sleep(5);
        log.info("Going to perform query");

        QueryManager qm  =session.getWorkspace().getQueryManager();
        final Query q = qm.createQuery("select * from [nt:base] where " +
                "contains(*,'torgeir')", Query.JCR_SQL2);

        new RetryLoop(new RetryLoop.Condition() {
            @Override
            public String getDescription() {
                return "Full text query";
            }

            @Override
            public boolean isTrue() throws Exception {
                QueryResult r = q.execute();
                return r.getNodes().hasNext();
            }
        }, 105, 200);

        System.out.println(q.execute().getNodes().next());
    }

    private Session createAdminSession() throws RepositoryException {
        return repository.login(getAdminCredentials());
    }

    private SimpleCredentials getAdminCredentials() {
        return new SimpleCredentials("admin", "admin".toCharArray());
    }

    public static void main(String[] args) throws Exception {
        LuceneJcr test = new LuceneJcr();
        test.setUp();
    }

    private void setUp() throws Exception {
        initNodeStore();
        initRepository();
        createLuceneIndex();
        createTestData();
        performQuery();
    }


    private static class RetryLoop {
        private final long timeout;

        static public interface Condition {
            /**
             * Used in failure messages to describe what was expected
             */
            String getDescription();

            /**
             * If true we stop retrying. The RetryLoop retries on AssertionError,
             * so if tests fail in this method they are not reported as
             * failures but retried.
             */
            boolean isTrue() throws Exception;
        }

        public RetryLoop(Condition c, int timeoutSeconds, int intervalBetweenTriesMsec) {
            timeout = System.currentTimeMillis() + timeoutSeconds * 1000L;
            while (System.currentTimeMillis() < timeout) {
                try {
                    if (c.isTrue()) {
                        return;
                    }
                } catch (AssertionError ae) {
                    // Retry JUnit tests failing in the condition as well
                    reportException(ae);
                } catch (Exception e) {
                    reportException(e);
                }

                try {
                    Thread.sleep(intervalBetweenTriesMsec);
                } catch (InterruptedException ignore) {
                }
            }

            onTimeout();
            fail("RetryLoop failed, condition is false after " + timeoutSeconds + " seconds: "
                    + c.getDescription());
        }

        /**
         * Can be overridden to report Exceptions that happen in the retry loop
         */
        protected void reportException(Throwable t) {
        }

        /**
         * Called if the loop times out without success, just before failing
         */
        protected void onTimeout() {
        }
    }


}
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* 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.apache.jackrabbit.oak.jcr;

	import java.io.File;
	import java.io.IOException;
	import java.util.concurrent.TimeUnit;

	import javax.jcr.Node;
	import javax.jcr.Repository;
	import javax.jcr.RepositoryException;
	import javax.jcr.Session;
	import javax.jcr.SimpleCredentials;
	import javax.jcr.query.Query;
	import javax.jcr.query.QueryManager;
	import javax.jcr.query.QueryResult;

	import org.apache.jackrabbit.commons.JcrUtils;
	import org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexEditorProvider;
	import org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexProvider;
	import org.apache.jackrabbit.oak.plugins.segment.SegmentNodeStore;
	import org.apache.jackrabbit.oak.plugins.segment.file.FileStore;
	import org.apache.jackrabbit.oak.spi.commit.Observer;
	import org.apache.jackrabbit.oak.spi.query.QueryIndexProvider;
	import org.apache.jackrabbit.oak.spi.state.NodeStore;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import static org.junit.Assert.fail;

	public class LuceneJcr {
	private final Logger log = LoggerFactory.getLogger(getClass());
	private NodeStore nodeStore;
	private Repository repository;

	public void initNodeStore() throws IOException {
	FileStore fileStore = FileStore.newFileStore(new File("target/"+System.currentTimeMillis())).create();
	nodeStore = new SegmentNodeStore(fileStore);
	}

	public void initRepository() {
	LuceneIndexProvider provider = new LuceneIndexProvider();
	Jcr jcr = new Jcr(nodeStore)
	.withAsyncIndexing()
	.with(new LuceneIndexEditorProvider())
	.with((QueryIndexProvider) provider)
	.with((Observer) provider)
	.withAsyncIndexing();
	repository = jcr.createRepository();
	log.info("Repository initialized");
	}

	public void createLuceneIndex() throws RepositoryException {
	Session session = createAdminSession();
	Node lucene = JcrUtils.getOrCreateByPath("/oak:index/lucene", "oak:Unstructured",
	"oak:QueryIndexDefinition", session, false);
	lucene.setProperty("compatVersion", 2);
	lucene.setProperty("type", "lucene");
	lucene.setProperty("async", "async");
	Node rules = lucene.addNode("indexRules", "nt:unstructured");
	Node allProps = rules.addNode("nt:base")
	.addNode("properties", "nt:unstructured")
	.addNode("allProps", "oak:Unstructured");
	allProps.setProperty("name", ".*");
	allProps.setProperty("isRegexp", true);
	allProps.setProperty("nodeScopeIndex", true);
	session.save();
	session.logout();
	log.info("Lucene index created");
	}

	private void createTestData() throws RepositoryException {
	Session session = createAdminSession();

	Node test = session.getRootNode().addNode("test");
	test.setProperty("name", "torgeir");

	session.save();
	session.logout();
	log.info("Testdata created");
	}

	private void performQuery() throws RepositoryException, InterruptedException {
	final Session session = createAdminSession();

	TimeUnit.SECONDS.sleep(5);
	log.info("Going to perform query");

	QueryManager qm =session.getWorkspace().getQueryManager();
	final Query q = qm.createQuery("select * from [nt:base] where " +
	"contains(*,'torgeir')", Query.JCR_SQL2);

	new RetryLoop(new RetryLoop.Condition() {
	@Override
	public String getDescription() {
	return "Full text query";
	}

	@Override
	public boolean isTrue() throws Exception {
	QueryResult r = q.execute();
	return r.getNodes().hasNext();
	}
	}, 105, 200);

	System.out.println(q.execute().getNodes().next());
	}

	private Session createAdminSession() throws RepositoryException {
	return repository.login(getAdminCredentials());
	}

	private SimpleCredentials getAdminCredentials() {
	return new SimpleCredentials("admin", "admin".toCharArray());
	}

	public static void main(String[] args) throws Exception {
	LuceneJcr test = new LuceneJcr();
	test.setUp();
	}

	private void setUp() throws Exception {
	initNodeStore();
	initRepository();
	createLuceneIndex();
	createTestData();
	performQuery();
	}


	private static class RetryLoop {
	private final long timeout;

	static public interface Condition {
	/**
	* Used in failure messages to describe what was expected
	*/
	String getDescription();

	/**
	* If true we stop retrying. The RetryLoop retries on AssertionError,
	* so if tests fail in this method they are not reported as
	* failures but retried.
	*/
	boolean isTrue() throws Exception;
	}

	public RetryLoop(Condition c, int timeoutSeconds, int intervalBetweenTriesMsec) {
	timeout = System.currentTimeMillis() + timeoutSeconds * 1000L;
	while (System.currentTimeMillis() < timeout) {
	try {
	if (c.isTrue()) {
	return;
	}
	} catch (AssertionError ae) {
	// Retry JUnit tests failing in the condition as well
	reportException(ae);
	} catch (Exception e) {
	reportException(e);
	}

	try {
	Thread.sleep(intervalBetweenTriesMsec);
	} catch (InterruptedException ignore) {
	}
	}

	onTimeout();
	fail("RetryLoop failed, condition is false after " + timeoutSeconds + " seconds: "
	+ c.getDescription());
	}

	/**
	* Can be overridden to report Exceptions that happen in the retry loop
	*/
	protected void reportException(Throwable t) {
	}

	/**
	* Called if the loop times out without success, just before failing
	*/
	protected void onTimeout() {
	}
	}


	}