GEODE-6210: Native Client User Guide - document transaction examples (#467)
* GEODE-6210: Native Client User Guide - document transaction examples
diff --git a/BUILDING.md b/BUILDING.md
index 5d258af..67745ef 100644
--- a/BUILDING.md
+++ b/BUILDING.md
@@ -8,10 +8,12 @@
* [Apache Geode](http://geode.apache.org/releases/) binaries installed or available to link against
### Platform-Specific Prerequisites
-* [Mac OS X](#mac-os-x)
-* [Linux](#linux)
-* [Solaris](#solaris)
+
* [Windows](#windows)
+* [Linux](#linux)
+* [Mac OS X](#mac-os-x)
+* [Solaris](#solaris)
+
## Setting Path to Geode
Building requires access to an installation of Geode. There are two ways to achieve this:
@@ -23,6 +25,7 @@
## Steps to build
+
```console
$ cd <clone>
$ mkdir build
@@ -40,13 +43,15 @@
#### CLion / Eclipse / Other
The recommended generator for most unix platforms is 'Makefiles' (default):
+
```console
$ cmake ..
```
#### Xcode
The recommended generator for Xcode is `Xcode`:
-```console
+
+```bash
$ cmake .. -G "Xcode"
```
@@ -54,6 +59,7 @@
When running cmake commands on Windows, be sure to use [Visual Studio Native Tools Command Prompt](https://msdn.microsoft.com/en-us/library/f35ctcxw.aspx) so environment variables are set properly.
The recommended generator on Windows is `Visual Studio 14 2015 Win64`:
+
```console
$ cmake .. -G "Visual Studio 14 2015 Win64" -Thost=x64
```
@@ -62,11 +68,13 @@
For faster builds, use optional parallelism parameters in the last build step:
#### Unix
+
```console
$ cmake --build . -- -j <# of jobs>
```
#### Windows
+
```console
$ cmake --build . -- /m
```
@@ -76,10 +84,12 @@
#### Code Coverage
If building with GCC or Clang you can enable C++ code coverage by adding `-DUSE_CPP_COVERAGE=ON` to the CMake [Generator](#generator) command.
+
```console
$ cmake … -DUSE_CPP_COVERAGE=ON …
```
You can then generate a C++ code coverage report by downloading [lcov](http://ltp.sourceforge.net/coverage/lcov.php). After acquiring lcov, finish the [Steps to build](#Steps-to-build) section above. Then, run the tests as described in the [CONTRIBUTING.md](CONTRIBUTING.md). Finally, run the following commands from the `build` directory:
+
```console
$ lcov --capture --directory . --output-file coverage.info
$ genhtml coverage.info --output-directory coverage_report
@@ -89,15 +99,18 @@
#### Clang-Tidy
To enable `clang-tidy`:
+
```console
$ cmake … -DCMAKE_CXX_CLANG_TIDY=clang-tidy …
```
To use specific `clang-tidy`:
+
```console
$ cmake … -DCMAKE_CXX_CLANG_TIDY=/path/to/clang-tidy …
```
By default `clang-tidy` uses the configuration found in `.clang-tidy`
To override `clang-tidy` options:
+
```console
$ cmake … -DCMAKE_CXX_CLANG_TIDY=clang-tidy;<options> …
```
@@ -119,7 +132,31 @@
# Platform-Specific Prerequisites
-## Mac OS X
+## <a id="windows"></a>Windows
+* Windows 8.1 64-bit
+* Windows 10 64-bit
+* Windows Server 2012 R2 64-bit
+* Windows Server 2016 64-bit
+
+### Required Tools
+* [Visual Studio 2015](https://www.visualstudio.com) or newer
+* .NET 4.5.2 or later
+* Chocolately
+* [Other dependencies installed via Powershell](packer/windows/install-dependencies.ps1)
+
+## <a id="linux"></a>Linux
+* RHEL/CentOS 6
+* RHEL/CentOS 7
+* SLES 11
+* SLES 12
+
+### Required Tools
+* [GCC 5](https://gcc.gnu.org) or newer
+
+### Optional Tools
+* [Eclipse CDT 8.8](https://eclipse.org/cdt/) or newer
+
+## <a id="mac-os-x"></a>Mac OS X
* Mac OS X 10.12 (Sierra) or newer
* Xcode 8.2 or newer
@@ -135,31 +172,7 @@
* [Doxygen GUI](http://ftp.stack.nl/pub/users/dimitri/Doxygen-1.8.11.dmg)
* [CLion](https://www.jetbrains.com/clion/)
-## Windows
-* Windows 8.1 64-bit
-* Windows 10 64-bit
-* Windows Server 2012 R2 64-bit
-* Windows Server 2016 64-bit
-
-### Required Tools
-* [Visual Studio 2015](https://www.visualstudio.com) or newer
-* .NET 4.5.2 or later
-* Chocolately
-* [Other dependencies installed via Powershell](packer/windows/install-dependencies.ps1)
-
-## Linux
-* RHEL/CentOS 6
-* RHEL/CentOS 7
-* SLES 11
-* SLES 12
-
-### Required Tools
-* [GCC 5](https://gcc.gnu.org) or newer
-
-### Optional Tools
-* [Eclipse CDT 8.8](https://eclipse.org/cdt/) or newer
-
-## Solaris
+## <a id="solaris"></a>Solaris
* Solaris 11 SPARC
* Solaris 11 x86
diff --git a/docs/geode-native-book/master_middleman/source/subnavs/geode-nc-nav.erb b/docs/geode-native-book/master_middleman/source/subnavs/geode-nc-nav.erb
index dda6d7b..ed5cf39 100644
--- a/docs/geode-native-book/master_middleman/source/subnavs/geode-nc-nav.erb
+++ b/docs/geode-native-book/master_middleman/source/subnavs/geode-nc-nav.erb
@@ -91,7 +91,7 @@
</li>
<li>
- <a href="/docs/geode-native/<%=vars.product_version_nodot%>/transactions/transactions.html">Transactions</a>
+ <a href="/docs/geode-native/<%=vars.product_version_nodot%>/transactions.html">Transactions</a>
</li>
<li>
<a href="/docs/geode-native/<%=vars.product_version_nodot%>/configuring/sysprops.html">System Properties</a>
diff --git a/docs/geode-native-docs/common/images/xact-run-from-client.gif b/docs/geode-native-docs/common/images/xact-run-from-client.gif
deleted file mode 100644
index 4fe2d26..0000000
--- a/docs/geode-native-docs/common/images/xact-run-from-client.gif
+++ /dev/null
Binary files differ
diff --git a/docs/geode-native-docs/function-execution.html.md.erb b/docs/geode-native-docs/function-execution.html.md.erb
index 010d07a..df1d98d 100644
--- a/docs/geode-native-docs/function-execution.html.md.erb
+++ b/docs/geode-native-docs/function-execution.html.md.erb
@@ -21,7 +21,7 @@
A client can invoke a server-resident function, with parameters, and can collect and operate on the returned results.
-## <a id="server_side_requirements"></a>Server-side Requirements
+## <a id="nc-fe-server_side_requirements"></a>Server-side Requirements
To be callable from your client, a function must be
@@ -31,11 +31,11 @@
See [Executing a Function in <%=vars.product_name_long%>](serverman/developing/function_exec/function_execution.html)
in the <%=vars.product_name%> User Guide for details on how to write and register server-resident functions.
-## <a id="client_side_requirements"></a>Client-side Requirements
+## <a id="nc-fe-client_side_requirements"></a>Client-side Requirements
The client must connect to the server through a connection pool in order to invoke a server-side function.
-## <a id="how_functions_execute"></a>How Functions Execute
+## <a id="nc-fe-how_functions_execute"></a>How Functions Execute
1. The calling client application runs the `execute` method on the `Execution` object. The function must already be registered on the servers.
2. The function is invoked on the servers where it needs to run. The servers are determined by the `FunctionService on*`
@@ -59,7 +59,7 @@
- Call the `Execution.execute()` method to run the function.
-## <a id="processing_function_results"></a>Processing Function Results
+## <a id="nc-fe-processing_function_results"></a>Processing Function Results
To get the results from the function in the client app, use the result collector returned from the function execution.
The `getResult` methods of the default result collector block until all results are received, then return the full result set.
@@ -75,11 +75,11 @@
- `clearResults` is called to clear partial results from the results collector. This is used only for highly available `onRegion` functions where the calling application waits for the results. If the call fails, before <%=vars.product_name%> retries the execution, it calls `clearResults` to ready the instance for a clean set of results.
2. Use the `Execution` object in your executing member to call `withCollector`, passing your custom collector.
-# <a id="examples"></a>Examples
+## <a id="nc-fe-examples"></a>Function Execution Examples
The native client release contains examples of function execution written for .NET and
C++. The examples are located in `../examples/dotnet/functionexecution` and
-`../examples/cpp/function-execution`, respectively.
+`../examples/cpp/functionexecution`, respectively.
The two examples share some common elements:
@@ -105,7 +105,7 @@
The C++ example creates a result variable to hold the results from the collector.
-## <a id="dotnet_example"></a>.NET Example
+### <a id="nc-fe-dotnet_example"></a>.NET Example
This section contains code snippets showing highlights of the .NET function execution example. They are not intended for cut-and-paste execution.
For the complete source, see the example source directory.
@@ -189,7 +189,7 @@
}
```
-## <a id="cpp_example"></a>C++ Example
+### <a id="nc-fe-cpp_example"></a>C++ Example
This section contains code snippets showing highlights of the C++ function execution example. They are not intended for cut-and-paste execution.
For the complete source, see the example source directory.
diff --git a/docs/geode-native-docs/transactions.html.md.erb b/docs/geode-native-docs/transactions.html.md.erb
new file mode 100644
index 0000000..150c5a8
--- /dev/null
+++ b/docs/geode-native-docs/transactions.html.md.erb
@@ -0,0 +1,197 @@
+---
+title: 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.
+-->
+
+The Native Client API provides a server delegate that runs transactions on the server as if they were local to the client application.
+Thus, the key to running client transactions lies in making sure the server is properly configured and programmed.
+For complete information about how transactions are conducted on the <%=vars.product_name%> server, see the
+[Transactions section of the <%=vars.product_name%> User Guide](geodeman/developing/transactions/chapter_overview.html).
+
+## <a id="client-transaction-apis"></a>Native Client Transaction APIs
+
+The API for distributed transactions has the familiar relational database methods, `begin`,
+`commit`, and `rollback`. There are also APIs available to suspend and resume transactions.
+
+The .NET classes for executing transactions are:
+
+- `Apache.Geode.Client.CacheTransactionManager`
+- `Apache.Geode.Client.TransactionId`
+
+The C++ classes for executing transactions are:
+
+- `apache.geode.client.CacheTransactionManager`
+- `apache.geode.client.TransactionId`
+
+## <a id="running-nc-transactions"></a>Running Native Client Transactions
+
+The syntax for writing client transactions is the same as with server or peer transactions, but when
+a client performs a transaction, the transaction is delegated to a server that brokers the
+transaction.
+
+Start each transaction with a `begin` operation, and end the transaction with a `commit` or a `rollback`.
+
+To maintain cache consistency, the local client cache is blocked during a transaction, as it may
+reflect information inconsistent with the transaction in progress. When the transaction completes or
+is suspended, the block is removed.
+
+If the transaction runs on server regions that are a mix of partitioned and replicated regions,
+perform the first transaction operation on a partitioned region. This sets the server data host for
+the entire transaction. If you are using PR single-hop, single-hop will be applied as usual to this
+first operation.
+
+In addition to the failure conditions common to all transactions, client transactions can also fail
+if the transaction delegate fails. If the delegate performing the transaction fails, the transaction
+code throws a `TransactionException`.
+
+## <a id="nc-transaction-examples"></a>Client Transaction Examples
+
+The native client release contains transaction examples written for .NET and C++. The examples are
+located in `../examples/dotnet/transaction` and `../examples/cpp/transaction`, respectively.
+
+Both examples perform the same sequence of operations, displaying simple log entries as they run.
+
+- To run an example, follow the instructions in the `README.md` file in the example directory.
+- Review the source code in the example directory to see exactly how it operates.
+
+- You begin by running a script that sets up the servers-side environment by invoking `gfsh` commands to create a region, simply called "exampleRegion".
+
+- You run the example client application, which performs the following steps:
+
+ - Connects to the server
+ - Begins a transaction
+ - Performs some `put` operations
+ - Commits the transaction
+
+- For this example, the transaction code has these characteristics:
+
+ - To introduce the possibility of failure, values are randomized from 0 to 9, and the 0 values are
+treated as unsuccessful. The transaction is retried until it succeeds.
+
+ - In case the transaction repeatedly fails, the retry loop uses a counter to set a limit of 5 retries.
+
+
+### <a id="dotnet-example"></a>.NET Example
+
+This section contains code snippets showing highlights of the .NET transaction example. They are not intended for cut-and-paste execution.
+For the complete source, see the example source directory.
+
+The .NET example creates a cache, then uses it to create a connection pool.
+
+```csharp
+ var cache = new CacheFactory()
+ .Set("log-level", "none").Create();
+
+ var poolFactory = cache.GetPoolFactory()
+ .AddLocator("localhost", 10334);
+
+ poolFactory.Create("pool");
+
+ var regionFactory = cache.CreateRegionFactory(RegionShortcut.PROXY)
+ .SetPoolName("pool");
+ var region = regionFactory.Create<string, int>("exampleRegion");
+```
+
+The example application gets a transaction manager from the cache and begins a transaction.
+
+```csharp
+ cache.CacheTransactionManager.Begin();
+```
+
+Within the transaction, the client populates data store with 10 values associated with Key1 - Key10.
+
+```csharp
+ foreach(var key in keys)
+ {
+ var value = getValueFromExternalSystem();
+ region.Put(key, value);
+ }
+```
+
+If all `put` operations succeed, the application commits the transaction. Otherwise, it retries up to 5 times if necessary.
+
+```csharp
+ var retries = 5;
+ while(retries-- > 0)
+ {
+ try
+ {
+ ... // PUT OPERATIONS ...
+ cache.CacheTransactionManager.Commit();
+ Console.WriteLine("Committed transaction - exiting");
+ break;
+ } catch
+ {
+ cache.CacheTransactionManager.Rollback();
+ Console.WriteLine("Rolled back transaction - retrying({0})", retries);
+ }
+ }
+```
+
+### <a id="cpp-example"></a>C++ Example
+
+This section contains code snippets showing highlights of the C++ transaction example. They are not intended for cut-and-paste execution.
+For the complete source, see the example source directory.
+
+The C++ example creates a cache, then uses it to create a connection pool.
+
+```cpp
+ auto cache = CacheFactory().set("log-level", "none").create();
+ auto poolFactory = cache.getPoolManager().createFactory();
+
+ poolFactory.addLocator("localhost", 10334);
+ auto pool = poolFactory.create("pool");
+ auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
+ auto region = regionFactory.setPoolName("pool").create("exampleRegion");
+```
+
+The example application gets a transaction manager from the cache and begins a transaction.
+
+```cpp
+ auto transactionManager = cache.getCacheTransactionManager();
+
+ transactionManager->begin();
+```
+
+Within the transaction, the client populates data store with 10 values associated with Key1 - Key10.
+
+```cpp
+ for (auto& key : keys) {
+ auto value = getValueFromExternalSystem();
+ region->put(key, value);
+ }
+```
+
+If all `put` operations succeed, the application commits the transaction. Otherwise, it retries up to 5 times if necessary.
+
+```cpp
+ auto retries = 5;
+ while (retries--) {
+ try {
+ transactionManager->begin();
+ ... // PUT OPERATIONS ...
+ transactionManager->commit();
+ std::cout << "Committed transaction - exiting" << std::endl;
+ break;
+ } catch ( ... ) {
+ transactionManager->rollback();
+ std::cout << "Rolled back transaction - retrying(" << retries << ")" << std::endl;
+ }
+ }
+```
diff --git a/docs/geode-native-docs/transactions/how-client-xacts-work.html.md.erb b/docs/geode-native-docs/transactions/how-client-xacts-work.html.md.erb
deleted file mode 100644
index 7a2737e..0000000
--- a/docs/geode-native-docs/transactions/how-client-xacts-work.html.md.erb
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: How Client Transactions 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.
--->
-
-The syntax for writing client transactions is the same as with server or peer transactions, but when a client performs a transaction, the transaction is delegated to a server that brokers the transaction.
-
-## <a id="how-native-client-xacts-work__section_C804F1FE5BDF49CEA037AA589BBF284E" class="no-quick-link"></a>Role of Server Delegates in Transactions
-
-The client can run transactions on the Java cache server, using a server delegate to actually run the transaction code.
-
-For information on transaction requirements and activities on the
-server side, see the server documentation at
-[Transactions](geodeman/developing/transactions/chapter_overview.html).
-
-**Note:**
-The client cache blocks until the transaction is successfully committed.
-However, the block is removed if the transaction is suspended.
-
-Depending on where the data resides, the server transaction delegate may or not be the same member that hosts the transaction. This is the same as for transactions run by the servers, but for server-run transactions, there is no delegate. There is just the member that is directly running its own transaction code.
-
-In this figure, the application code on the client makes changes to data entries Y and Z within a transaction. The server delegate that performs the transaction, M1, does not host the primary copy of the data being modified. The transaction takes place on server M2, where the data resides.
-
-<a id="how-native-client-xacts-work__fig_7E408D84E18C452683077528756E31C3"></a>
-<span class="figtitleprefix">Figure: </span>Transaction Run From a Client
-
-<img src="../common/images/xact-run-from-client.gif" id="how-native-client-xacts-work__image_E9ED33166A994014942ABAD9E6F61755" class="image" />
-
-To maintain cache consistency, the local client cache is not accessible during a transaction as it may reflect information inconsistent with the transaction in progress. When the transaction completes, the local cache is accessible again.
-
-In addition to the failure conditions common to all transactions, client transactions can also fail if the transaction delegate fails. If the delegate performing the transaction fails, the transaction code throws a `TransactionException`.
-
-## <a id="how-native-client-xacts-work__section_434BA87403C1449FADC3E7796E30F3C7" class="no-quick-link"></a>Client Transaction APIs
-
-The API for distributed transactions has the familiar relational database methods, `begin`, `commit`, and `rollback`. There are also APIs available to suspend and resume transactions.
-
-The .NET classes for executing transactions are:
-
-- Apache.Geode.Client.CacheTransactionManager
-- Apache.Geode.Client.TransactionId
diff --git a/docs/geode-native-docs/transactions/running-client-xact.html.md.erb b/docs/geode-native-docs/transactions/running-client-xact.html.md.erb
deleted file mode 100644
index 07f99a4..0000000
--- a/docs/geode-native-docs/transactions/running-client-xact.html.md.erb
+++ /dev/null
@@ -1,90 +0,0 @@
----
-title: Running a Transaction
----
-
-<!--
-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.
--->
-
-Before you can run a transaction, you must configure your clients and servers, define your server regions for your transactions, and define your client regions.
-
-1. Retrieve the transaction manager.
-
- **C++ example**
-
- ``` pre
- std::shared_ptr<CacheTransactionManager> txManager =
- cache->getTransactionManager();
- ```
-
- **C\# .NET example**
-
- ``` pre
- CacheTransactionManager txManager =
- cache.CacheTransactionManager;
- ```
-
-2. Run the transaction. (Detailed steps follow the examples.)
-
- **C++ example**
-
- ``` pre
- TransactionId& tid;
- txManager->begin();
- // ..do work
- tid = txManager->suspend();
- // following code can be run from another
- // thread that has access to tid
- try {
- txManager->resume(tid);
- // ..do work
- tid = txManager->commit();
- } catch (const CommitConflictException& e) {
- // ..on exception
- }
- ```
-
- **C\# .NET example**
-
- ``` pre
- TransactionId tid;
- txManager.Begin();
- // ..do work
- tid = txManager.Suspend();
- // following code can be run from another
- // thread that has access to tid
- try {
- txManager.Resume(tid);
- // ..do work
- txManager.Commit();
- } catch (CommitConflictException e)
- ```
- - Start each transaction with a `begin` operation.
- - If the transaction runs on server regions that are a mix of partitioned and replicated regions, perform the first transaction operation on a partitioned region. This sets the server data host for the entire transaction. If you are using PR single-hop, single-hop will be applied as usual to this first operation.
- - Run the operations that you want included in the transaction.
- - End the transaction with a `commit` or a `rollback`.
- **Note:**
- Do not leave any transaction in an uncommitted and unrolled back state unless you have suspended the transaction. Transactions that have not been explicitly suspended do not time out, so will remain in the system for the life of your application.
-
-3. Review all of your client code for compatibility with transactions.
-
-When you commit a transaction, while the commit is taking place, the changes are visible in the cache. This is also known as transition commits. This provides better performance than locking everything to do the transaction updates, but it means that another process accessing data used in the transaction might get some data in the pre-transaction state and some in the post-transaction state.
-
-For example, keys 1 and 2 are written to in a transaction so both of their values change from A to B. In another thread, it is possible to read key 1 with value B and key 2 with value A, while the transaction is being committed. This can happen because of how <%=vars.product_name%> performs reads. This choice sacrifices atomic visibility in favor of performance. Reads do not block writes. Writes do not block reads.
-
-Because the client cache waits during transaction execution, and client regions are not distributed, the only activities that interact with a client transaction are those that occur on the server.
-
-
diff --git a/docs/geode-native-docs/transactions/suspend-resume-xacts.html.md.erb b/docs/geode-native-docs/transactions/suspend-resume-xacts.html.md.erb
deleted file mode 100644
index 3c7d821..0000000
--- a/docs/geode-native-docs/transactions/suspend-resume-xacts.html.md.erb
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: Suspending and Resuming 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.
--->
-
-The ability to suspend and resume transactions is useful when a thread must perform operations that should not be part of the transaction before the transaction can complete.
-
-When a transaction is suspended, it loses the transactional view of the cache. None of the previous operations (before calling suspend) are visible to the thread. Subsequently any operations that are performed by the thread do not participate in the suspended transaction.
-
-When a transaction is resumed, the resuming thread assumes the transactional view. A transaction that is suspending on a member must be resumed on the same member. Before resuming a transaction, you may want to check if the transaction exists on the member and whether it is suspended. You may optionally use the `tryResume` method.
-
-If the member with the primary copy of the data crashes, the transactional view that applied to that data is lost. The secondary member for the data cannot resume transactions suspended on the crashed member. You need to take remedial steps to retry the transaction on a new primary copy of the data.
-
-If a suspended transaction is not touched for a period of time, <%=vars.product_name%> cleans it up automatically. By default, the timeout for a suspended transaction is 30 minutes and can be configured by using the `suspended-tx-timeout` property of the `geode.properties` file. The suspended transaction timeout value is specified in milliseconds.
-
-See [Running a Client Transaction](running-client-xact.html) for code examples that show a how to suspend and resume a transaction.
-
-
diff --git a/docs/geode-native-docs/transactions/transactions.html.md.erb b/docs/geode-native-docs/transactions/transactions.html.md.erb
deleted file mode 100644
index f88f950..0000000
--- a/docs/geode-native-docs/transactions/transactions.html.md.erb
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: 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.
--->
-
-Client transactions run on the server tier. The client uses a server delegate
-that runs the transaction as it would a local transaction.
-Thus, the key to running client transactions lies in making sure the server
-is properly configured and programmed.
-For complete information about transactions in the <%=vars.product_name%> server,
-see the server documentation at
-[Transactions](geodeman/developing/transactions/chapter_overview.html).
-It provides detailed information including server data requirements,
-interactions of transactions with other operations running on the server tier,
-server-side application plug-ins with transactions,
-and querying with transactions.
-
diff --git a/examples/BUILD-EXAMPLES.md b/examples/BUILD-EXAMPLES.md
index 9455b3a..2e8a99a 100644
--- a/examples/BUILD-EXAMPLES.md
+++ b/examples/BUILD-EXAMPLES.md
@@ -27,12 +27,14 @@
**For Windows:** Include options that specify the generator, the architecture toolset, and the path to the Geode Native installation:
- $ cd workspace\examples\
- $ mkdir build
- $ cd build
- $ cmake .. -G"Visual Studio 15 2017 Win64" -DGeodeNative_ROOT="<geode-native-install-dir>"
- $ cmake --build . -- <optional parallelism parameter>
-
+ ```
+ $ cd workspace\examples\
+ $ mkdir build
+ $ cd build
+ $ cmake .. -G"Visual Studio 15 2017 Win64" -DGeodeNative_ROOT="<geode-native-install-dir>"
+ $ cmake --build . -- <optional parallelism parameter>
+ ```
+
## Running the Examples
To run an example,
diff --git a/examples/cpp/transaction/README.md b/examples/cpp/transaction/README.md
index 6dc88ca..af0fb37 100644
--- a/examples/cpp/transaction/README.md
+++ b/examples/cpp/transaction/README.md
@@ -37,14 +37,17 @@
$ ./startserver.sh
```
-3. Execute `cpp-transaction`, expect the following output:
+3. Execute `cpp-transaction`. Expect the following output:
+ ```bash
+ $ ./cpp-transaction
Created cache
Created region 'exampleRegion'
Rolled back transaction - retrying(4)
Rolled back transaction - retrying(3)
Rolled back transaction - retrying(2)
Committed transaction - exiting
+ ```
4. Run the `stopserver` script to gracefully shutdown the Geode cluster.
