http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/querying_basics/querying_partitioned_regions.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/querying_basics/querying_partitioned_regions.html.md.erb
 
b/geode-docs/developing/querying_basics/querying_partitioned_regions.html.md.erb
deleted file mode 100644
index 0105d82..0000000
--- 
a/geode-docs/developing/querying_basics/querying_partitioned_regions.html.md.erb
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title:  Querying Partitioned Regions
----
-
-<!--
-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.
--->
-
-Geode allows you to manage and store large amounts of data across distributed 
nodes using partitioned regions. The basic unit of storage for a partitioned 
region is a bucket, which resides on a Geode node and contains all the entries 
that map to a single hashcode. In a typical partitioned region query, the 
system distributes the query to all buckets across all nodes, then merges the 
result sets and sends back the query results.
-
-<a 
id="querying_partitioned_regions__section_4C603563DEDC4303818FB8F894470457"></a>
-The following list summarizes the querying functionality supported by Geode 
for partitioned regions:
-
--   **Ability to target specific nodes in a query**. If you know that a 
specific bucket contains the data that you want to query, you can use a 
function to ensure that your query only runs the specific node that holds the 
data. This can greatly improve query efficiency. The ability to query data on a 
specific node is only available if you are using functions and if the function 
is executed on one single region. In order to do this, you need to use 
`Query.execute(RegionFunctionContext context)`. See the [Java 
API](/releases/latest/javadoc/org/apache/geode/cache/query/Query.html) and 
[Querying a Partitioned Region on a Single 
Node](../query_additional/query_on_a_single_node.html#concept_30B18A6507534993BD55C2C9E0544A97)
 for more details.
--   **Ability to optimize partitioned region query performance using key 
indexes**. You can improve query performance on data that is partitioned by key 
or a field value by creating a key index and then executing the query using use 
`Query.execute(RegionFunctionContext                         context)` with the 
key or field value used as filter. See the [Java 
API](/releases/latest/javadoc/org/apache/geode/cache/query/Query.html) and 
[Optimizing Queries on Data Partitioned by a Key or Field 
Value](../query_additional/partitioned_region_key_or_field_value.html#concept_3010014DFBC9479783B2B45982014454)
 for more details.
--   **Ability to perform equi-join queries between partitioned regions and 
between partitioned regions and replicated regions**. Join queries between 
partitioned region and between partitioned regions and replicated regions are 
supported through the function service. In order to perform equi-join 
operations on partitioned regions or partitioned regions and replicated 
regions, the partitioned regions must be colocated, and you need to use the 
need to use `Query.execute(RegionFunctionContext                         
context)`. See the [Java 
API](/releases/latest/javadoc/org/apache/geode/cache/query/Query.html) and 
[Performing an Equi-Join Query on Partitioned 
Regions](../partitioned_regions/join_query_partitioned_regions.html#concept_B930D276F49541F282A2CFE639F107DD)
 for more details.
-
--   **[Using ORDER BY on Partitioned 
Regions](../../developing/query_additional/order_by_on_partitioned_regions.html)**
-
--   **[Querying a Partitioned Region on a Single 
Node](../../developing/query_additional/query_on_a_single_node.html)**
-
--   **[Optimizing Queries on Data Partitioned by a Key or Field 
Value](../../developing/query_additional/partitioned_region_key_or_field_value.html)**
-
--   **[Performing an Equi-Join Query on Partitioned 
Regions](../../developing/partitioned_regions/join_query_partitioned_regions.html)**
-
--   **[Partitioned Region Query 
Restrictions](../../developing/query_additional/partitioned_region_query_restrictions.html)**
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/querying_basics/reserved_words.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/querying_basics/reserved_words.html.md.erb 
b/geode-docs/developing/querying_basics/reserved_words.html.md.erb
deleted file mode 100644
index 7a23f91..0000000
--- a/geode-docs/developing/querying_basics/reserved_words.html.md.erb
+++ /dev/null
@@ -1,129 +0,0 @@
----
-title:  Reserved Words
----
-
-<!--
-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.
--->
-
-## <a 
id="concept_4F288B1F9579422FA481FBE2C3ADD007__section_3415163C3EFB46A6BE873E2606C9DE0F"
 class="no-quick-link"></a>Reserved Words
-
-These words are reserved for the query language and may not be used as 
identifiers. The words with asterisk (`*`) after them are not currently used by 
Geode, but are reserved for future implementation.
-
-<table>
-<colgroup>
-<col width="25%" />
-<col width="25%" />
-<col width="25%" />
-<col width="25%" />
-</colgroup>
-<tbody>
-<tr class="odd">
-<td><pre class="pre codeblock"><code>abs*
-all
-and 
-andthen* 
-any* 
-array 
-as 
-asc 
-avg* 
-bag* 
-boolean 
-by 
-byte 
-char 
-collection
-count 
-date 
-declare* 
-define*
-desc </code></pre></td>
-<td><pre class="pre codeblock"><code>dictionary 
-distinct 
-double 
-element 
-enum* 
-except* 
-exists* 
-false 
-first* 
-flatten* 
-float 
-for* 
-from 
-group* 
-having* 
-import 
-in 
-int 
-intersect* 
-interval* </code></pre></td>
-<td><pre class="pre codeblock"><code>is_defined 
-is_undefined 
-last* 
-like
-limit
-list* 
-listtoset* 
-long 
-map 
-max* 
-min* 
-mod* 
-nil 
-not 
-null 
-nvl 
-octet 
-or 
-order </code></pre></td>
-<td><pre class="pre codeblock"><code>orelse* 
-query* 
-select 
-set 
-short 
-some* 
-string 
-struct* 
-sum* 
-time 
-timestamp 
-to_date 
-true 
-type 
-undefine* 
-undefined 
-union* 
-unique* 
-where</code></pre></td>
-</tr>
-</tbody>
-</table>
-
-To access any method, attribute, or named object that has the same name as a 
query language reserved word, enclose the name within double quotation marks.
-
-Examples:
-
-``` pre
-SELECT DISTINCT "type" FROM /portfolios WHERE status = 'active'
-```
-
-``` pre
-SELECT DISTINCT * FROM /region1 WHERE emps."select"() < 100000 
-```
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/querying_basics/restrictions_and_unsupported_features.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/querying_basics/restrictions_and_unsupported_features.html.md.erb
 
b/geode-docs/developing/querying_basics/restrictions_and_unsupported_features.html.md.erb
deleted file mode 100644
index d315461..0000000
--- 
a/geode-docs/developing/querying_basics/restrictions_and_unsupported_features.html.md.erb
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title:  Query Language Restrictions and Unsupported Features
----
-
-<!--
-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.
--->
-
-At a high level, Geode does not support the following querying features:
-
--   Indexes targeted for joins across more than one region are not supported
--   Static method invocations. For example, the following query is invalid:
-
-    ``` pre
-    SELECT DISTINCT * FROM /QueryRegion0 WHERE aDay = Day.Wednesday
-    ```
-
--   You cannot create an index on fields using Set/List types (Collection 
types) that are not comparable. The OQL index implementation expects fields to 
be Comparable. To workaround this, you can create a custom Collection type that 
implements Comparable.
--   ORDER BY is only supported with DISTINCT queries.
-
-In addition, there are some specific limitations on partitioned region 
querying. See [Partitioned Region Query 
Restrictions](../query_additional/partitioned_region_query_restrictions.html#concept_5353476380D44CC1A7F586E5AE1CE7E8).
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/querying_basics/running_a_query.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/querying_basics/running_a_query.html.md.erb 
b/geode-docs/developing/querying_basics/running_a_query.html.md.erb
deleted file mode 100644
index 6ddb1de..0000000
--- a/geode-docs/developing/querying_basics/running_a_query.html.md.erb
+++ /dev/null
@@ -1,87 +0,0 @@
----
-title:  Writing and Executing a Query in Geode
----
-
-<!--
-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.
--->
-
-<a id="running_a_querying__section_C285160AF91C4486A39444C3A22D6475"></a>
-The Geode QueryService provides methods to create the Query object. You can 
then use the Query object to perform query-related operations.
-
-The QueryService instance you should use depends on whether you are querying 
the local cache of an application or if you want your application to query the 
server cache.
-
-## <a id="running_a_querying__section_8B9C3F5BFBA6421A81EEB404DBE512C2" 
class="no-quick-link"></a>Querying a Local Cache
-
-To query the application's local cache or to query other members, use 
`org.apache.geode.cache.Cache.getQueryService`.
-
-**Sample Code**
-
-``` pre
- // Identify your query string.
- String queryString = "SELECT DISTINCT * FROM /exampleRegion";
- 
- // Get QueryService from Cache.
- QueryService queryService = cache.getQueryService();
- 
- // Create the Query Object.
- Query query = queryService.newQuery(queryString);
- 
- // Execute Query locally. Returns results set.
- SelectResults results = (SelectResults)query.execute();
- 
- // Find the Size of the ResultSet.
- int size = results.size();
- 
- // Iterate through your ResultSet.
- Portfolio p = (Portfolio)results.iterator().next(); /* Region containing 
Portfolio object. */
-```
-
-## <a id="running_a_querying__section_BAD35A249F784095857CC6848F91F6A4" 
class="no-quick-link"></a>Querying a Server Cache from a Client
-
-To perform a client to server query, use 
`org.apache.geode.cache.client.Pool.getQueryService`.
-
-**Sample Code**
-
-``` pre
-// Identify your query string.
- String queryString = "SELECT DISTINCT * FROM /exampleRegion";
- 
- // Get QueryService from client pool.
- QueryService queryService = pool.getQueryService();
- 
- // Create the Query Object.
- Query query = queryService.newQuery(queryString);
- 
- // Execute Query locally. Returns results set.
- SelectResults results = (SelectResults)query.execute();
- 
- // Find the Size of the ResultSet.
- int size = results.size();
- 
- // Iterate through your ResultSet.
- Portfolio p = (Portfolio)results.iterator().next(); /* Region containing 
Portfolio object. */
-```
-
-Refer to the following JavaDocs for specific APIs:
-
--   [Query 
package](/releases/latest/javadoc/org/apache/geode/cache/query/package-summary.html)
--   
[QueryService](/releases/latest/javadoc/org/apache/geode/cache/query/QueryService.html)
-
-**Note:**
-You can also perform queries using the gfsh `query` command. See 
[query](../../tools_modules/gfsh/command-pages/query.html).
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/querying_basics/supported_character_sets.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/querying_basics/supported_character_sets.html.md.erb 
b/geode-docs/developing/querying_basics/supported_character_sets.html.md.erb
deleted file mode 100644
index 50b9c87..0000000
--- a/geode-docs/developing/querying_basics/supported_character_sets.html.md.erb
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title:  Supported Character Sets
----
-
-<!--
-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.
--->
-
-Geode query language supports the full ASCII and Unicode character sets.
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/querying_basics/what_is_a_query_string.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/querying_basics/what_is_a_query_string.html.md.erb 
b/geode-docs/developing/querying_basics/what_is_a_query_string.html.md.erb
deleted file mode 100644
index eb79645..0000000
--- a/geode-docs/developing/querying_basics/what_is_a_query_string.html.md.erb
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title:  Building a Query String
----
-
-<!--
-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.
--->
-
-<a id="what_is_a_query_string__section_1866AE6026DE4D66A2CD2363C1BC0406"></a>
-A query string is a fully formed OQL statement that can be passed to a query 
engine and executed against a data set. To build a query string, you combine 
supported keywords, expressions, and operators to create an expression that 
returns the information you require.
-
-A query string follows the rules specified by the query language and grammar. 
It can include:
-
--   **Namescopes**. For example, the IMPORT statement. See [IMPORT 
Statement](../query_select/the_import_statement.html#concept_2E9F15B2FE9041238B54736103396BF7).
--   **Path expressions**. For example, in the query `SELECT * FROM             
                    /exampleRegion`,` /exampleRegion` is a path expression. See 
[FROM Clause](../query_select/the_from_clause.html#the_from_clause).
--   **Attribute names**. For example, in the query `SELECT DISTINCT * FROM 
/exampleRegion p WHERE                             p.position1.secId = '1'`, we 
access the `secId` attribute of the Position object. See [WHERE 
Clause](../query_select/the_where_clause.html#the_where_clause).
--   **Method invocations**. For example, in the query `SELECT DISTINCT * FROM 
/exampleRegion p WHERE                             p.name.startsWith('Bo')`, we 
invoke the `startsWith` method on the Name object. See [WHERE 
Clause](../query_select/the_where_clause.html#the_where_clause).
--   **Operators**. For example, comparison operators (=,&lt;,&gt;,&lt;&gt;), 
unary operators (NOT), logical operators (AND, OR) and so on. See 
[Operators](../query_additional/operators.html#operators) for a complete list.
--   **Literals**. For example, boolean, date, time and so on. See [Supported 
Literals](../query_additional/literals.html#literals) for a complete list.
--   **Query bind parameters**. For example, in the query `SELECT DISTINCT * 
FROM $1 p WHERE p.status =                             $2`, $1 and $2 are 
parameters that can be passed to the query during runtime. See [Using Query 
Bind 
Parameters](../query_additional/using_query_bind_parameters.html#concept_173E775FE46B47DF9D7D1E40680D34DF)
 for more details.
--   **Preset query functions**. For example, ELEMENT(expr) and 
IS\_DEFINED(expr). See [SELECT 
Statement](../query_select/the_select_statement.html#concept_85AE7D6B1E2941ED8BD2A8310A81753E)
 for other available functions.
--   **SELECT statements**. For example, in the example queries above `SELECT 
*` or `SELECT DISTINCT *`. See [SELECT 
Statement](../query_select/the_select_statement.html#concept_85AE7D6B1E2941ED8BD2A8310A81753E)
 for other available functions.
--   **Comments**. OQL permits extra characters to accompany the query string 
without changing the string's definition. Form a multi-line comment by 
enclosing the comment body within `/*` and `*/` delimiters; OQL does not permit 
nested comments. A single line comment body is all the characters to the right 
of `--` (two hyphens) up to the end of the line.
-
-The components listed above can all be part of the query string, but none of 
the components are required. At a minimum, a query string contains an 
expression that can be evaluated against specified data.
-
-The following sections provide guidelines for the query language building 
blocks that are used when writing typical Geode queries.
-
--   **[IMPORT 
Statement](../../developing/query_select/the_import_statement.html)**
-
--   **[FROM Clause](../../developing/query_select/the_from_clause.html)**
-
--   **[WHERE Clause](../../developing/query_select/the_where_clause.html)**
-
--   **[SELECT 
Statement](../../developing/query_select/the_select_statement.html)**
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/region_options/chapter_overview.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/region_options/chapter_overview.html.md.erb 
b/geode-docs/developing/region_options/chapter_overview.html.md.erb
deleted file mode 100644
index e48ac79..0000000
--- a/geode-docs/developing/region_options/chapter_overview.html.md.erb
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title:  Region Data Storage and Distribution
----
-
-<!--
-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.
--->
-
-The Apache Geode data storage and distribution models put your data in the 
right place at the right time. You should understand all the options for data 
storage in Geode before you configure your data regions.
-
--   **[Storage and Distribution 
Options](../../developing/region_options/storage_distribution_options.html)**
-
-    Geode provides several models for data storage and distribution, including 
partitioned or replicated regions as well as distributed or non-distributed 
regions (local cache storage).
-
--   **[Region Types](../../developing/region_options/region_types.html)**
-
-    Region types define region behavior within a single distributed system. 
You have various options for region data storage and distribution.
-
--   **[Region Data Stores and Data 
Accessors](../../developing/region_options/data_hosts_and_accessors.html)**
-
-    Understand the difference between members that store data for a region and 
members that act only as data accessors to the region.
-
--   **[Creating Regions 
Dynamically](../../developing/region_options/dynamic_region_creation.html)**
-
-    You can dynamically create regions in your application code and 
automatically instantiate them on members of a distributed system.
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/region_options/data_hosts_and_accessors.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/region_options/data_hosts_and_accessors.html.md.erb 
b/geode-docs/developing/region_options/data_hosts_and_accessors.html.md.erb
deleted file mode 100644
index 9e35009..0000000
--- a/geode-docs/developing/region_options/data_hosts_and_accessors.html.md.erb
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title:  Region Data Stores and Data Accessors
----
-
-<!--
-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.
--->
-
-Understand the difference between members that store data for a region and 
members that act only as data accessors to the region.
-
-<a id="data_hosts_and_accessors__section_0EF33633F97B4C63AC34F523259AD310"></a>
-In most cases, when you define a data region in a member’s cache, you also 
specify whether the member is a data store. Members that store data for a 
region are referred to as data stores or data hosts. Members that do not store 
data are referred to as accessor members, or empty members. Any member, store 
or accessor, that defines a region can access it, put data into it, and receive 
events from other members. To configure a region so the member is a data 
accessor, you use configurations that specify no local data storage for the 
region. Otherwise, the member is a data store for the region.
-
-For server regions, suppress local data storage at region creation by 
specifying a region shortcut that contains the term
-"PROXY" in its name, such as `PARTITION_PROXY` or `REPLICATE_PROXY`.
-
-For client regions, suppress local data storage at region creation by 
specifying the `PROXY` region
-shortcut. Do not use the `CACHING_PROXY` shortcut for this purpose, as it 
allows local data storage.

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/region_options/dynamic_region_creation.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/region_options/dynamic_region_creation.html.md.erb 
b/geode-docs/developing/region_options/dynamic_region_creation.html.md.erb
deleted file mode 100644
index 2652e3d..0000000
--- a/geode-docs/developing/region_options/dynamic_region_creation.html.md.erb
+++ /dev/null
@@ -1,197 +0,0 @@
----
-title:  Creating Regions Dynamically
----
-
-<!--
-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.
--->
-
-You can dynamically create regions in your application code and automatically 
instantiate them on members of a distributed system.
-
-If your application does not require partitioned regions, you can use the 
<span class="keyword 
apiname">org.apache.geode.cache.DynamicRegionFactory</span> class to 
dynamically create regions, or you can create them using the 
`<dynamic-region-factory>` element in the cache.xml file that defines the 
region. See 
[&lt;dynamic-region-factory&gt;](../../reference/topics/cache_xml.html#dynamic-region-factory).
-
-Due to the number of options involved, most developers use functions to create 
regions dynamically in their applications, as described in this topic. Dynamic 
regions can also be created from the `gfsh` command line.
-
-For a complete discussion of using Geode functions, see [Function 
Execution](../function_exec/chapter_overview.html). Functions use the <span 
class="keyword apiname">org.apache.geode.cache.execute.FunctionService</span> 
class.
-
-For example, the following Java classes define and use a function for dynamic 
region creation:
-
-The <span class="keyword apiname">CreateRegionFunction</span> class defines a 
function invoked on a server by a client using the <span class="keyword 
apiname">onServer()</span> method of the <span class="keyword 
apiname">FunctionService</span> class. This function call initiates region 
creation by putting an entry into the region attributes metadata region. The 
entry key is the region name and the value is the set of region attributes used 
to create the region.
-
-``` pre
-#CreateRegionFunction.java
-
-import org.apache.geode.cache.Cache;
-import org.apache.geode.cache.CacheFactory;
-import org.apache.geode.cache.DataPolicy;
-import org.apache.geode.cache.Declarable;
-import org.apache.geode.cache.Region;
-import org.apache.geode.cache.RegionAttributes;
-import org.apache.geode.cache.RegionFactory;
-import org.apache.geode.cache.Scope;
-
-import org.apache.geode.cache.execute.Function;
-import org.apache.geode.cache.execute.FunctionContext;
-
-import java.util.Properties;
-
-public class CreateRegionFunction implements Function, Declarable {
-
-  private final Cache cache;
-  
-  private final Region<String,RegionAttributes> regionAttributesMetadataRegion;
-
-  private static final String REGION_ATTRIBUTES_METADATA_REGION = 
-                                     "_regionAttributesMetadata";
-  
-  public enum Status {SUCCESSFUL, UNSUCCESSFUL, ALREADY_EXISTS};
-
-  public CreateRegionFunction() {
-    this.cache = CacheFactory.getAnyInstance();
-    this.regionAttributesMetadataRegion = 
createRegionAttributesMetadataRegion();
-  }
-
-  public void execute(FunctionContext context) {
-    Object[] arguments = (Object[]) context.getArguments();
-    String regionName = (String) arguments[0];
-    RegionAttributes attributes = (RegionAttributes) arguments[1];
-
-    // Create or retrieve region
-    Status status = createOrRetrieveRegion(regionName, attributes);
-
-    // Return status
-    context.getResultSender().lastResult(status);
-  }
-  
-  private Status createOrRetrieveRegion(String regionName, 
-                                        RegionAttributes attributes) {
-    Status status = Status.SUCCESSFUL;
-    Region region = this.cache.getRegion(regionName);
-    if (region == null) {
-      // Put the attributes into the metadata region. The afterCreate call will
-      // actually create the region.
-      this.regionAttributesMetadataRegion.put(regionName, attributes);
-      
-      // Retrieve the region after creating it
-      region = this.cache.getRegion(regionName);
-      if (region == null) {
-        status = Status.UNSUCCESSFUL;
-      }
-    } else {
-      status = Status.ALREADY_EXISTS;
-    }
-    return status;
-  }
-  
-  private Region<String,RegionAttributes> 
-  createRegionAttributesMetadataRegion() {
-    Region<String, RegionAttributes> metaRegion = 
-                         
this.cache.getRegion(REGION_ATTRIBUTES_METADATA_REGION);
-    if (metaRegion == null) {
-      RegionFactory<String, RegionAttributes> factory =
-                              this.cache.createRegionFactory();
-      factory.setDataPolicy(DataPolicy.REPLICATE);
-      factory.setScope(Scope.DISTRIBUTED_ACK);
-      factory.addCacheListener(new CreateRegionCacheListener());
-      metaRegion = factory.create(REGION_ATTRIBUTES_METADATA_REGION);
-    }
-    return metaRegion;
-  }
-
-  public String getId() {
-    return getClass().getSimpleName();
-  }
-
-  public boolean optimizeForWrite() {
-    return false;
-  }
-
-  public boolean isHA() {
-    return true;
-  }
-
-  public boolean hasResult() {
-    return true;
-  }
-
-  public void init(Properties properties) {
-  }
-}
-```
-
-The <span class="keyword apiname">CreateRegionCacheListener</span> class is a 
cache listener that implements two methods, <span class="keyword 
apiname">afterCreate()</span> and <span class="keyword 
apiname">afterRegionCreate()</span>. The <span class="keyword 
apiname">afterCreate()</span> method creates the region. The <span 
class="keyword apiname">afterRegionCreate()</span> method causes each new 
server to create all the regions defined in the metadata region.
-
-``` pre
-#CreateRegionCacheListener.java
-
-import org.apache.geode.cache.Cache;
-import org.apache.geode.cache.CacheFactory;
-import org.apache.geode.cache.Declarable;
-import org.apache.geode.cache.EntryEvent;
-import org.apache.geode.cache.Region;
-import org.apache.geode.cache.RegionAttributes;
-import org.apache.geode.cache.RegionEvent;
-import org.apache.geode.cache.RegionExistsException;
-
-import org.apache.geode.cache.util.CacheListenerAdapter;
-
-import java.util.Map;
-import java.util.Properties;
-
-public class CreateRegionCacheListener 
-             extends CacheListenerAdapter<String,RegionAttributes>
-             implements Declarable {
-
-  private Cache cache;
-  
-  public CreateRegionCacheListener() {
-    this.cache = CacheFactory.getAnyInstance();
-  }
-
-  public void afterCreate(EntryEvent<String,RegionAttributes> event) {
-    createRegion(event.getKey(), event.getNewValue());
-  }
-  
-  public void afterRegionCreate(RegionEvent<String,RegionAttributes> event) {
-    Region<String,RegionAttributes> region = event.getRegion();
-    for (Map.Entry<String,RegionAttributes> entry : region.entrySet()) {
-      createRegion(entry.getKey(), entry.getValue());
-    }
-  }
-  
-  private void createRegion(String regionName, RegionAttributes attributes) {
-    if (this.cache.getLogger().fineEnabled()) {
-      this.cache.getLogger().fine(
-                             "CreateRegionCacheListener creating region named: 
"
-                             + regionName + " with attributes: " + attributes);
-    }
-    try {
-      Region region = this.cache.createRegionFactory(attributes)
-        .create(regionName);
-      if (this.cache.getLogger().fineEnabled()) {
-        this.cache.getLogger().fine("CreateRegionCacheListener created: "
-                               + region);
-      }
-      System.out.println("CreateRegionCacheListener created: " + region);
-    } catch (RegionExistsException e) {/* ignore */}
-  }
-
-  public void init(Properties p) {
-  }
-}
-```
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/region_options/region_types.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/region_options/region_types.html.md.erb 
b/geode-docs/developing/region_options/region_types.html.md.erb
deleted file mode 100644
index 57e565e..0000000
--- a/geode-docs/developing/region_options/region_types.html.md.erb
+++ /dev/null
@@ -1,146 +0,0 @@
----
-title:  Region Types
----
-
-<!--
-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.
--->
-
-Region types define region behavior within a single distributed system. You 
have various options for region data storage and distribution.
-
-<a id="region_types__section_E3435ED1D0D142538B99FA69A9E449EF"></a>
-Within a Geode distributed system, you can define distributed regions and 
non-distributed regions, and you can define regions whose data is spread across 
the distributed system, and regions whose data is entirely contained in a 
single member.
-
-Your choice of region type is governed in part by the type of application you 
are running. In particular, you need to use specific region types for your 
servers and clients for effective communication between the two tiers:
-
--   Server regions are created inside a `Cache` by servers and are accessed by 
clients that connect to the servers from outside the server's distributed 
system. Server regions must have region type partitioned or replicated. Server 
region configuration uses the `RegionShortcut` enum settings.
--   Client regions are created inside a `ClientCache` by clients and are 
configured to distribute data and events between the client and the server 
tier. Client regions must have region type `local`. Client region configuration 
uses the `ClientRegionShortcut` enum settings.
--   Peer regions are created inside a `Cache`. Peer regions may be server 
regions, or they may be regions that are not accessed by clients. Peer regions 
can have any region type. Peer region configuration uses the `RegionShortcut` 
enum settings.
-
-When you configure a server or peer region using `gfsh` or with the 
`cache.xml` file, you can use *region shortcuts* to define the basic 
configuration of your region. A region shortcut provides a set of default 
configuration attributes that are designed for various types of caching 
architectures. You can then add additional configuration attributes as needed 
to customize your application. For more information and a complete reference of 
these region shortcuts, see [Region Shortcuts 
Reference](../../reference/topics/region_shortcuts_reference.html#reference_lt4_54c_lk).
-
-<a id="region_types__section_A3449B07598C47A881D9219574DE46C5"></a>
-
-These are the primary configuration choices for each data region.
-
-<table>
-<colgroup>
-<col width="33%" />
-<col width="34%" />
-<col width="33%" />
-</colgroup>
-<thead>
-<tr class="header">
-<th>Region Type</th>
-<th>Description</th>
-<th>Best suited for...</th>
-</tr>
-</thead>
-<tbody>
-<tr class="odd">
-<td>Partitioned</td>
-<td>System-wide setting for the data set. Data is divided into buckets across 
the members that define the region. For high availability, configure redundant 
copies so each bucket is stored in multiple members with one member holding the 
primary.</td>
-<td>Server regions and peer regions
-<ul>
-<li>Very large data sets</li>
-<li>High availability</li>
-<li>Write performance</li>
-<li>Partitioned event listeners and data loaders</li>
-</ul></td>
-</tr>
-<tr class="even">
-<td>Replicated (distributed)</td>
-<td>Holds all data from the distributed region. The data from the distributed 
region is copied into the member replica region. Can be mixed with 
non-replication, with some members holding replicas and some holding 
non-replicas.</td>
-<td>Server regions and peer regions
-<ul>
-<li>Read heavy, small datasets</li>
-<li>Asynchronous distribution</li>
-<li>Query performance</li>
-</ul></td>
-</tr>
-<tr class="odd">
-<td>Distributed non-replicated</td>
-<td>Data is spread across the members that define the region. Each member 
holds only the data it has expressed interest in. Can be mixed with 
replication, with some members holding replicas and some holding 
non-replicas.</td>
-<td>Peer regions, but not server regions and not client regions
-<ul>
-<li>Asynchronous distribution</li>
-<li>Query performance</li>
-</ul></td>
-</tr>
-<tr class="even">
-<td>Non-distributed (local)</td>
-<td>The region is visible only to the defining member.</td>
-<td>Client regions and peer regions
-<ul>
-<li>Data that is not shared between applications</li>
-</ul></td>
-</tr>
-</tbody>
-</table>
-
-## <a id="region_types__section_C92C7DBD8EF44F1789FCB36281D3F8BF" 
class="no-quick-link"></a>Partitioned Regions
-
-Partitioning is a good choice for very large server regions. Partitioned 
regions are ideal for data sets in the hundreds of gigabytes and beyond.
-
-**Note:**
-Partitioned regions generally require more JDBC connections than other region 
types because each member that hosts data must have a connection.
-
-Partitioned regions group your data into buckets, each of which is stored on a 
subset of all of the system members. Data location in the buckets does not 
affect the logical view - all members see the same logical data set.
-
-Use partitioning for:
-
--   **Large data sets**. Store data sets that are too large to fit into a 
single member, and all members will see the same logical data set. Partitioned 
regions divide the data into units of storage called buckets that are split 
across the members hosting the partitioned region data, so no member needs to 
host all of the region’s data. Geode provides dynamic redundancy recovery and 
rebalancing of partitioned regions, making them the choice for large-scale data 
containers. More members in the system can accommodate more uniform balancing 
of the data across all host members, allowing system throughput (both gets and 
puts) to scale as new members are added.
--   **High availability**. Partitioned regions allow you configure the number 
of copies of your data that Geode should make. If a member fails, your data 
will be available without interruption from the remaining members. Partitioned 
regions can also be persisted to disk for additional high availability.
--   **Scalability**. Partitioned regions can scale to large amounts of data 
because the data is divided between the members available to host the region. 
Increase your data capacity dynamically by simply adding new members. 
Partitioned regions also allow you to scale your processing capacity. Because 
your entries are spread out across the members hosting the region, reads and 
writes to those entries are also spread out across those members.
--   **Good write performance**. You can configure the number of copies of your 
data. The amount of data transmitted per write does not increase with the 
number of members. By contrast, with replicated regions, each write must be 
sent to every member that has the region replicated, so the amount of data 
transmitted per write increases with the number of members.
-
-In partitioned regions, you can colocate keys within buckets and across 
multiple partitioned regions. You can also control which members store which 
data buckets.
-
-## <a id="region_types__section_iwt_dnj_bm" 
class="no-quick-link"></a>Replicated Regions
-
-
-Replicated regions provide the highest performance in terms of throughput and 
latency.
-Replication is a good choice for small to medium size server regions.
-
-Use replicated regions for:
-
--   **Small amounts of data required by all members of the distributed 
system**. For example, currency rate information and mortgage rates.
--   **Data sets that can be contained entirely in a single member**. Each 
replicated region holds the complete data set for the region
--   **High performance data access**. Replication guarantees local access from 
the heap for application threads, providing the lowest possible latency for 
data access.
--   **Asynchronous distribution**. All distributed regions, replicated and 
non-replicated, provide the fastest distribution speeds.
-
-## <a id="region_types__section_2232BEC969F74CDB91B1BB74FEF67EE1" 
class="no-quick-link"></a>Distributed, Non-Replicated Regions
-
-Distributed regions provide the same performance as replicated regions, but 
each member stores only  data in which it has expressed an interest, either by 
subscribing to events from other members or by defining the data entries in its 
cache.
-
-Use distributed, non-replicated regions for:
-
--   **Peer regions, but not server regions or client regions**. Server regions 
must be either replicated or partitioned. Client regions must be local.
--   **Data sets where individual members need only notification and updates 
for changes to a subset of the data**. In non-replicated regions, each member 
receives only update events for the data entries it has defined in the local 
cache.
--   **Asynchronous distribution**. All distributed regions, replicated and 
non-replicated, provide the fastest distribution speeds.
-
-## <a id="region_types__section_A8150BDBC74E4019B1942481877A4370" 
class="no-quick-link"></a>Local Regions
-
-**Note:**
-When created using the `ClientRegionShortcut` settings, client regions are 
automatically defined as local, since all client distribution activities go to 
and come from the server tier.
-
-The local region has no peer-to-peer distribution activity.
-
-Use local regions for:
-
--   **Client regions**. Distribution is only between the client and server 
tier.
--   **Private data sets for the defining member**. The local region is not 
visible to peer members.
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/region_options/storage_distribution_options.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/region_options/storage_distribution_options.html.md.erb 
b/geode-docs/developing/region_options/storage_distribution_options.html.md.erb
deleted file mode 100644
index f30135e..0000000
--- 
a/geode-docs/developing/region_options/storage_distribution_options.html.md.erb
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title:  Storage and Distribution Options
----
-
-<!--
-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.
--->
-
-Geode provides several models for data storage and distribution, including 
partitioned or replicated regions as well as distributed or non-distributed 
regions (local cache storage).
-
-## <a 
id="concept_B18B7754E7C7485BA6D66F2DDB7A11FB__section_787D674A64244871AE49CBB58475088E"
 class="no-quick-link"></a>Peer-to-Peer Region Storage and Distribution
-
-At its most general, data management means having current data available when 
and where your applications need it. In a properly configured Geode 
installation, you store your data in your local members and Geode automatically 
distributes it to the other members that need it according to your cache 
configuration settings. You may be storing very large data objects that require 
special consideration, or you may have a high volume of data requiring careful 
configuration to safeguard your application's performance or memory use. You 
may need to be able to explicitly lock some data during particular operations. 
Most data management features are available as configuration options, which you 
can specify either using the `gfsh` cluster configuration service, `cache.xml` 
file or the API. Once configured, Geode manages the data automatically. For 
example, this is how you manage data distribution, disk storage, data 
expiration activities, and data partitioning. A few features are managed at ru
 n-time through the API.
-
-At the architectural level, data distribution runs between peers in a single 
system and between clients and servers.
-
--   Peer-to-peer provides the core distribution and storage models, which are 
specified as attributes on the data regions.
-
--   For client/server, you choose which data regions to share between the 
client and server tiers. Then, within each region, you can fine-tune the data 
that the server automatically sends to the client by subscribing to subsets.
-
-Data storage in any type of installation is based on the peer-to-peer 
configuration for each individual distributed system. Data and event 
distribution is based on a combination of the peer-to-peer and system-to-system 
configurations.
-
-Storage and distribution models are configured through cache and region 
attributes. The main choices are partitioned, replicated, or just distributed. 
All server regions must be partitioned or replicated. Each region’s 
`data-policy` and `subscription-attributes`, and its `scope` if it is not a 
partitioned region, interact for finer control of data distribution.
-
-## <a 
id="concept_B18B7754E7C7485BA6D66F2DDB7A11FB__section_A364D16DFADA49D1A838A7EAF8E4251C"
 class="no-quick-link"></a>Storing Data in the Local Cache
-
-To store data in your local cache, use a region `refid` with a 
`RegionShortcut` or `ClientRegionShortcut` that has local state. These 
automatically set the region `data-policy` to a non-empty policy. Regions 
without storage can send and receive event distributions without storing 
anything in your application heap. With the other settings, all entry 
operations received are stored locally.

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/storing_data_on_disk/chapter_overview.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/storing_data_on_disk/chapter_overview.html.md.erb 
b/geode-docs/developing/storing_data_on_disk/chapter_overview.html.md.erb
deleted file mode 100644
index 002fb53..0000000
--- a/geode-docs/developing/storing_data_on_disk/chapter_overview.html.md.erb
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title:  Persistence and Overflow
----
-
-<!--
-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.
--->
-
-You can persist data on disk for backup purposes and overflow it to disk to 
free up memory without completely removing the data from your cache.
-
-**Note:**
-This supplements the general steps for managing data regions provided in 
[Basic Configuration and Programming](../../basic_config/book_intro.html).
-
-All disk storage uses Apache Geode[Disk 
Storage](../../managing/disk_storage/chapter_overview.html).
-
--   **[How Persistence and Overflow 
Work](../../developing/storing_data_on_disk/how_persist_overflow_work.html)**
-
-    To use Geode persistence and overflow, you should understand how they work 
with your data.
-
--   **[Configure Region Persistence and 
Overflow](../../developing/storing_data_on_disk/storing_data_on_disk.html)**
-
-    Plan persistence and overflow for your data regions and configure them 
accordingly.
-
--   **[Overflow Configuration 
Examples](../../developing/storing_data_on_disk/overflow_config_examples.html)**
-
-    The `cache.xml` examples show configuration of region and server 
subscription queue overflows.
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/storing_data_on_disk/how_persist_overflow_work.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/storing_data_on_disk/how_persist_overflow_work.html.md.erb
 
b/geode-docs/developing/storing_data_on_disk/how_persist_overflow_work.html.md.erb
deleted file mode 100644
index 1a1cc10..0000000
--- 
a/geode-docs/developing/storing_data_on_disk/how_persist_overflow_work.html.md.erb
+++ /dev/null
@@ -1,64 +0,0 @@
----
-title:  How Persistence and Overflow Work
----
-
-<!--
-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.
--->
-
-To use Geode persistence and overflow, you should understand how they work 
with your data.
-
-<a id="how_persist_overflow_work__section_jzl_wwb_pr"></a>
-Geode persists and overflows several types of data. You can persist or 
overflow the application data in your regions. In addition, Geode persists and 
overflows messaging queues between distributed systems, to manage memory 
consumption and provide high availability.
-
-Persistent data outlives the member where the region resides and can be used 
to initialize the region at creation. Overflow acts only as an extension of the 
region in memory.
-
-The data is written to disk according to the configuration of Geode disk 
stores. For any disk option, you can specify the name of the disk store to use 
or use the Geode default disk store. See [Disk 
Storage](../../managing/disk_storage/chapter_overview.html).
-
-## <a id="how_persist_overflow_work__section_78F2D1820B6C48859A0E5411CE360105" 
class="no-quick-link"></a>How Data Is Persisted and Overflowed
-
-For persistence, the entry keys and values are copied to disk. For overflow, 
only the entry values are copied. Other data, such as statistics and user 
attributes, are retained in memory only.
-
--   Data regions are overflowed to disk by least recently used (LRU) entries 
because those entries are deemed of least interest to the application and 
therefore less likely to be accessed.
--   Server subscription queues overflow most recently used (MRU) entries. 
These are the messages that are at the end of the queue and so are last in line 
to be sent to the client.
-
-## <a id="how_persist_overflow_work__section_1A3AE288145749058880D98C699FE124" 
class="no-quick-link"></a>Persistence
-
-Persistence provides a disk backup of region entry data. The keys and values 
of all entries are saved to disk, like having a replica of the region on disk. 
Region entry operations such as put and destroy are carried out in memory and 
on disk.
-
-<img src="../../images_svg/developing_persistence.svg" 
id="how_persist_overflow_work__image_B53E1A5A568D437692247A2FD99348A6" 
class="image" />
-
-When the member stops for any reason, the region data on disk remains. In 
partitioned regions, where data buckets are divided among members, this can 
result in some data only on disk and some on disk and in memory. The disk data 
can be used at member startup to populate the same region.
-
-## <a id="how_persist_overflow_work__section_55A7BBEB48574F649C40EB5D3E9CD0AC" 
class="no-quick-link"></a>Overflow
-
-Overflow limits region size in memory by moving the values of least recently 
used (LRU) entries to disk. Overflow basically uses disk as a swap space for 
entry values. If an entry is requested whose value is only on disk, the value 
is copied back up into memory, possibly causing the value of a different LRU 
entry to be moved to disk. As with persisted entries, overflowed entries are 
maintained on disk just as they are in memory.
-
-In this figure, the value of entry X has been moved to disk to make space in 
memory. The key for X remains in memory. From the distributed system 
perspective, the value on disk is as much a part of the region as the data in 
memory.
-
-<img src="../../images_svg/developing_overflow.svg" 
id="how_persist_overflow_work__image_1F89C9FBACB54EDA844778EC60F61B8D" 
class="image" />
-
-## <a id="how_persist_overflow_work__section_9CBEBC0B59554DB49CE4941435793C51" 
class="no-quick-link"></a>Persistence and Overflow Together
-
-Used together, persistence and overflow keep all entry keys and values on disk 
and only the most active entry values in memory. The removal of an entry value 
from memory due to overflow has no effect on the disk copy as all entries are 
already on disk.
-
-<img src="../../images_svg/developing_persistence_and_overflow.svg" 
id="how_persist_overflow_work__image_E40D9C2EA238406A991E954477C7EB78" 
class="image" />
-
-## Persistence and Multi-Site Configurations
-
-Multi-site gateway sender queues overflow most recently used (MRU) entries. 
These are the messages that are at the end of the queue and so are last in line 
to be sent to the remote site. You can also configure gateway sender queues to 
persist for high availability.
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/storing_data_on_disk/overflow_config_examples.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/storing_data_on_disk/overflow_config_examples.html.md.erb
 
b/geode-docs/developing/storing_data_on_disk/overflow_config_examples.html.md.erb
deleted file mode 100644
index 092ffee..0000000
--- 
a/geode-docs/developing/storing_data_on_disk/overflow_config_examples.html.md.erb
+++ /dev/null
@@ -1,53 +0,0 @@
----
-title:  Overflow Configuration Examples
----
-
-<!--
-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.
--->
-
-The `cache.xml` examples show configuration of region and server subscription 
queue overflows.
-
-<a id="overflow_config_examples__section_FD38DA72706245C996ACB7B23927F6AF"></a>
-Configure overflow criteria based on one of these factors:
-
--   Entry count
--   Absolute memory consumption
--   Memory consumption as a percentage of the application heap (not available 
for server subscription queues)
-
-Configuration of region overflow:
-
-``` pre
-<!-- Overflow when the region goes over 10000 entries -->
-<region-attributes>
-  <eviction-attributes>
-    <lru-entry-count maximum="10000" action="overflow-to-disk"/>
-  </eviction-attributes>
-</region-attributes>
-```
-
-Configuration of server's client subscription queue overflow:
-
-``` pre
-<!-- Overflow the server's subscription queues when the queues reach 1 Mb of 
memory -->
-<cache> 
-  <cache-server> 
-    <client-subscription eviction-policy="mem" capacity="1"/> 
-  </cache-server> 
-</cache>
-```
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/storing_data_on_disk/storing_data_on_disk.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/storing_data_on_disk/storing_data_on_disk.html.md.erb 
b/geode-docs/developing/storing_data_on_disk/storing_data_on_disk.html.md.erb
deleted file mode 100644
index 5da2f19..0000000
--- 
a/geode-docs/developing/storing_data_on_disk/storing_data_on_disk.html.md.erb
+++ /dev/null
@@ -1,79 +0,0 @@
----
-title:  Configure Region Persistence and Overflow
----
-
-<!--
-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.
--->
-
-Plan persistence and overflow for your data regions and configure them 
accordingly.
-
-<a id="storing_data_on_disk__section_E253562A46114CF0A4E47048D8143999"></a>
-Use the following steps to configure your data regions for persistence and 
overflow:
-
-1.  Configure your disk stores as needed. See [Designing and Configuring Disk 
Stores](../../managing/disk_storage/using_disk_stores.html#defining_disk_stores).
 The cache disk store defines where and how the data is written to disk.
-
-    ``` pre
-    <disk-store name="myPersistentStore" . . . >
-    <disk-store name="myOverflowStore" . . . >
-    ```
-
-2.  Specify the persistence and overflow criteria for the region. If you are 
not using the default disk store, provide the disk store name in your region 
attributes configuration. To write asynchronously to disk, specify 
`disk-synchronous="false"`.
-    -   For overflow, specify the overflow criteria in the region's 
`eviction-attributes` and name the disk store to use.
-
-        Example:
-
-        ``` pre
-        <region name="overflowRegion" . . . >
-          <region-attributes disk-store-name="myOverflowStore" 
disk-synchronous="true">
-            <eviction-attributes>
-              <!-- Overflow to disk when 100 megabytes of data reside in the
-                   region -->
-              <lru-memory-size maximum="100" action="overflow-to-disk"/>
-            </eviction-attributes>
-          </region-attributes>
-        </region>
-        ```
-
-        gfsh:
-
-        You cannot configure `lru-memory-size` using gfsh.
-    -   For persistence, set the `data-policy` to `persistent-replicate` and 
name the disk store to use.
-
-        Example:
-
-        ``` pre
-        <region name="partitioned_region" refid="PARTITION_PERSISTENT">
-          <region-attributes disk-store-name="myPersistentStore">
-            . . . 
-          </region-attributes>
-        </region> 
-        ```
-
-When you start your members, overflow and persistence will be done 
automatically, with the disk stores and disk write behaviors.
-
-**Note:**
-You can also configure Regions and Disk Stores using the gfsh command-line 
interface. See [Region 
Commands](../../tools_modules/gfsh/quick_ref_commands_by_area.html#topic_EF03119A40EE492984F3B6248596E1DD)
 and [Disk Store 
Commands](../../tools_modules/gfsh/quick_ref_commands_by_area.html#topic_1ACC91B493EE446E89EC7DBFBBAE00EA).
-
-<a id="storing_data_on_disk__section_0D825566F508444C98DFE57527962FED"></a>
-
-| Related Topics                                                               
         |
-|---------------------------------------------------------------------------------------|
-| `org.apache.geode.cache.RegionAttributes` for data region persistence 
information |
-| `org.apache.geode.cache.EvictionAttributes` for data region overflow 
information  |
-| `org.apache.geode.cache.server.ClientSubscriptionConfig`                     
     |
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/transactions/JTA_transactions.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/transactions/JTA_transactions.html.md.erb 
b/geode-docs/developing/transactions/JTA_transactions.html.md.erb
deleted file mode 100644
index e218684..0000000
--- a/geode-docs/developing/transactions/JTA_transactions.html.md.erb
+++ /dev/null
@@ -1,243 +0,0 @@
----
-title: JTA Global Transactions with Geode
----
-
-<!--
-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.
--->
-
-
-Use JTA global transactions to coordinate Geode cache transactions and JDBC 
transactions.
-
-JTA is a standard Java interface you can use to coordinate Geode cache 
transactions and JDBC transactions globally under one umbrella. JTA provides 
direct coordination between the Geode cache and another transactional resource, 
such as a database. The parties involved in a JTA transaction include:
-
--   The Java application, responsible for starting the global transaction
--   The JTA transaction manager, responsible for opening, committing, and 
rolling back transactions
--   The transaction resource managers, including the Geode cache transaction 
manager and the JDBC resource manager, responsible for managing operations in 
the cache and database respectively
-
-Using JTA, your application controls all transactions in the same standard 
way, whether the transactions act on the Geode cache, a JDBC resource, or both 
together. When a JTA global transaction is done, the Geode transaction and the 
database transaction are both complete.
-
-When using JTA global transactions with Geode, you have three options:
-
-1.  Coordinate with an external JTA transaction manager in a container (such 
as WebLogic or JBoss)
-2.  Set Geode as the “last resource” while using a container (such as 
WebLogic or JBoss) as the JTA transaction manager
-3.  Have Geode act as the JTA transaction manager
-
-An application creates a global transaction by using 
`javax.transaction.UserTransaction` bound to the JNDI context 
`java:/UserTransaction` to start and terminate transactions. During the 
transaction, cache operations are done through Geode as usual as described in 
[Geode Cache Transactions](cache_transactions.html#topic_e15_mr3_5k).
-
-**Note:**
-See the Sun documentation for more information on topics such as JTA, 
`javax.transaction`, committing and rolling back global transactions, and the 
related exceptions.
-
--   **[Coordinating with External JTA Transactions 
Managers](#concept_cp1_zx1_wk)**
-
-    Geode can work with the JTA transaction managers of several containers 
like JBoss, WebLogic, GlassFish, and so on.
-
--   **[Using Geode as the "Last Resource" in a Container-Managed JTA 
Transaction](#concept_csy_vfb_wk)**
-
-    The "last resource" feature in certain 3rd party containers such as 
WebLogic allow the use one non-XAResource (such as Geode) in a transaction with 
multiple XAResources while ensuring consistency.
-
--   **[Using Geode as the JTA Transaction Manager](#concept_8567sdkbigige)**
-
-    You can also use Geode as the JTA transaction manager.
-
--   **[Behavior of Geode Cache Writers and Loaders Under 
JTA](cache_plugins_with_jta.html)**
-
-    When Geode participates in a global transactions, you can still have Geode 
cache writers and cache loaders operating in the usual way.
-
--   **[Turning Off JTA Transactions](turning_off_jta.html)**
-
-    You can configure regions to not participate in any JTA global transaction.
-
-<a id="concept_cp1_zx1_wk"></a>
-
-# Coordinating with External JTA Transactions Managers
-
-Geode can work with the JTA transaction managers of several containers like 
JBoss, WebLogic, GlassFish, and so on.
-
-At startup Geode looks for a TransactionManager 
(`javax.transaction.TransactionManager`) that has been bound to its JNDI 
context. When Geode finds such an external transaction manager, all Geode 
region operations (such as get and put) will participate in global transactions 
hosted by this external JTA transaction manager.
-
-This figure shows the high-level operation of a JTA global transaction whose 
resources include a Geode cache and a database.
-
-<img src="../../images/transactions_jta_app_server.png" 
id="concept_cp1_zx1_wk__image_C2935E48415349659FC39BF5C7E75579" class="image" />
-
-An externally coordinated JTA global transaction is run in the following 
manner:
-
-1.  Each region operation looks up for presence of a global transaction. If 
one is detected, then a Geode transaction is started automatically, and we 
register a `javax.transaction.Synchronization` callback with the external JTA 
transaction manager.
-2.  At transaction commit, Geode gets a `beforeCommit()` callback from the 
external JTA transaction manager. Geode does all locking and conflict detection 
at this time. If this fails, an exception is thrown back to JTA transaction 
manager, which then aborts the transaction.
-3.  After a successful `beforeCommit()`callback, JTA transaction manager asks 
other data sources to commit their transaction.
-4.  Geode then gets a `afterCommit()` callback in which changes are applied to 
the cache and distributed to other members.
-
-You can disable JTA in any region that should not participate in JTA 
transactions. See [Turning Off JTA 
Transactions](turning_off_jta.html#concept_nw2_5gs_xk).
-
-## <a id="task_j3g_3mn_1l" class="no-quick-link"></a>How to Run a JTA 
Transaction Coordinated by an External Transaction Manager
-
-Use the following procedure to run a Geode global JTA transaction coordinated 
by an external JTA transaction manager.
-
-1.  **Configure the external data sources in the external container.** Do not 
configure the data sources in cache.xml . They are not guaranteed to get bound 
to the JNDI tree.
-2.  
-
-    Configure Geode for any necessary transactional behavior in the 
`cache.xml` file. For example, enable `copy-on-read` and specify a transaction 
listener, as needed. See [Setting Global Copy on 
Read](working_with_transactions.html#concept_vx2_gs4_5k) and [Configuring 
Transaction Plug-In Event 
Handlers](working_with_transactions.html#concept_ocw_vf1_wk) for details. 
-3.  
-
-    Make sure that JTA transactions are enabled for the regions that will 
participate in the transaction. See [Turning Off JTA 
Transactions](turning_off_jta.html#concept_nw2_5gs_xk) for details. 
-4.  
-
-     Start the transaction through the external container. 
-5.  
-
-    Initialize the Geode cache. Geode will automatically join the transaction. 
-6.  
-
-     Execute operations in the cache and the database as usual. 
-7.  
-
-     Commit the transaction through the external container. 
-
-<a id="concept_csy_vfb_wk"></a>
-
-# Using Geode as the "Last Resource" in a Container-Managed JTA Transaction
-
-The "last resource" feature in certain 3rd party containers such as WebLogic 
allow the use one non-XAResource (such as Geode) in a transaction with multiple 
XAResources while ensuring consistency.
-
-In the previous two JTA transaction use cases, if the Geode member fails after 
the other data sources commit but before Geode receives the `afterCommit` 
callback, Geode and the other data sources may become inconsistent. To prevent 
this from occurring, you can use the container's "last resource optimization" 
feature, with Geode set as the "last resource". Using Geode as the last 
resource ensures that in the event of failure, Geode remains consistent with 
the other XAResources involved in the transaction.
-
-To accomplish this, the application server container must use a JCA Resource 
Adapter to accomodate Geode as the transaction's last resource. The transaction 
manager of the container first issues a "prepare" message to the participating 
XAResources. If the XAResources all accept the transaction, then the manager 
issues a "commit" instruction to the non-XAResource (in this case, Geode). The 
non-XAResource (in this case, Geode) participates as a local transaction 
resource. If the non-XAResource fails, then the transaction manager can 
rollback the XAResources.
-
-<img src="../../images/transactions_jca_adapter.png" 
id="concept_csy_vfb_wk__image_opb_sgb_wk" class="image" />
-
-<a id="task_sln_x3b_wk"></a>
-
-# How to Run JTA Transactions with Geode as a "Last Resource"
-
-1.  Locate the `$GEMFIRE/lib/gemfire-jca.rar` file in your Geode installation. 
-2.  Add your container-specific XML file to the `gemfire-jca.rar` file. 
-<ol>
-<li>Create a container-specific resource adapter XML file named 
&lt;container&gt;-ra.xml. For example, an XML file for a WebLogic resource 
adapter XML file might look something like this:
-
-    ``` pre
-    <?xml version="1.0"?>
-    <!DOCTYPE weblogic-connection-factory-dd PUBLIC '-//BEA Systems, Inc.//DTD 
WebLogic 9.0.0 Connector//EN' 
-    'http://www.bea.com/servers/wls810/dtd/weblogic810-ra.dtd'>
-
-    <weblogic-connection-factory-dd>
-       <connection-factory-name>GFE JCA</connection-factory-name>
-       <jndi-name>gfe/jca</jndi-name>
-    </weblogic-connection-factory-dd>
-    ```
-</li>
-<li>Create a folder named `META-INF`, and place the container-specific XML 
file inside the directory. For example, the folder structure would look like 
this:
-
-    ``` pre
-    META-INF/weblogic-ra.xml
-    ```
-</li>
-<li>Navigate to the directory above the `META-INF` folder and execute the 
following command:
-
-    ``` pre
-    $ jar -uf <GEMFIRE_INSTALL_DIR>/lib/gemfire-jca.rar 
META-INF/weblogic-ra.xml
-    ```
-</li>
-</ol>
-3.  Make sure that `$GEMFIRE/lib/gemfire.jar` is accessible in the CLASSPATH 
of the JTA transaction coordinator container.
-4.  Deploy `gemfire-jca.rar` file on the JTA transaction coordinator container 
. When deploying the file, you specify the JNDI name and so on. 
-5.  Configure Geode for any necessary transactional behavior. Enable 
`copy-on-read` and specify a transaction listener, if you need one. See 
[Setting Global Copy on 
Read](working_with_transactions.html#concept_vx2_gs4_5k) and [Configuring 
Transaction Plug-In Event 
Handlers](working_with_transactions.html#concept_ocw_vf1_wk) for details.
-6.  Get an initial context through `com.gemstone.cache.Cache.getJNDIContext`. 
For example:
-
-    ``` pre
-    Context ctx = cache.getJNDIContext();
-    ```
-
-    This returns `javax.naming.Context` and gives you the JNDI associated with 
the cache. The context contains the `TransactionManager`, `UserTransaction`, 
and any configured JDBC resource manager.
-
-7.  Start and commit the global transaction using the `UserTransaction` object 
rather than with Geode's `CacheTransactionManager`. 
-
-    ``` pre
-    UserTransaction txManager = 
(UserTransaction)ctx.lookup("java:/UserTransaction");
-    ```
-
-8.  Obtain a Geode connection.
-
-    ``` pre
-    GFConnectionFactory cf = (GFConnectionFactory) ctx.lookup("gfe/jca");
-
-    //This step of obtaining connection is what begins the
-    //LocalTransaction.
-    //If this is absent, GFE operations will not be part of any
-    //transaction
-    GFConnection gemfireConn = (GFConnection)cf.getConnection();
-    ```
-
-See [JCA Resource Adapter 
Example](jca_adapter_example.html#concept_swv_z2p_wk) for an example of how to 
set up a transaction using the JCA Resource Adapter.
-
-## <a id="concept_8567sdkbigige" class="no-quick-link"></a>Using Geode as the 
JTA Transaction Manager
-
-You can also use Geode as the JTA transaction manager.
-
-Geode ships with its own implementation of a JTA transaction manager. However, 
note that this implementation is not XA-compliant; therefore, it does not 
persist any state, which could lead to an inconsistent state after recovering a 
crashed member.
-
-<img src="../../images/transactions_jta.png" 
id="concept_8567sdkbigige__image_C8D94070E55F4BCC8B5FF3D5BEBA99ED" 
class="image" />
-
-The Geode JTA transaction manager is initialized when the Geode cache is 
initialized. Until then, JTA is not available for use. The application starts a 
JTA transaction by using the `UserTransaction.begin` method. The 
`UserTransaction` object is the application’s handle to instruct the JTA 
transaction manager on what to do.
-
-The Geode JTA implementation also supports the J2EE Connector Architecture 
(JCA) `ManagedConnectionFactory`.
-
-The Geode implementation of JTA has the following limitations:
-
--   Only one JDBC database instance per transaction is allowed, although you 
can have multiple connections to that database.
--   Multiple threads cannot participate in a transaction.
--   Transaction recovery after a crash is not supported.
-
-In addition, JTA transactions are subject to the limitations of Geode cache 
transactions such as not being supported on regions with global scope. When a 
global transaction needs to access the Geode cache, JTA silently starts a Geode 
cache transaction.
-
-<a id="task_qjv_khb_wk"></a>
-
-# How to Run a JTA Global Transaction Using Geode as the JTA Transaction 
Manager
-
-This topic describes how to run a JTA global transaction in Geode .
-
-To run a global transaction, perform the following steps:
-
-1. Configure the external data sources in the `cache.xml` file. See 
[Configuring Database Connections Using 
JNDI](configuring_db_connections_using_JNDI.html#topic_A5E3A67C808D48C08E1F0DC167C5C494)
 for examples. 
-2. Include the JAR file for any data sources in your CLASSPATH. 
-3.  Configure Geode for any necessary transactional behavior. Enable 
`copy-on-read` for your cache and specify a transaction listener, if you need 
one. See [Setting Global Copy on 
Read](working_with_transactions.html#concept_vx2_gs4_5k) and [Configuring 
Transaction Plug-In Event 
Handlers](working_with_transactions.html#concept_ocw_vf1_wk) for details. 
-4.  Make sure that JTA transactions are not disabled in the `cache.xml` file 
or the application code. 
-5.  Initialize the Geode cache. 
-6.  Get an initial context through 
`org.apache.geode.cache.Cache.getJNDIContext`. For example: 
-
-    ``` pre
-    Context ctx = cache.getJNDIContext();
-    ```
-
-    This returns `javax.naming.Context` and gives you the JNDI associated with 
the cache. The context contains the `TransactionManager`, `UserTransaction`, 
and any configured JDBC resource manager.
-
-7.  Look up the `UserTransaction` context: 
-
-    ``` pre
-    UserTransaction txManager = (UserTransaction) 
ctx.lookup("java:/UserTransaction");
-    ```
-
-    With `UserTransaction`, you can begin, commit, and rollback transactions.
-    If a global transaction exists when you use the cache, it automatically 
joins the transaction. Operations on a region automatically detect and become 
associated with the existing global transaction through JTA synchronization. If 
the global transaction has been marked for rollback, however, the Geode cache 
is not allowed to enlist with that transaction. Any cache operation that causes 
an attempt to enlist throws a `FailedSynchronizationException`.
-
-    The Geode cache transaction’s commit or rollback is triggered when the 
global transaction commits or rolls back. When the global transaction is 
committed using the `UserTransaction` interface, the transactions of any 
registered JTA resources are committed, including the Geode cache transaction. 
If the cache or database transaction fails to commit, the `UserTransaction` 
call throws a `TransactionRolledBackException`. If a commit or rollback is 
attempted directly on a Geode transaction that is registered with JTA, that 
action throws an `IllegalStateException`.
-
-See [Geode JTA Transaction 
Example](transaction_jta_gemfire_example.html#concept_ffg_sj5_1l).
-
--   **[Configuring Database Connections Using 
JNDI](configuring_db_connections_using_JNDI.html)**
-
--   **[Example DataSource Configurations in 
cache.xml](configuring_db_connections_using_JNDI.html#topic_F67EC20067124A618A8099AB4CBF634C)**
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/transactions/about_transactions.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/transactions/about_transactions.html.md.erb 
b/geode-docs/developing/transactions/about_transactions.html.md.erb
deleted file mode 100644
index c0e3261..0000000
--- a/geode-docs/developing/transactions/about_transactions.html.md.erb
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title: About Transactions
----
-
-<!--
-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.
--->
-
-<a id="topic_jbt_2y4_wk"></a>
-
-
-This section covers the features of Geode transactions.
-
-Geode transactions provide the following features:
-
--   Basic transaction properties: atomicity, consistency, isolation, and 
durability
--   Rollback and commit operations along with standard Geode cache operations
--   Ability to suspend and resume transactions
--   High concurrency and high performance
--   Transaction statistics gathering and archiving
--   Compatibility with Java Transaction API (JTA) transactions, using either 
Geode JTA or a third-party implementation
--   Ability to use Geode as a “last resource” in JTA transactions with 
multiple data sources to guarantee transactional consistency
-
-## Types of Transactions
-
-Geode supports two kinds of transactions: **Geode cache transactions** and 
**JTA global transactions**.
-
-Geode cache transactions are used to group the execution of cache operations 
and to gain the control offered by transactional commit and rollback. 
Applications create cache transactions by using an instance of the Geode 
`CacheTransactionManager`. During a transaction, cache operations are performed 
and distributed through Geode as usual. See [Geode Cache 
Transactions](cache_transactions.html#topic_e15_mr3_5k) for details on Geode 
cache transactions and how these transactions work.
-
-JTA global transactions allow you to use the standard JTA interface to 
coordinate Geode transactions with JDBC transactions. When performing JTA 
global transactions, you have the option of using Geode’s own implementation 
of JTA or a third party’s implementation (typically application servers such 
as WebLogic or JBoss) of JTA. In addition, some third party JTA implementations 
allow you to set Geode as a “last resource” to ensure transactional 
consistency across data sources in the event that Geode or another data source 
becomes unavailable. For global transactions, applications use 
`java:/UserTransaction` to start and terminate transactions while Geode cache 
operations are performed in the same manner as regular Geode cache 
transactions. See [JTA Global Transactions with Geode](JTA_transactions.html) 
for details on JTA Global transactions.
-
-You can also coordinate a Geode cache transaction with an external database by 
specifying database operations within cache and transaction application 
plug-ins (CacheWriters/CacheListeners and 
TransactionWriters/TransactionListeners.) This is an alternative to using JTA 
transactions. See [How to Run a Geode Cache Transaction that Coordinates with 
an External 
Database](run_a_cache_transaction_with_external_db.html#task_sdn_2qk_2l).
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/transactions/cache_plugins_with_jta.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/transactions/cache_plugins_with_jta.html.md.erb 
b/geode-docs/developing/transactions/cache_plugins_with_jta.html.md.erb
deleted file mode 100644
index 7735bf0..0000000
--- a/geode-docs/developing/transactions/cache_plugins_with_jta.html.md.erb
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title:  Behavior of Geode Cache Writers and Loaders Under JTA
----
-
-<!--
-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.
--->
-
-When Geode participates in a global transactions, you can still have Geode 
cache writers and cache loaders operating in the usual way.
-
-For example, in addition to the transactional connection to the database, the 
region could also have a cache writer and cache loader configured to exchange 
data with that same database. As long as the data source is transactional, 
which means that it can detect the transaction manager, the cache writer and 
cache loader participate in the transaction. If the JTA rolls back its 
transaction, the changes made by the cache loader and the cache writer are 
rolled back. For more on transactional data sources, see the discussion of 
XAPooledDataSource and ManagedDataSource in[Configuring Database Connections 
Using 
JNDI](configuring_db_connections_using_JNDI.html#topic_A5E3A67C808D48C08E1F0DC167C5C494).
-
-If you are using a Geode cache or transaction listener with global 
transactions, be aware that the EntryEvent returned by a transaction has the 
Geode transaction ID, not the JTA transaction ID.
-
-

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/84cfbdfc/geode-docs/developing/transactions/cache_transaction_performance.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/transactions/cache_transaction_performance.html.md.erb 
b/geode-docs/developing/transactions/cache_transaction_performance.html.md.erb
deleted file mode 100644
index 5f25453..0000000
--- 
a/geode-docs/developing/transactions/cache_transaction_performance.html.md.erb
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title:  Cache Transaction Performance
----
-
-<!--
-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.
--->
-
-Cache transaction performance can vary depending on the type of regions you 
are using.
-
-The most common region configurations for use with transactions are 
distributed replicated and partitioned:
-
--   Replicated regions are better suited for running transactions on small to 
mid-size data sets. To ensure all or nothing behavior, at commit time, 
distributed transactions use the global reservation system of the Geode 
distributed lock service. This works well as long as the data set is reasonably 
small.
--   Partitioned regions are the right choice for highly-performant, scalable 
operations. Transactions on partitioned regions use only local locking, and 
only send messages to the redundant data stores at commit time. Because of 
this, these transactions perform much better than distributed transactions. 
There are no global locks, so partitioned transactions are extremely scalable 
as well.
-
-


Reply via email to