Index: oak-run/pom.xml
===================================================================
--- oak-run/pom.xml	(revision 1595746)
+++ oak-run/pom.xml	(working copy)
@@ -224,7 +224,7 @@
   <profiles>
     <profile>
       <activation>
-        <activeByDefault>true</activeByDefault>
+        <activeByDefault>false</activeByDefault>
       </activation>
       <id>oak-run-jr2</id>
       <properties>
@@ -241,7 +241,7 @@
     <profile>
       <id>oak-run-oak</id>
       <activation>
-        <activeByDefault>false</activeByDefault>
+        <activeByDefault>true</activeByDefault>
       </activation>
       <properties>
         <!--
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/TestInputStream.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/TestInputStream.java	(revision 1595746)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/TestInputStream.java	(working copy)
@@ -24,7 +24,7 @@
  * data is designed to be non-compressible to prevent possible compression
  * mechanisms from affecting performance measurements.
  */
-class TestInputStream extends InputStream {
+public class TestInputStream extends InputStream {
 
     private final int n;
 
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/util/Date.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/util/Date.java	(revision 0)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/util/Date.java	(working copy)
@@ -0,0 +1,106 @@
+/*
+ * 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.benchmark.util;
+
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+/**
+ * Enumerates some Calendar with math applied for easying tests
+ */
+public enum Date {
+    /**
+     * what could be considered the current timestamp
+     */
+    NOW(Calendar.getInstance()),
+    
+    /**
+     * given {@code NOW} less 2 hours
+     */
+    LAST_2_HRS(add(NOW.getCalendar(), Calendar.HOUR_OF_DAY, -2)),
+    
+    /**
+     * given {@code NOW} less 24 hours
+     */
+    LAST_24_HRS(add(NOW.getCalendar(), Calendar.HOUR_OF_DAY, -24)),
+    
+    /**
+     * given {@code NOW} less 1 week
+     */
+    LAST_7_DAYS(add(NOW.getCalendar(), Calendar.HOUR_OF_DAY, -24*7)),
+    
+    /**
+     * given {@code NOW} less 1 month
+     */
+    LAST_MONTH(add(NOW.getCalendar(), Calendar.MONTH, -1)),
+    
+    /**
+     * given {@code NOW} less 1 year
+     */
+    LAST_YEAR(add(NOW.getCalendar(), Calendar.YEAR, -1));
+
+    /**
+     * perform math on the provided calendar and return it.
+     * 
+     * @param cal
+     * @param field
+     * @param amount
+     * @return
+     */
+    private static Calendar add(Calendar cal, int field, int amount) {
+        cal.add(field, amount);
+        return cal;
+    }
+
+    
+    private final Calendar cal;
+    
+    private Date(Calendar cal) {
+        this.cal = cal;
+    }
+    
+    public Calendar getCalendar() {
+        // duplicating the calendar for allowing safe operations from consumers
+        Calendar c = Calendar.getInstance();
+        c.setTime(cal.getTime());
+        return c;
+    }
+
+    private static final SimpleDateFormat ISO_8601_2000 = new SimpleDateFormat(
+        "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
+
+    private static final List<Date> VALUES = Collections.unmodifiableList(Arrays.asList(values()));
+    private static final int SIZE = VALUES.size();
+    private static final Random RND = new Random();
+    
+    /**
+     * return a random Date
+     * 
+     * @return
+     */
+    public static Date randomDate() {
+        return VALUES.get(RND.nextInt(SIZE));
+    }
+    
+    public String toISO_8601_2000() {
+        return ISO_8601_2000.format(getCalendar().getTime());
+    }
+}

Property changes on: oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/util/Date.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/util/MimeType.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/util/MimeType.java	(revision 0)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/util/MimeType.java	(working copy)
@@ -0,0 +1,112 @@
+/*
+ * 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.benchmark.util;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+import javax.annotation.Nonnull;
+
+public enum MimeType {
+    APPLICATION_DVI("application/x-dvi"),
+    APPLICATION_FLASH("application/x-shockwave-flash"),
+    APPLICATION_INDESIGN("application/x-indesign"),
+    APPLICATION_JAVAARCHIVE("application/java-archive"),
+    APPLICATION_MSEXCEL("application/vnd.ms-excel"),
+    APPLICATION_MSPOWERPOINT("application/vnd.ms-powerpoint"),
+    APPLICATION_MSWORD("application/msword"),
+    APPLICATION_OD_GRAPHICS("application/vnd.oasis.opendocument.graphics"),
+    APPLICATION_OD_PRESENTATION("application/vnd.oasis.opendocument.presentation"),
+    APPLICATION_OD_SPREADSHEET("application/vnd.oasis.opendocument.spreadsheet"),
+    APPLICATION_OD_TEXT("application/vnd.oasis.opendocument.text"),
+    APPLICATION_OXML_DOCUMENT("application/vnd.openxmlformats-officedocument.wordprocessingml.document"),
+    APPLICATION_OXML_PRESENTATION("application/vnd.openxmlformats-officedocument.presentationml.presentation"),
+    APPLICATION_OX_SPREADSHEET("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"),
+    APPLICATION_PACKAGE("application/vnd.adobe.air-application-installer-package+zip"),
+    APPLICATION_PDF("application/pdf"),
+    APPLICATION_POSTSCRIPT("application/postscript"),
+    APPLICATION_QUARKXPRESS("application.vnd.quark.quarkxpress"),
+    APPLICATION_RAR("application/x-rar-compressed"),
+    APPLICATION_TAR("application/x-tar"),
+    APPLICATION_TARGZ("application/x-tar-gz"),
+    APPLICATION_ZIP("application/zip"),
+    AUDIO_3GPP("audio/3gpp"),
+    AUDIO_AAC("audio/x-aac"),
+    AUDIO_MIDI("audio/midi"),
+    AUDIO_MP3("audio/mp3"),
+    AUDIO_MP4("audio/mp4"),
+    AUDIO_MPEG("audio/mpeg"),
+    AUDIO_OGG("audio/ogg"),
+    AUDIO_REALAUDIO("audio/vnd.rn-realaudio"),
+    AUDIO_VORBIS("audio/vorbis"),
+    AUDIO_WAV("audio/x-wav"),
+    AUDIO_WMA("audio/x-ms-wma"),
+    IMAGE_BMP("image/x-bmp"),
+    IMAGE_BPM("image/pbm"),
+    IMAGE_DCRAW("image/x-dcraw"),
+    IMAGE_DNG("image/x-adobe-dng"),
+    IMAGE_GIF("image/gif"),
+    IMAGE_ICON("image/vnd.microsoft.icon"),
+    IMAGE_JPEG("image/jpeg"),
+    IMAGE_PHOTOSHOP("image/vnd.adobe.photoshop"),
+    IMAGE_PJPEG("image/pjpeg"),
+    IMAGE_PNG("image/png"),
+    IMAGE_PPM("image/x-ppm"),
+    IMAGE_RAW_NIKON("image/x-raw-nikon"),
+    IMAGE_SVG("image/svg+xml"),
+    IMAGE_TIFF("image/tiff"),
+    IMAGE_XCF("image/x-xcf"),
+    IMAGE_XPBM("image/x-pbm"),
+    TEXT_HTML("text/html"),
+    TEXT_PLAIN("text/plain"),
+    TEXT_RTF("text/rtf"),
+    VIDEO_MP4("video/mp4"),
+    VIDEO_MPEG("video/mpeg"),
+    VIDEO_OGG("video/ogg"),
+    VIDEO_QUICKTIME("video/quicktime"),
+    VIDEO_WMV("video/x-ms-wmv"),
+    VIDEO_XFLV("video/x-flv");
+    
+    private final String value;
+    
+    private MimeType(@Nonnull final String value) {
+        this.value = value;
+    }
+    
+    /**
+     * retrieve the string representation of the current Mime-Type
+     * @return
+     */
+    public String getValue() {
+        return value;
+    }
+    
+    private static final List<MimeType> VALUES = Collections.unmodifiableList(Arrays
+        .asList(values()));
+    private static final int SIZE = VALUES.size();
+    private static final Random RND = new Random();
+    
+    /**
+     * retrieve a random Mime-Type from the available collection
+     * @return
+     */
+    public static MimeType randomMimeType() {
+        return VALUES.get(RND.nextInt(SIZE));
+    }
+}

Property changes on: oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/util/MimeType.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/run/Main.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/run/Main.java	(revision 1595746)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/run/Main.java	(working copy)
@@ -60,6 +60,7 @@
 import org.apache.jackrabbit.oak.plugins.segment.SegmentNodeState;
 import org.apache.jackrabbit.oak.plugins.segment.SegmentNodeStore;
 import org.apache.jackrabbit.oak.plugins.segment.file.FileStore;
+import org.apache.jackrabbit.oak.scalability.ScalabilityRunner;
 import org.apache.jackrabbit.oak.spi.state.NodeState;
 import org.apache.jackrabbit.oak.spi.state.NodeStore;
 import org.apache.jackrabbit.oak.upgrade.RepositoryUpgrade;
@@ -109,6 +110,9 @@
             case UPGRADE:
                 upgrade(args);
                 break;
+            case SCALABILITY:
+                ScalabilityRunner.main(args);
+                break;                
             default:
                 System.err.println("Unknown command: " + mode);
                 System.exit(1);
@@ -487,8 +491,9 @@
         BENCHMARK("benchmark"),
         DEBUG("debug"),
         SERVER("server"),
-        UPGRADE("upgrade");
-
+        UPGRADE("upgrade"),
+        SCALABILITY("scalability");
+        
         private final String name;
 
         private Mode(String name) {
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/FormatSearcher.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/FormatSearcher.java	(revision 0)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/FormatSearcher.java	(working copy)
@@ -0,0 +1,57 @@
+/*
+ * 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.scalability;
+
+import javax.jcr.RepositoryException;
+import javax.jcr.query.Query;
+import javax.jcr.query.QueryManager;
+
+import org.apache.jackrabbit.oak.benchmark.util.MimeType;
+import org.apache.jackrabbit.oak.plugins.nodetype.NodeTypeConstants;
+import org.apache.jackrabbit.oak.scalability.ScalabilityAbstractSuite.ExecutionContext;
+
+/**
+ * Searches on the file format/Mime type 
+ *
+ */
+public class FormatSearcher extends SearchScalabilityBenchmark {
+    @SuppressWarnings("deprecation")
+    @Override
+    protected Query getQuery(QueryManager qm, ExecutionContext context) throws RepositoryException {
+        StringBuilder statement = new StringBuilder("/jcr:content/");
+        
+        statement.append(((String) context.getMap().get("ROOT_NODE_NAME"))).append("//element(*, ")
+            .append(context.getMap().get(ScalabilityBlobSearchSuite.CTX_FILE_NODE_TYPE_PROP)).append(")");
+        statement.append("[((");
+        
+        // adding all the possible mime-types in an OR fashion
+        for (MimeType mt : MimeType.values()) {
+            statement.append("@").append(ScalabilityBlobSearchSuite.FORMAT_PROP).append(" = '")
+                .append(mt.getValue()).append("' or ");
+        }
+
+        // removing latest ' or '
+        statement.delete(statement.lastIndexOf(" or "), statement.length());
+        
+        statement.append("))]");
+        
+        LOG.debug("{}", statement);
+        
+        return qm.createQuery(statement.toString(), Query.XPATH);
+    }
+    
+}
\ No newline at end of file

Property changes on: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/FormatSearcher.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/FullTextSearcher.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/FullTextSearcher.java	(revision 0)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/FullTextSearcher.java	(working copy)
@@ -0,0 +1,46 @@
+/*
+ * 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.scalability;
+
+import java.util.List;
+import java.util.Random;
+
+import javax.annotation.Nonnull;
+import javax.jcr.RepositoryException;
+import javax.jcr.query.Query;
+import javax.jcr.query.QueryManager;
+
+import org.apache.jackrabbit.oak.scalability.ScalabilityAbstractSuite.ExecutionContext;
+
+/**
+ * Full text query search
+ *
+ */
+public class FullTextSearcher extends SearchScalabilityBenchmark {
+    private final Random random = new Random(93);
+
+    @SuppressWarnings("deprecation")
+    @Override
+    protected Query getQuery(@Nonnull final QueryManager qm, ExecutionContext context) throws RepositoryException {
+        @SuppressWarnings("unchecked")
+        List<String> paths = (List<String>) context.getMap().get(ScalabilityBlobSearchSuite.CTX_SEARCH_PATHS_PROP);
+        
+        return qm.createQuery("//*[jcr:contains(., '" + paths.get(random.nextInt(paths.size()))  + "File"
+                + "*"
+                + "')] ", Query.XPATH);
+    }
+}
\ No newline at end of file

Property changes on: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/FullTextSearcher.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/LastModifiedSearcher.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/LastModifiedSearcher.java	(revision 0)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/LastModifiedSearcher.java	(working copy)
@@ -0,0 +1,78 @@
+/*
+ * 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.scalability;
+
+import javax.jcr.RepositoryException;
+import javax.jcr.query.Query;
+import javax.jcr.query.QueryManager;
+
+import org.apache.jackrabbit.oak.benchmark.util.Date;
+import org.apache.jackrabbit.oak.plugins.nodetype.NodeTypeConstants;
+import org.apache.jackrabbit.oak.scalability.ScalabilityAbstractSuite.ExecutionContext;
+
+/**
+ * perform searches using the {@code jcr:lastModified} and the provided timeframe
+ */
+public class LastModifiedSearcher extends SearchScalabilityBenchmark {
+    private final Date timeframe;
+    
+    public LastModifiedSearcher(Date timeframe) {
+        this.timeframe = timeframe;
+    }
+    
+    @SuppressWarnings("deprecation")
+    @Override
+    protected Query getQuery(QueryManager qm, ExecutionContext context) throws RepositoryException {
+        // TODO Auto-generated method stub
+        //  /jcr:root/content/dam//element(*, dam:Asset)[(jcr:content/@jcr:lastModified >= xs:dateTime('2013-05-09T09:44:01.403Z'))
+        final String path = (String) context.getMap().get(ScalabilityBlobSearchSuite.CTX_ROOT_NODE_NAME_PROP);
+        final String statement = "/jcr:root/" + path + "//element(*, "
+                                 + context.getMap().get(ScalabilityBlobSearchSuite.CTX_FILE_NODE_TYPE_PROP)
+                                 + ")[(@jcr:lastModified >= xs:dateTime('"
+                                 + timeframe.toISO_8601_2000() + "'))]";
+        
+        LOG.debug("LastModifiedSearcher: {}", statement);
+        
+        return qm.createQuery(statement, Query.XPATH);
+    }
+
+    @Override
+    public String toString() {
+        String s = "::";
+        
+        switch(timeframe) {
+        case LAST_2_HRS:
+            s += "Hour";
+            break;
+        case LAST_24_HRS:
+            s += "Day";
+            break;
+        case LAST_7_DAYS:
+            s += "Week";
+            break;
+        case LAST_MONTH:
+            s += "Month";
+            break;
+        case LAST_YEAR:
+            s += "Year";
+            break;
+        default:
+        }
+        
+        return super.toString() + s;
+    }
+}

Property changes on: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/LastModifiedSearcher.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/NodeTypeSearcher.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/NodeTypeSearcher.java	(revision 0)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/NodeTypeSearcher.java	(working copy)
@@ -0,0 +1,41 @@
+/*
+ * 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.scalability;
+
+import javax.annotation.Nonnull;
+import javax.jcr.RepositoryException;
+import javax.jcr.query.Query;
+import javax.jcr.query.QueryManager;
+
+import org.apache.jackrabbit.oak.plugins.nodetype.NodeTypeConstants;
+import org.apache.jackrabbit.oak.scalability.ScalabilityAbstractSuite.ExecutionContext;
+
+/**
+ * Searches on the NodeType 
+ *
+ */
+public class NodeTypeSearcher extends SearchScalabilityBenchmark {
+    
+    @SuppressWarnings("deprecation")
+    @Override
+    protected Query getQuery(@Nonnull final QueryManager qm, ExecutionContext context) throws RepositoryException {
+        return qm.createQuery(
+                "/jcr:root/" + ((String) context.getMap().get(ScalabilityBlobSearchSuite.CTX_ROOT_NODE_NAME_PROP)) + "//element(*, "
+                        + context.getMap().get(ScalabilityBlobSearchSuite.CTX_FILE_NODE_TYPE_PROP) + ")",
+                Query.XPATH);
+    }
+}
\ No newline at end of file

Property changes on: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/NodeTypeSearcher.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityAbstractSuite.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityAbstractSuite.java	(revision 0)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityAbstractSuite.java	(working copy)
@@ -0,0 +1,529 @@
+/*
+ * 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.scalability;
+
+import static com.google.common.collect.Lists.newArrayList;
+import static com.google.common.collect.Maps.newConcurrentMap;
+import static com.google.common.collect.Maps.newHashMap;
+
+import java.io.PrintStream;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+
+import javax.jcr.Credentials;
+import javax.jcr.Repository;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import javax.jcr.SimpleCredentials;
+
+import com.google.common.base.Preconditions;
+import com.google.common.base.Splitter;
+import com.google.common.base.Stopwatch;
+
+import org.apache.commons.math.stat.descriptive.DescriptiveStatistics;
+import org.apache.commons.math.stat.descriptive.SynchronizedDescriptiveStatistics;
+import org.apache.jackrabbit.oak.benchmark.CSVResultGenerator;
+import org.apache.jackrabbit.oak.benchmark.util.Profiler;
+import org.apache.jackrabbit.oak.fixture.RepositoryFixture;
+
+/**
+ * Longevity suite to load test.
+ * 
+ */
+public abstract class ScalabilityAbstractSuite implements ScalabilitySuite, CSVResultGenerator {
+    /**
+     * A random string to guarantee concurrently running tests don't overwrite
+     * each others changes (for example in a cluster).
+     * <p>
+     * The probability of duplicates, for 50 concurrent processes, is less than 1 in 1 million.
+     */
+    protected static final String TEST_ID = Integer.toHexString(new Random().nextInt());
+
+    protected static final boolean PROFILE = Boolean.getBoolean("profile");
+
+    protected static final boolean DEBUG = Boolean.getBoolean("debug");
+
+    /**
+     * Controls the incremental load for each iteration
+     */
+    protected static final List<String> INCREMENTS = Splitter.on(",").trimResults()
+                    .omitEmptyStrings().splitToList(System.getProperty("increments", "1,5,7,10"));
+
+    protected static final Credentials CREDENTIALS = new SimpleCredentials("admin", "admin"
+            .toCharArray());
+
+    private PrintStream out;
+
+    protected Map<String, ScalabilityBenchmark> benchmarks;
+
+    /**
+     * Variables per suite run
+     */
+    private Repository repository;
+
+    private Credentials credentials;
+
+    private LinkedList<Session> sessions;
+
+    ExecutionContext context;
+
+    private Result result;
+
+    private volatile boolean running;
+
+    private List<Thread> threads;
+
+    private RepositoryFixture fixture;
+
+    public ScalabilityAbstractSuite() {
+        this.benchmarks = newHashMap();
+    }
+
+    @Override
+    public void run(Iterable<RepositoryFixture> fixtures) {
+        for (RepositoryFixture fixture : fixtures) {
+            try {
+                Repository[] cluster = createRepository(fixture);
+                try {
+                    runSuite(fixture, cluster[0]);
+                } finally {
+                    fixture.tearDownCluster();
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Run the full suite on the given fixture.
+     *
+     * @param fixture the fixture
+     * @param repository the repository
+     * @throws Exception the exception
+     */
+    private void runSuite(RepositoryFixture fixture, Repository repository) throws Exception {
+
+        setUp(repository, fixture, CREDENTIALS);
+
+        try {
+            for (String increment : INCREMENTS) {
+                context.setIncrement(Integer.parseInt(increment.trim()));
+
+                setupIteration(increment);
+
+                if (DEBUG) {
+                    System.out.println("Started test");
+                }
+
+                // Run one iteration
+                runIteration(context);
+
+                if (DEBUG) {
+                    System.out.println("Finished test");
+                }
+
+                tearDownIteration();
+            }
+        } catch(Exception e) {
+           e.printStackTrace(); 
+        } finally {
+            tearDown();
+        }
+    }
+    
+    /**
+     * Setup the iteration. Calls {@link this#beforeIteration()} which can 
+     * be overridden by subclasses.
+     * 
+     * @param increment
+     * @throws Exception
+     */
+    private void setupIteration(String increment) throws Exception {
+        if (DEBUG) {
+            System.out.println("Start load : " + increment);
+        }
+        
+        initBackgroundJobs();
+        
+        // create the load for this iteration
+        beforeIteration(context);
+
+        for (ScalabilityBenchmark benchmark : benchmarks.values()) {
+            executeBenchmark(benchmark, context);
+        }
+    }
+    
+    /**
+     * Post processing for the iteration.
+     * 
+     * @throws InterruptedException
+     * @throws Exception
+     */
+    private void tearDownIteration() throws InterruptedException, Exception {
+        shutdownBackgroundJobs();
+        
+        afterIteration();
+    }    
+
+    /**
+     * Setup any options before the benchmarks.
+     * 
+     * @throws Exception
+     */
+    protected void beforeSuite() throws Exception {}
+
+    /**
+     * Prepares this performance benchmark.
+     * 
+     * @param repository the repository to use
+     * @param fixture credentials of a user with write access
+     * @throws Exception if the benchmark can not be prepared
+     */
+    public void setUp(Repository repository, RepositoryFixture fixture, Credentials credentials)
+            throws Exception {
+        this.repository = repository;
+        this.credentials = credentials;
+        this.sessions = new LinkedList<Session>();
+        this.fixture = fixture;
+        context = new ExecutionContext();
+        result = new Result();
+
+        beforeSuite();
+
+        if (PROFILE) {
+            context.startProfiler();
+        }
+    }
+
+    /**
+     * Cleanup after the benchmarks are run.
+     * 
+     * @throws Exception
+     */
+    protected void afterSuite() throws Exception {}
+
+    /**
+     * Cleans up after this performance benchmark.
+     * 
+     * @throws Exception if the benchmark can not be cleaned up
+     */
+    public void tearDown() throws Exception {
+
+        context.stopProfiler();
+        result.out();
+
+        afterSuite();
+
+        for (Session session : sessions) {
+            if (session.isLive()) {
+                session.logout();
+            }
+        }
+
+        this.threads = null;
+        this.sessions = null;
+        this.credentials = null;
+        this.repository = null;
+        this.context = null;
+        this.result = null;
+        this.benchmarks = null;
+    }
+
+    /**
+     * Adds the benchmarks to run.
+     * 
+     * @param benchmarks
+     * @return
+     */
+    public abstract ScalabilitySuite addBenchmarks(ScalabilityBenchmark... benchmarks);
+    
+    /**
+     * Removes the benchmark.
+     */
+    @Override
+    public boolean removeBenchmark(String benchmark) {
+        return benchmarks.remove(benchmark) != null;
+    }
+    
+    @Override
+    public Map<String, ScalabilityBenchmark> getBenchmarks() {
+        return benchmarks;
+    }
+    /**
+     * Runs the benchmark.
+     * 
+     * @param benchmark
+     * @throws Exception 
+     */
+    protected abstract void executeBenchmark(ScalabilityBenchmark benchmark,
+            ExecutionContext context) throws Exception;
+
+    /**
+     * Runs the iteration of the benchmarks added.
+     * 
+     * @param context
+     * @throws Exception 
+     */
+    private void runIteration(ExecutionContext context) throws Exception {
+        Preconditions.checkArgument(benchmarks != null && !benchmarks.isEmpty(),
+                "No Benchmarks configured");
+
+        for (ScalabilityBenchmark benchmark : benchmarks.values()) {
+            if (result.getBenchmarkStatistics(benchmark) == null) {
+                result.addBenchmarkStatistics(benchmark, new SynchronizedDescriptiveStatistics());
+            }
+
+            Stopwatch watch = Stopwatch.createStarted();
+
+            executeBenchmark(benchmark, context);
+
+            watch.stop();
+            result.getBenchmarkStatistics(benchmark).addValue(watch.elapsed(TimeUnit.MILLISECONDS));
+            
+            if (DEBUG) {
+                System.out.println("Execution time for " + benchmark + "-"
+                                            + watch.elapsed(TimeUnit.MILLISECONDS));
+            }
+        }
+    }
+
+    /**
+     * Executes once for each iteration.
+     * 
+     * @param context the context
+     * @throws Exception the repository exception
+     */
+    public void beforeIteration(ExecutionContext context) throws Exception {}
+
+    /**
+     * Run after all iterations of this test have been executed. Subclasses can
+     * override this method to clean up static test content.
+     * 
+     * @throws Exception if an error occurs
+     */
+    protected void afterIteration() throws Exception {}
+
+    /**
+     * Adds a background thread that repeatedly executes the given job
+     * until all the iterations of this test have been executed.
+     * 
+     * @param job background job
+     */
+    protected void addBackgroundJob(final Runnable job) {
+        Thread thread = new Thread("Background job " + job) {
+            @Override
+            public void run() {
+                while (running) {
+                    job.run();
+                }
+            }
+        };
+        thread.start();
+        threads.add(thread);
+    }
+    
+    /**
+     * Sets the running flag to true.
+     */
+    protected void initBackgroundJobs() {
+        this.running = true;
+        threads = newArrayList();
+    }
+    
+    /**
+     * Shutdown the background threads.
+     * 
+     * @throws InterruptedException
+     */
+    protected void shutdownBackgroundJobs() throws InterruptedException {
+        this.running = false;
+        for (Thread thread : threads) {
+            thread.join();
+        }
+    }
+
+    protected Repository[] createRepository(RepositoryFixture fixture) throws Exception {
+        return fixture.setUpCluster(1);
+    }
+
+    /**
+     * Returns a new writer session that will be automatically closed once
+     * all the iterations of this test have been executed.
+     * 
+     * @return writer session
+     */
+    protected Session loginWriter() {
+        try {
+            Session session = repository.login(credentials);
+            synchronized (sessions) {
+                sessions.add(session);
+            }
+            return session;
+        } catch (RepositoryException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Collects the execution times for each benchmark.
+     */
+    class Result {
+        private Map<ScalabilityBenchmark, DescriptiveStatistics> stats;
+
+        public Result() {
+            this.stats = newHashMap();
+        }
+
+        public void addBenchmarkStatistics(ScalabilityBenchmark benchmark,
+                SynchronizedDescriptiveStatistics stat) {
+            stats.put(benchmark, stat);
+        }
+
+        public DescriptiveStatistics getBenchmarkStatistics(ScalabilityBenchmark benchmark) {
+            return stats.get(benchmark);
+        }
+
+        public void out() {
+            Iterator<Entry<ScalabilityBenchmark, DescriptiveStatistics>> iter =
+                    stats.entrySet().iterator();
+            while (iter.hasNext()) {
+                Entry<ScalabilityBenchmark, DescriptiveStatistics> entry = iter.next();
+                DescriptiveStatistics statistics = entry.getValue();
+                ScalabilityBenchmark benchmark = entry.getKey();
+
+                System.out
+                        .format(
+                                "# %-26.26s       min     10%%     50%%     90%%     max       N%n",
+                                benchmark.toString());
+                if (out != null) {
+                    out.format(
+                            "# %-26.26s       min     10%%     50%%     90%%     max       N%n",
+                            benchmark.toString());
+                }
+
+                System.out.format(
+                        "%-30.30s  %6.0f  %6.0f  %6.0f  %6.0f  %6.0f  %6d%n",
+                        fixture.toString(),
+                        statistics.getMin(),
+                        statistics.getPercentile(10.0),
+                        statistics.getPercentile(50.0),
+                        statistics.getPercentile(90.0),
+                        statistics.getMax(),
+                        statistics.getN());
+
+                if (out != null) {
+                    out.format(
+                            "%-30.30s  %-6.0f  %-6.0f  %-6.0f  %-6.0f  %-6.0f  %-6d%n",
+                            fixture.toString(),
+                            statistics.getMin(),
+                            statistics.getPercentile(10.0),
+                            statistics.getPercentile(50.0),
+                            statistics.getPercentile(90.0),
+                            statistics.getMax(),
+                            statistics.getN());
+                }
+
+                StringBuffer header = new StringBuffer();
+                header.append("\t# %-26.26s");
+                for (String increment : INCREMENTS) {
+                    header.append("\t");
+                    header.append(increment);
+                }
+                header.append("%n");
+                System.out.format(header.toString(), "Iterations/Load");
+
+                StringBuffer format = new StringBuffer();
+                format.append("%-30.30s");
+                System.out.format(format.toString(), "\t" + "Time (ms)");
+                if (out != null) {
+                    out.format(format.toString(), "\t" + "Time (ms)");
+                }
+
+                for (int idx = 0; idx < INCREMENTS.size(); idx++) {
+                    format = new StringBuffer();
+                    format.append("\t");
+                    format.append("%-7.0f");
+                    System.out.format(format.toString(), statistics.getValues()[idx]);
+                    if (out != null) {
+                        out.format(format.toString(), statistics.getValues()[idx]);
+                    }
+                }
+                System.out.format("%n");
+            }
+        }
+    }
+
+    /**
+     * Execution context to be pass information to and from the suite to the benchmarks.
+     */
+    class ExecutionContext {
+        private Profiler profiler;
+        private AtomicLong iteration = new AtomicLong();
+        private Map<Object, Object> map = newConcurrentMap();
+
+        protected void setIncrement(int increment) {
+            iteration.getAndSet(increment);
+        }
+
+        public int getIncrement() {
+            return iteration.intValue();
+        }
+
+        public void startProfiler() {
+            if (PROFILE) {
+                profiler = new Profiler().startCollecting();
+            }
+        }
+
+        public void stopProfiler() {
+            if (profiler != null) {
+                System.out.println(profiler.stopCollecting().getTop(5));
+                profiler = null;
+            }
+        }
+
+        public Map<Object, Object> getMap() {
+            return map;
+        }
+
+        public void setMap(Map<Object, Object> map) {
+            this.map = map;
+        }
+    }
+
+    @Override
+    public String toString() {
+        String name = getClass().getName();
+        return name.substring(name.lastIndexOf('.') + 1);
+    }
+
+    @Override
+    public void setPrintStream(PrintStream out) {
+        this.out = out;
+    }
+
+    protected Repository getRepository() {
+        return repository;
+    }
+}

Property changes on: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityAbstractSuite.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityBenchmark.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityBenchmark.java	(revision 0)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityBenchmark.java	(working copy)
@@ -0,0 +1,45 @@
+/*
+ * 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.scalability;
+
+import javax.jcr.Credentials;
+import javax.jcr.Repository;
+
+import org.apache.jackrabbit.oak.scalability.ScalabilityAbstractSuite.ExecutionContext;
+
+
+/**
+ * Abstract class for all the Scalability/Longevity benchmarks.
+ * 
+ */
+public abstract class ScalabilityBenchmark {
+
+    /**
+     * Runs the benchmark against the given repository.
+     * 
+     * @param fixtures repository fixtures
+     * @throws Exception 
+     */
+    public abstract void execute(Repository repository, Credentials credentials,
+            ExecutionContext context) throws Exception;
+
+    @Override
+    public String toString() {
+        String name = getClass().getName();
+        return name.substring(name.lastIndexOf('.') + 1);
+    }
+}

Property changes on: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityBenchmark.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityBlobSearchSuite.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityBlobSearchSuite.java	(revision 0)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityBlobSearchSuite.java	(working copy)
@@ -0,0 +1,476 @@
+/*
+ * 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.scalability;
+
+import static com.google.common.collect.Lists.newArrayList;
+import static com.google.common.collect.Lists.newArrayListWithCapacity;
+
+import java.util.Calendar;
+import java.util.List;
+import java.util.Random;
+
+import javax.jcr.Binary;
+import javax.jcr.Node;
+import javax.jcr.Property;
+import javax.jcr.PropertyType;
+import javax.jcr.Repository;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import javax.jcr.UnsupportedRepositoryOperationException;
+import javax.jcr.ValueFormatException;
+import javax.jcr.lock.LockException;
+import javax.jcr.nodetype.ConstraintViolationException;
+import javax.jcr.nodetype.NodeType;
+import javax.jcr.version.VersionException;
+
+import org.apache.commons.io.output.NullOutputStream;
+import org.apache.jackrabbit.commons.JcrUtils;
+import org.apache.jackrabbit.oak.benchmark.TestInputStream;
+import org.apache.jackrabbit.oak.benchmark.util.Date;
+import org.apache.jackrabbit.oak.benchmark.util.MimeType;
+import org.apache.jackrabbit.oak.fixture.JcrCustomizer;
+import org.apache.jackrabbit.oak.fixture.OakRepositoryFixture;
+import org.apache.jackrabbit.oak.fixture.RepositoryFixture;
+import org.apache.jackrabbit.oak.jcr.Jcr;
+import org.apache.jackrabbit.oak.plugins.index.IndexConstants;
+import org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexEditorProvider;
+import org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexProvider;
+import org.apache.jackrabbit.oak.plugins.index.lucene.util.LuceneInitializerHelper;
+import org.apache.jackrabbit.oak.plugins.index.property.PropertyIndexEditorProvider;
+import org.apache.jackrabbit.oak.plugins.nodetype.NodeTypeConstants;
+import org.apache.jackrabbit.oak.spi.commit.Observer;
+import org.apache.jackrabbit.oak.spi.query.QueryIndexProvider;
+
+import com.google.common.base.Strings;
+import com.google.common.collect.Lists;
+
+/**
+ * The suite test will incrementally increase the load and execute searches.
+ * Each test run thus adds blobs and executes different searches. This way we measure time taken for
+ * search(es) execution.
+ * 
+ */
+public class ScalabilityBlobSearchSuite extends ScalabilityAbstractSuite {
+    private static final int FILE_SIZE = Integer.getInteger("fileSize", 1);
+
+    /**
+     * Controls the number of concurrent threads for loading blobs initially
+     */
+    private static final int LOADERS = Integer.getInteger("loaders", 1);
+
+    /**
+     * Controls the number of concurrent threads for writing blobs
+     */
+    private static final int WRITERS = Integer.getInteger("fileWriters", 0);
+
+    /**
+     * Controls the number of concurrent thread for reading blobs
+     */
+    private static final int READERS = Integer.getInteger("fileReaders", 0);
+
+    /**
+     * Controls the number of concurrent thread for searching
+     */
+    private static final int SEARCHERS = Integer.getInteger("fileSearchers", 1);
+
+    /**
+     * Controls the max child nodes created under a node.
+     */
+    private static final int MAX_ASSETS_PER_LEVEL = Integer.getInteger("maxAssets", 500);
+
+    public static final String CTX_SEARCH_PATHS_PROP = "searchPaths";
+    
+    public static final String CTX_ROOT_NODE_NAME_PROP = "rootNodeName";
+    
+    public static final String CTX_FILE_NODE_TYPE_PROP = "nodeType";
+
+    private static final String CUSTOM_PATH_PROP = "contentPath";
+
+    private static final String CUSTOM_REF_PROP = "references";
+
+    public static final String FORMAT_PROP = "format";
+
+    protected static final String ROOT_NODE_NAME =
+            "LongevitySearchAssets" + TEST_ID;
+
+    private final Random random = new Random(29);
+
+    private List<String> searchPaths;
+
+    private List<String> readPaths;
+
+    private Boolean storageEnabled;
+
+    public ScalabilityBlobSearchSuite(Boolean storageEnabled) {
+        this.storageEnabled = storageEnabled;
+    }
+
+    @Override
+    public ScalabilitySuite addBenchmarks(ScalabilityBenchmark... tests) {
+        for (ScalabilityBenchmark test : tests) {
+            benchmarks.put(test.toString(), test);
+        }
+        return this;
+    }
+
+    @Override
+    protected void beforeSuite() throws Exception {
+        Session session = loginWriter();
+        Node root = session.getRootNode();
+        
+        root.addNode(ROOT_NODE_NAME);
+
+        // defining indexes
+        createIndexDefinition(root, FORMAT_PROP, PropertyIndexEditorProvider.TYPE,
+            new String[] { FORMAT_PROP }, false);
+
+        session.save();
+    }
+
+    /**
+     * create a new index definition
+     * 
+     * @param root the root node of the repository
+     * @param indexDefinitionName the name of the node for the index definition
+     * @param indexType the type of the index. Eg {@code property} or {@code ordered}
+     * @param propertyNames the list of properties to index
+     * @param unique if unique or not
+     * @return the node just created
+     * @throws RepositoryException
+     */
+    private Node createIndexDefinition(final Node root, final String indexDefinitionName,
+                                       final String indexType, final String[] propertyNames,
+                                       final boolean unique) throws RepositoryException {
+        Node indexDefRoot = JcrUtils.getOrAddNode(root, IndexConstants.INDEX_DEFINITIONS_NAME,
+            NodeTypeConstants.NT_UNSTRUCTURED);
+        Node indexDef = JcrUtils.getOrAddNode(indexDefRoot, indexDefinitionName,
+            IndexConstants.INDEX_DEFINITIONS_NODE_TYPE);
+        indexDef.setProperty(IndexConstants.TYPE_PROPERTY_NAME, indexType);
+        indexDef.setProperty(IndexConstants.REINDEX_PROPERTY_NAME, true);
+        indexDef.setProperty(IndexConstants.PROPERTY_NAMES, propertyNames,
+            PropertyType.NAME);
+        indexDef.setProperty(IndexConstants.UNIQUE_PROPERTY_NAME, unique);
+        // TODO declaring nodeTypes
+        // TODO any additional properties
+        return indexDef;
+    }
+    
+    /**
+     * Executes before each test run
+     */
+    @Override
+    public void beforeIteration(ExecutionContext context) throws RepositoryException {
+        if (DEBUG) {
+            System.out.println("Started beforeIteration()");
+        }
+
+        // recreate paths created in this run
+        searchPaths = newArrayList();
+        readPaths = newArrayListWithCapacity(READERS);
+        
+        // create the blob load for this iteration
+        createLoad(context);
+        
+        // Add background jobs to simulate workload
+        for (int i = 0; i < WRITERS; i++) {
+            /* Each writer will write to a directory of the form load-b-i */
+            addBackgroundJob(new Writer(String.valueOf(context.getIncrement() + "-b-" + i), 1));
+        }
+        for (int i = 0; i < READERS; i++) {
+            addBackgroundJob(new Reader());
+        }
+        
+        if (DEBUG) {
+            System.out.println("Finish beforeIteration()");
+        }
+        
+        context.getMap().put(CTX_ROOT_NODE_NAME_PROP, ROOT_NODE_NAME);
+        context.getMap().put(CTX_SEARCH_PATHS_PROP, searchPaths);
+    }
+
+    /**
+     * Creates the load for the search.
+     *
+     * @param context the context
+     * @throws RepositoryException the repository exception
+     */
+    private void createLoad(ExecutionContext context) throws RepositoryException {
+        // Creates assets for this run
+        List<Thread> loadThreads = newArrayList();
+        for(int idx = 0; idx < LOADERS; idx++) {
+            /* Each loader will write to a directory of the form load-idx */
+            Thread t = new Thread(new Writer((context.getIncrement() + "-" + idx), 
+                                        context.getIncrement()/LOADERS), 
+                                    "LoadThread-" + idx);
+            loadThreads.add(t);
+            t.start();
+        }
+        
+        // wait for the load threads to finish
+        for(Thread t : loadThreads) {
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override
+    protected void executeBenchmark(final ScalabilityBenchmark benchmark, final ExecutionContext context) throws Exception {
+        //Execute the benchmark with the number threads configured 
+        List<Thread> threads = newArrayListWithCapacity(SEARCHERS);
+        for (int idx = 0; idx < SEARCHERS;idx++) {
+            Thread t = new Thread("Search-" + idx) {
+                @Override
+                public void run() {
+                    try {
+                        benchmark.execute(getRepository(), CREDENTIALS, context);
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                }
+            };
+            threads.add(t);
+            t.start();
+        }
+        
+        for(Thread t : threads) {
+            try {
+                t.join();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override
+    protected Repository[] createRepository(RepositoryFixture fixture) throws Exception {
+        if (fixture instanceof OakRepositoryFixture) {
+            return ((OakRepositoryFixture) fixture).setUpCluster(1, new JcrCustomizer() {
+                @Override
+                public Jcr customize(Jcr jcr) {
+                    LuceneIndexProvider provider = new LuceneIndexProvider();
+                    jcr.with((QueryIndexProvider) provider)
+                            .with((Observer) provider)
+                            .with(new LuceneIndexEditorProvider())
+                            .with(new LuceneInitializerHelper("luceneGlobal", storageEnabled));
+                    return jcr;
+                }
+            });
+        }
+        return super.createRepository(fixture);
+    }
+
+    private synchronized String getRandomReadPath() {
+        if (readPaths.size() > 0) {
+            return readPaths.get(random.nextInt(readPaths.size()));
+        } else {
+            return "";
+        }
+    }
+
+    private synchronized void addReadPath(String file) {
+        // Limit the number of paths added to be no more than the number of readers to limit the
+        // heap used.
+        int limit = 1000;
+        if (readPaths.size() < limit) {
+            readPaths.add(file);
+        } else if (random.nextDouble() < 0.5) {
+            readPaths.set(random.nextInt(limit), file);
+        }
+    }
+
+    private synchronized void addSearchPath(String path) {
+        if (!searchPaths.contains(path)) {
+            searchPaths.add(path);
+        }
+    }
+    
+    private class Reader implements Runnable {
+
+        private final Session session = loginWriter();
+
+        @Override
+        public void run() {
+            try {
+                String path = getRandomReadPath();
+                session.refresh(false);
+                JcrUtils.readFile(
+                        session.getNode(path), new NullOutputStream());
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+    private class Writer implements Runnable {
+
+        private final Node parent;
+        
+        private final Session session;
+        
+        private long counter;
+        
+        private String id;
+        
+        /** The maximum number of assets to be written by this thread. */
+        private int maxAssets;
+
+        Writer(String id, int maxAssets) throws RepositoryException {
+            this.id = id;
+            this.maxAssets = maxAssets;
+            this.session = loginWriter();
+            this.parent = session
+                    .getRootNode()
+                    .getNode(ROOT_NODE_NAME)
+                    .addNode("writer-" + id);
+            session.save();
+        }
+
+        @Override
+        public void run() {
+            try {
+                int count = 0;
+                while (count < maxAssets) {
+                    session.refresh(false);
+
+                    List<String> levels = Lists.newArrayList();
+                    getParentLevels(count, maxAssets, levels);
+
+                    String fileNamePrefix = getFileNamePrefix(levels);
+                    String parentDir = getParentSuffix(levels);
+
+                    Node file = putFile(fileNamePrefix, parentDir);
+
+                    session.save();
+
+                    // record for searching and reading
+                    addReadPath(file.getPath());
+                    addSearchPath(fileNamePrefix);
+
+                    if (DEBUG && (count + 1) % 1000 == 0) {
+                        System.out.println("Thread " + id + " - Added assets : " + (count + 1));
+                    }
+                    count++;
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        private Node putFile(String fileNamePrefix, String parentDir) throws RepositoryException,
+                UnsupportedRepositoryOperationException, ValueFormatException, VersionException,
+                LockException, ConstraintViolationException {
+            String type = getType();
+
+            Node filepath = JcrUtils.getOrAddNode(parent, parentDir, type);
+            Node file =
+                    JcrUtils.getOrAddNode(filepath,
+                            (fileNamePrefix + "File" + counter++),
+                            type);
+            
+            // adding a custom format/mime-type for later querying.
+            file.setProperty(FORMAT_PROP, MimeType.randomMimeType().getValue());
+            // adding a last modified for later querying
+            file.setProperty(Property.JCR_LAST_MODIFIED, Date.randomDate().getCalendar());
+            
+            Binary binary =
+                    parent.getSession().getValueFactory().createBinary(
+                            new TestInputStream(FILE_SIZE * 1024));
+            try {
+                Node content =
+                        JcrUtils.getOrAddNode(file, Node.JCR_CONTENT, NodeType.NT_RESOURCE);
+
+                content.setProperty(Property.JCR_MIMETYPE, "application/octet-stream");
+                content.setProperty(Property.JCR_LAST_MODIFIED, Calendar.getInstance());
+                content.setProperty(Property.JCR_DATA, binary);
+
+                file.setProperty(CUSTOM_PATH_PROP, file.getPath());
+                String reference = getRandomReadPath();
+                if (!Strings.isNullOrEmpty(reference)) {
+                    file.setProperty(CUSTOM_REF_PROP, reference);
+                }
+            } finally {
+                binary.dispose();
+            }
+            return file;
+        }
+
+        private String getType() throws RepositoryException {
+            String type = NodeTypeConstants.NT_UNSTRUCTURED;
+            if (!context.getMap().containsKey(CTX_FILE_NODE_TYPE_PROP)) {
+                if (parent.getSession().getWorkspace().getNodeTypeManager().hasNodeType(
+                        NodeTypeConstants.NT_OAK_UNSTRUCTURED)) {
+                    type = NodeTypeConstants.NT_OAK_UNSTRUCTURED;
+                }
+                context.getMap().put(CTX_FILE_NODE_TYPE_PROP, type);
+            } else {
+                type = (String) context.getMap().get(CTX_FILE_NODE_TYPE_PROP);
+            }
+            return type;
+        }
+
+
+        /**
+         * Create a handy filename to search known files.
+         * 
+         * @param levels
+         * @return
+         */
+        private String getFileNamePrefix(List<String> levels) {
+            String name = "";
+            for (String level : levels) {
+                name = name + "Level" + level;
+            }
+            return name;
+        }
+
+        private String getParentSuffix(List<String> levels) {
+            String parentSuffix = "";
+            for (String level : levels) {
+                parentSuffix = parentSuffix + level + "/";
+            }
+            return parentSuffix;
+        }
+
+        /**
+         * Assigns the asset to it appropriate folder. The folder hierarchy is construted such that
+         * each
+         * folder has only MAX_ASSETS_PER_LEVEL children.
+         * 
+         * @param assetNum
+         * @param maxAssets
+         * @param levels
+         */
+        private void getParentLevels(long assetNum, long maxAssets,
+                List<String> levels) {
+
+            int maxAssetsNextLevel =
+                    (int) Math.ceil((double) maxAssets / (double) MAX_ASSETS_PER_LEVEL);
+            long nextAssetBucket = assetNum / maxAssetsNextLevel;
+
+            levels.add(String.valueOf(nextAssetBucket));
+            if (maxAssetsNextLevel > MAX_ASSETS_PER_LEVEL) {
+                getParentLevels((assetNum - nextAssetBucket * maxAssetsNextLevel),
+                        maxAssetsNextLevel,
+                        levels);
+            }
+        }
+    }
+}

Property changes on: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityBlobSearchSuite.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityRunner.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityRunner.java	(revision 0)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityRunner.java	(working copy)
@@ -0,0 +1,179 @@
+/*
+ * 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.scalability;
+
+import java.io.File;
+import java.io.PrintStream;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import joptsimple.OptionParser;
+import joptsimple.OptionSet;
+import joptsimple.OptionSpec;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.jackrabbit.oak.benchmark.CSVResultGenerator;
+import org.apache.jackrabbit.oak.benchmark.util.Date;
+import org.apache.jackrabbit.oak.fixture.JackrabbitRepositoryFixture;
+import org.apache.jackrabbit.oak.fixture.OakRepositoryFixture;
+import org.apache.jackrabbit.oak.fixture.RepositoryFixture;
+
+import com.google.common.base.Splitter;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+/**
+ * Main class for running scalability/longevity tests.
+ * 
+ */
+public class ScalabilityRunner {
+
+    private static final int MB = 1024 * 1024;
+
+    public static void main(String[] args) throws Exception {
+        OptionParser parser = new OptionParser();
+        OptionSpec<File> base = parser.accepts("base", "Base directory")
+                .withRequiredArg().ofType(File.class)
+                .defaultsTo(new File("target"));
+        OptionSpec<String> host = parser.accepts("host", "MongoDB host")
+                .withRequiredArg().defaultsTo("localhost");
+        OptionSpec<Integer> port = parser.accepts("port", "MongoDB port")
+                .withRequiredArg().ofType(Integer.class).defaultsTo(27017);
+        OptionSpec<String> dbName = parser.accepts("db", "MongoDB database")
+                .withRequiredArg();
+        OptionSpec<Boolean> dropDBAfterTest =
+                parser.accepts("dropDBAfterTest",
+                        "Whether to drop the MongoDB database after the test")
+                        .withOptionalArg().ofType(Boolean.class).defaultsTo(true);
+        OptionSpec<Boolean> mmap = parser.accepts("mmap", "TarMK memory mapping")
+                .withOptionalArg().ofType(Boolean.class)
+                .defaultsTo("64".equals(System.getProperty("sun.arch.data.model")));
+        OptionSpec<Integer> cache = parser.accepts("cache", "cache size (MB)")
+                .withRequiredArg().ofType(Integer.class).defaultsTo(100);
+        OptionSpec<Integer> fdsCache = parser.accepts("blobCache", "cache size (MB)")
+                .withRequiredArg().ofType(Integer.class).defaultsTo(32);
+        OptionSpec<Boolean> withStorage = parser
+                .accepts("storage", "Index storage enabled").withOptionalArg()
+                .ofType(Boolean.class);
+        OptionSpec<File> csvFile =
+                parser.accepts("csvFile", "File to write a CSV version of the benchmark data.")
+                        .withOptionalArg().ofType(File.class);
+        OptionSpec<File> dumpFile =
+                parser.accepts("dumpFile", "File to write threa dumps.")
+                        .withOptionalArg().ofType(File.class);
+
+        OptionSet options = parser.parse(args);
+        int cacheSize = cache.value(options);
+        RepositoryFixture[] allFixtures = new RepositoryFixture[] {
+                new JackrabbitRepositoryFixture(base.value(options), cacheSize),
+                OakRepositoryFixture.getMemory(cacheSize * MB),
+                OakRepositoryFixture.getMemoryNS(cacheSize * MB),
+                OakRepositoryFixture.getMemoryMK(cacheSize * MB),
+                OakRepositoryFixture.getH2MK(base.value(options), cacheSize * MB),
+                OakRepositoryFixture.getMongo(
+                        host.value(options), port.value(options),
+                        dbName.value(options), dropDBAfterTest.value(options),
+                        cacheSize * MB),
+                OakRepositoryFixture.getMongoWithFDS(
+                        host.value(options), port.value(options),
+                        dbName.value(options), dropDBAfterTest.value(options),
+                        cacheSize * MB,
+                        base.value(options),
+                        fdsCache.value(options)),
+                OakRepositoryFixture.getMongoNS(
+                        host.value(options), port.value(options),
+                        dbName.value(options), dropDBAfterTest.value(options),
+                        cacheSize * MB),
+                OakRepositoryFixture.getMongoMK(
+                        host.value(options), port.value(options),
+                        dbName.value(options), dropDBAfterTest.value(options),
+                        cacheSize * MB),
+                OakRepositoryFixture.getTar(
+                        base.value(options), 256, cacheSize, mmap.value(options)),
+                OakRepositoryFixture.getTarWithBlobStore(
+                        base.value(options), 256, cacheSize, mmap.value(options))
+        };
+        ScalabilitySuite[] allSuites = new ScalabilitySuite[] {
+                new ScalabilityBlobSearchSuite(withStorage.value(options))
+                    .addBenchmarks(new FullTextSearcher(), 
+                                    new NodeTypeSearcher(),
+                                    new FormatSearcher(),
+                                    new LastModifiedSearcher(Date.LAST_2_HRS),
+                                    new LastModifiedSearcher(Date.LAST_24_HRS),
+                                    new LastModifiedSearcher(Date.LAST_7_DAYS),
+                                    new LastModifiedSearcher(Date.LAST_MONTH),
+                                    new LastModifiedSearcher(Date.LAST_YEAR))
+        };
+
+        Set<String> argset = Sets.newHashSet(options.nonOptionArguments());
+        List<RepositoryFixture> fixtures = Lists.newArrayList();
+        for (RepositoryFixture fixture : allFixtures) {
+            if (argset.remove(fixture.toString())) {
+                fixtures.add(fixture);
+            }
+        }
+        
+        Map<String, List<String>> argmap = Maps.newHashMap();
+        // Split the args to get suites and benchmarks (i.e. suite:benchmark1,benchmark2)
+        for(String arg : argset) {
+            String tokens[] = arg.split(":");
+            if (tokens.length > 1) {
+                argmap.put(tokens[0], Splitter.on(",").trimResults().splitToList(tokens[1]));
+            } else {
+                argmap.put(tokens[0], null);
+            }
+            argset.remove(arg);
+        }
+        
+        List<ScalabilitySuite> suites = Lists.newArrayList();
+        for (ScalabilitySuite suite : allSuites) {
+            if (argmap.containsKey(suite.toString())) {
+                List<String> benchmarks = argmap.get(suite.toString());
+                // Only keep requested benchmarks
+                if (benchmarks != null) {
+                    for (ScalabilityBenchmark availableBenchmark : suite.getBenchmarks().values()) {
+                        if (!benchmarks.contains(availableBenchmark.toString())) {
+                            suite.removeBenchmark(availableBenchmark.toString());
+                        }
+                    }
+                }
+                suites.add(suite);
+                argmap.remove(suite.toString());
+            }
+        }
+
+        if (argmap.isEmpty()) {
+            PrintStream out = null;
+            if (options.has(csvFile)) {
+                out = new PrintStream(FileUtils.openOutputStream(csvFile.value(options), true));
+            }
+            for (ScalabilitySuite suite : suites) {
+                if (suite instanceof CSVResultGenerator) {
+                    ((CSVResultGenerator) suite).setPrintStream(out);
+                }
+                suite.run(fixtures);
+            }
+            if (out != null) {
+                out.close();
+            }
+        } else {
+            System.err.println("Unknown arguments: " + argset);
+        }
+    }
+}

Property changes on: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilityRunner.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilitySuite.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilitySuite.java	(revision 0)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilitySuite.java	(working copy)
@@ -0,0 +1,34 @@
+/*
+ * 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.scalability;
+
+import java.util.Map;
+
+import org.apache.jackrabbit.oak.fixture.RepositoryFixture;
+
+/**
+ * Interface for longevity suite for load testing.
+ */
+public interface ScalabilitySuite {
+    ScalabilitySuite addBenchmarks(ScalabilityBenchmark... benchmarks);
+
+    boolean removeBenchmark(String benchmark);
+    
+    void run(Iterable<RepositoryFixture> fixtures);
+
+    Map<String, ScalabilityBenchmark> getBenchmarks();
+}

Property changes on: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/ScalabilitySuite.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/SearchScalabilityBenchmark.java
===================================================================
--- oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/SearchScalabilityBenchmark.java	(revision 0)
+++ oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/SearchScalabilityBenchmark.java	(working copy)
@@ -0,0 +1,71 @@
+/*
+ * 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.scalability;
+
+import javax.annotation.Nonnull;
+import javax.jcr.Credentials;
+import javax.jcr.Node;
+import javax.jcr.Repository;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import javax.jcr.query.Query;
+import javax.jcr.query.QueryManager;
+import javax.jcr.query.QueryResult;
+import javax.jcr.query.RowIterator;
+
+import org.apache.jackrabbit.oak.scalability.ScalabilityAbstractSuite.ExecutionContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Abstract class for search scalability benchmarks.
+ *
+ */
+public abstract class SearchScalabilityBenchmark extends ScalabilityBenchmark {
+    protected static final Logger LOG = LoggerFactory.getLogger(SearchScalabilityBenchmark.class);    
+
+    /**
+     * Controls the max results retrieved after search
+     */
+    private int MAX_RESULTS = Integer.getInteger("maxResults", 100);
+
+    @Override
+    public void execute(Repository repository, Credentials credentials, ExecutionContext context) 
+            throws Exception {
+        Session session = repository.login(credentials);
+        QueryManager qm;
+        try {
+            qm = session.getWorkspace().getQueryManager();
+            search(qm, context);
+        } catch (RepositoryException e) {
+            e.printStackTrace();
+        }
+    }
+
+    protected void search(QueryManager qm, ExecutionContext context) throws RepositoryException {
+        Query q = getQuery(qm, context);
+        QueryResult r = q.execute();
+        RowIterator it = r.getRows();
+        for (int rows = 0; it.hasNext() && rows < MAX_RESULTS; rows++) {
+            Node node = it.nextRow().getNode();
+            LOG.debug(node.getPath());
+        }
+    }
+
+    protected abstract Query getQuery(@Nonnull final QueryManager qm, ExecutionContext context) 
+            throws RepositoryException;
+}
\ No newline at end of file

Property changes on: oak-run/src/main/java/org/apache/jackrabbit/oak/scalability/SearchScalabilityBenchmark.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property