560 lines
22 KiB
HTML
560 lines
22 KiB
HTML
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
||
<html xmlns="http://www.w3.org/1999/xhtml">
|
||
<head>
|
||
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
|
||
<title>Example Processing Loop</title>
|
||
<link rel="stylesheet" href="gettingStarted.css" type="text/css" />
|
||
<meta name="generator" content="DocBook XSL Stylesheets V1.62.4" />
|
||
<link rel="home" href="index.html" title="Getting Started with Replicated Berkeley DB Applications" />
|
||
<link rel="up" href="fwrkmasterreplica.html" title="Chapter 4. Replica versus Master Processes" />
|
||
<link rel="previous" href="processingloop.html" title="Processing Loop" />
|
||
<link rel="next" href="addfeatures.html" title="Chapter 5. Additional Features" />
|
||
</head>
|
||
<body>
|
||
<div class="navheader">
|
||
<table width="100%" summary="Navigation header">
|
||
<tr>
|
||
<th colspan="3" align="center">Example Processing Loop</th>
|
||
</tr>
|
||
<tr>
|
||
<td width="20%" align="left"><a accesskey="p" href="processingloop.html">Prev</a> </td>
|
||
<th width="60%" align="center">Chapter 4. Replica versus Master Processes</th>
|
||
<td width="20%" align="right"> <a accesskey="n" href="addfeatures.html">Next</a></td>
|
||
</tr>
|
||
</table>
|
||
<hr />
|
||
</div>
|
||
<div class="sect1" lang="en" xml:lang="en">
|
||
<div class="titlepage">
|
||
<div>
|
||
<div>
|
||
<h2 class="title" style="clear: both"><a id="exampledoloop"></a>Example Processing Loop</h2>
|
||
</div>
|
||
</div>
|
||
<div></div>
|
||
</div>
|
||
<p>
|
||
In this section we take the example
|
||
processing loop that we presented in the
|
||
previous section and we flesh it out to
|
||
provide a more complete example. We do this
|
||
by updating the
|
||
<tt class="function">doloop()</tt>
|
||
function that our original transaction
|
||
application used
|
||
|
||
|
||
<span>(see <a href="simpleprogramlisting.html#doloop_java">Method: SimpleTxn.doloop()</a>)</span>
|
||
to fully support our replicated application.
|
||
</p>
|
||
<p>
|
||
In the following example code, code that we
|
||
add to the original example is presented in
|
||
<b class="userinput"><tt>bold</tt></b>.
|
||
</p>
|
||
<p>
|
||
To begin, we must implement a way to track whether
|
||
our application is running as a master or a client.
|
||
There are many ways to do this, but in this case
|
||
what we will do is extend
|
||
<tt class="classname">com.sleepycat.db.Environment</tt>
|
||
to carry the information. We do this by creating
|
||
the <tt class="classname">RepQuoteEnvironment</tt>
|
||
class.
|
||
</p>
|
||
<pre class="programlisting">
|
||
<b class="userinput">
|
||
<tt>package db.repquote;
|
||
|
||
import com.sleepycat.db.DatabaseException;
|
||
import com.sleepycat.db.Environment;
|
||
import com.sleepycat.db.EnvironmentConfig;
|
||
|
||
public class RepQuoteEnvironment extends Environment
|
||
{
|
||
private boolean isMaster;
|
||
|
||
public RepQuoteEnvironment(final java.io.File host,
|
||
EnvironmentConfig config)
|
||
throws DatabaseException, java.io.FileNotFoundException
|
||
{
|
||
super(host, config);
|
||
isMaster = false;
|
||
}
|
||
|
||
boolean getIsMaster()
|
||
{
|
||
return isMaster;
|
||
}
|
||
|
||
public void setIsMaster(boolean isMaster)
|
||
{
|
||
this.isMaster = isMaster;
|
||
}
|
||
} </tt>
|
||
</b>
|
||
</pre>
|
||
<p>
|
||
Next, we go to <tt class="filename">RepQuoteExample.java</tt> and
|
||
we include the
|
||
<tt class="classname">RepQuoteEnvironment</tt> class
|
||
as well as the
|
||
<tt class="classname">EventHandler</tt> class. We then
|
||
cause our <tt class="classname">RepQuoteExample</tt>
|
||
class to implement
|
||
<tt class="classname">EventHandler</tt>. We also
|
||
change our environment handle to be an instance
|
||
of <tt class="classname">RepQuoteEnvironment</tt>
|
||
instead of <tt class="classname">Environment</tt>.
|
||
</p>
|
||
<p>
|
||
Note that we also import the
|
||
<tt class="classname">com.sleepycat.db.ReplicationHandleDeadException</tt>
|
||
class. We will discuss what that exception is
|
||
used for a little later in this example.
|
||
</p>
|
||
<pre class="programlisting">package db.repquote;
|
||
|
||
import java.io.FileNotFoundException;
|
||
import java.io.BufferedReader;
|
||
import java.io.InputStreamReader;
|
||
import java.io.IOException;
|
||
import java.io.UnsupportedEncodingException;
|
||
import java.lang.Thread;
|
||
import java.lang.InterruptedException;
|
||
|
||
import com.sleepycat.db.Cursor;
|
||
import com.sleepycat.db.Database;
|
||
import com.sleepycat.db.DatabaseConfig;
|
||
import com.sleepycat.db.DatabaseEntry;
|
||
import com.sleepycat.db.DatabaseException;
|
||
import com.sleepycat.db.DatabaseType;
|
||
import com.sleepycat.db.EnvironmentConfig;
|
||
<b class="userinput"><tt>import com.sleepycat.db.EventHandler;</tt></b>
|
||
import com.sleepycat.db.LockMode;
|
||
import com.sleepycat.db.OperationStatus;
|
||
<b class="userinput"><tt>import com.sleepycat.db.ReplicationHandleDeadException;</tt></b>
|
||
|
||
import db.repquote.RepConfig;
|
||
<b class="userinput"><tt>import db.repquote.RepQuoteEnvironment</tt></b>
|
||
|
||
public class RepQuoteExample <b class="userinput"><tt> implements EventHandler</tt></b>
|
||
{
|
||
private RepConfig repConfig;
|
||
private <b class="userinput"><tt>RepQuoteEnvironment</tt></b> dbenv; </pre>
|
||
<p>
|
||
That done, we can skip the
|
||
|
||
|
||
<span><tt class="methodname">main()</tt> method and
|
||
our class constructor, because they do not change.</span>
|
||
|
||
Instead, we skip down to our
|
||
|
||
|
||
<span><tt class="methodname">init()</tt> method
|
||
where we take care of opening our environment and setting
|
||
the event handler. </span>
|
||
</p>
|
||
<p>
|
||
To update our <tt class="methodname">init()</tt> method, we only need
|
||
to do a couple of things. First, we identify the current class as
|
||
the event handler. Then, when we open our environment, we
|
||
instantiate a <tt class="classname">RepQuoteEnvironment</tt>
|
||
class instead of an <tt class="classname">Environment</tt>
|
||
class.
|
||
</p>
|
||
<pre class="programlisting"> public int init(RepConfig config)
|
||
throws DatabaseException
|
||
{
|
||
int ret = 0;
|
||
appConfig = config;
|
||
EnvironmentConfig envConfig = new EnvironmentConfig();
|
||
envConfig.setErrorStream(System.err);
|
||
envConfig.setErrorPrefix(RepConfig.progname);
|
||
|
||
envConfig.setReplicationManagerLocalSite(appConfig.getThisHost());
|
||
for (ReplicationHostAddress host = appConfig.getFirstOtherHost();
|
||
host != null; host = appConfig.getNextOtherHost())
|
||
{
|
||
envConfig.replicationManagerAddRemoteSite(host);
|
||
}
|
||
|
||
if (appConfig.totalSites > 0)
|
||
envConfig.setReplicationNumSites(appConfig.totalSites);
|
||
envConfig.setReplicationPriority(appConfig.priority);
|
||
|
||
envConfig.setReplicationManagerAckPolicy(
|
||
ReplicationManagerAckPolicy.ALL);
|
||
envConfig.setCacheSize(RepConfig.CACHESIZE);
|
||
envConfig.setTxnNoSync(true);
|
||
|
||
<b class="userinput"><tt>envConfig.setEventHandler(this);</tt></b>
|
||
|
||
envConfig.setAllowCreate(true);
|
||
envConfig.setRunRecovery(true);
|
||
envConfig.setThreaded(true);
|
||
envConfig.setInitializeReplication(true);
|
||
envConfig.setInitializeLocking(true);
|
||
envConfig.setInitializeLogging(true);
|
||
envConfig.setInitializeCache(true);
|
||
envConfig.setTransactional(true);
|
||
envConfig.setVerboseReplication(appConfig.verbose);
|
||
try {
|
||
dbenv = new <b class="userinput"><tt>RepQuoteEnvironment</tt></b>(appConfig.getHome(), envConfig);
|
||
} catch(FileNotFoundException e) {
|
||
System.err.println("FileNotFound exception: " + e.toString());
|
||
System.err.println(
|
||
"Ensure that the environment directory is pre-created.");
|
||
ret = 1;
|
||
}
|
||
|
||
// start replication manager
|
||
dbenv.replicationManagerStart(3, appConfig.startPolicy);
|
||
return ret;
|
||
} </pre>
|
||
<p>
|
||
That done, we need to implement our
|
||
<tt class="methodname">handleEvent()</tt> method.
|
||
This method is required because we are now implementing
|
||
<tt class="classname">com.sleepycat.db.EventHandler</tt>. We use this
|
||
method to track whether we are operating as a master.
|
||
</p>
|
||
<pre class="programlisting"> public int handleEvent(EventType event)
|
||
{
|
||
int ret = 0;
|
||
if (event == EventType.REP_MASTER)
|
||
dbenv.setIsMaster(true);
|
||
else if (event == EventType.REP_CLIENT)
|
||
dbenv.setIsMaster(false);
|
||
else if (event == EventType.REP_NEW_MASTER) {
|
||
// ignored for now.
|
||
} else {
|
||
System.err.println("Unknown event callback received.\n");
|
||
ret = 1;
|
||
}
|
||
return ret;
|
||
} </pre>
|
||
<p>
|
||
That done, we need to update our
|
||
<tt class="function">doloop()</tt>
|
||
|
||
|
||
<span>method.</span>
|
||
</p>
|
||
<p>
|
||
We begin by updating our <tt class="classname">DatabaseConfig</tt>
|
||
instance to determine which options to use, depending on whether the
|
||
application is running as a master.
|
||
</p>
|
||
<pre class="programlisting"> public int doloop()
|
||
throws DatabaseException
|
||
{
|
||
Database db = null;
|
||
|
||
for (;;)
|
||
{
|
||
if (db == null) {
|
||
DatabaseConfig dbconf = new DatabaseConfig();
|
||
// Set page size small so page allocation is cheap.
|
||
dbconf.setPageSize(512);
|
||
dbconf.setType(DatabaseType.BTREE);
|
||
<b class="userinput"><tt>if (dbenv.getIsMaster()) {
|
||
dbconf.setAllowCreate(true);
|
||
}</tt></b>
|
||
dbconf.setTransactional(true); </pre>
|
||
<p>
|
||
When we open the database, we modify our error handling to
|
||
account for the case where the database does not yet exist. This can
|
||
happen if our code is running as a replica and the replication framework has not
|
||
yet had a chance to create the databases for us. Recall that replicas never
|
||
write to their own databases directly, and so they cannot
|
||
create databases on their own.
|
||
</p>
|
||
<p>
|
||
If we detect that the database does not yet exist, we simply
|
||
close the database handle, sleep for a short period of time
|
||
and then continue processing. This gives the replication framework a chance to
|
||
create the database so that our replica can continue
|
||
operations.
|
||
</p>
|
||
<pre class="programlisting"> try {
|
||
db = dbenv.openDatabase
|
||
(null, RepConfig.progname, null, dbconf);
|
||
} catch (java.io.FileNotFoundException e) {
|
||
<b class="userinput"><tt>System.err.println("no stock database available yet.");
|
||
if (db != null) {
|
||
db.close(true);
|
||
db = null;
|
||
}
|
||
try {
|
||
Thread.sleep(RepConfig.SLEEPTIME);
|
||
} catch (InterruptedException ie) {}
|
||
continue;</tt></b>
|
||
}
|
||
} </pre>
|
||
<p>
|
||
Next we modify our prompt, so that if the local process is running
|
||
as a replica, we can tell from the shell that the prompt is for a
|
||
read-only process.
|
||
</p>
|
||
<pre class="programlisting"> BufferedReader stdin =
|
||
new BufferedReader(new InputStreamReader(System.in));
|
||
|
||
// listen for input, and add it to the database.
|
||
System.out.print("QUOTESERVER");
|
||
<b class="userinput"><tt>if (!dbenv.getIsMaster())
|
||
System.out.print("(read-only)");
|
||
System.out.print("> ");</tt></b>
|
||
System.out.flush();
|
||
String nextline = null;
|
||
try {
|
||
nextline = stdin.readLine();
|
||
} catch (IOException ioe) {
|
||
System.err.println("Unable to get data from stdin");
|
||
break;
|
||
}
|
||
String[] words = nextline.split("\\s"); </pre>
|
||
<p>
|
||
When we collect data from the prompt, there is a case that says
|
||
if no data is entered then show the entire stocks database.
|
||
This display is performed by our
|
||
<tt class="function">print_stocks()</tt>
|
||
|
||
<span>method</span>
|
||
(which has not
|
||
required a modification since we first introduced it in
|
||
<a href="simpleprogramlisting.html#printstocks_c">
|
||
|
||
|
||
<span>Method: SimpleTxn.printStocks()</span>
|
||
</a>).
|
||
</p>
|
||
<p>
|
||
When we call
|
||
|
||
<span><tt class="function">printStocks()</tt>, </span>
|
||
we check for a dead replication handle. Dead
|
||
replication handles happen whenever a replication election
|
||
results in a previously committed transaction becoming
|
||
invalid. This is an error scenario caused by a new master having a
|
||
slightly older version of the data than the original
|
||
master and so all replicas must modify their database(s) to
|
||
reflect that of the new master. In this situation, some
|
||
number of previously committed transactions may have to be
|
||
unrolled. From the replica's perspective, the database
|
||
handles should all be closed and then opened again.
|
||
</p>
|
||
<pre class="programlisting"> // A blank line causes the DB to be dumped to stdout.
|
||
if (words.length == 0 ||
|
||
(words.length == 1 && words[0].length() == 0)) {
|
||
try {
|
||
printStocks(db);
|
||
<b class="userinput"><tt>} catch (DeadlockException de) {
|
||
continue;
|
||
// Dead replication handles are caused by an election
|
||
// resulting in a previously committing read becoming
|
||
// invalid. Close the db handle and reopen.
|
||
} catch (ReplicationHandleDeadException rhde) {
|
||
db.close(true); // close no sync.
|
||
db = null;
|
||
continue;</tt></b>
|
||
} catch (DatabaseException e) {
|
||
System.err.println("Got db exception reading " +
|
||
"replication DB: " + e.toString());
|
||
break;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (words.length == 1 &&
|
||
(words[0].compareToIgnoreCase("quit") == 0 ||
|
||
words[0].compareToIgnoreCase("exit") == 0)) {
|
||
break;
|
||
} else if (words.length != 2) {
|
||
System.err.println("Format: TICKER VALUE");
|
||
continue;
|
||
} </pre>
|
||
<p>
|
||
That done, we need to add a little error checking to our
|
||
command prompt to make sure the user is not attempting to
|
||
modify the database at a replica. Remember, replicas must never
|
||
modify their local databases on their own. This guards against
|
||
that happening due to user input at the prompt.
|
||
</p>
|
||
<pre class="programlisting"> <b class="userinput"><tt>if (!dbenv.getIsMaster()) {
|
||
System.err.println("Can't update client.");
|
||
continue;
|
||
}</tt></b>
|
||
|
||
DatabaseEntry key = new DatabaseEntry(words[0].getBytes());
|
||
DatabaseEntry data = new DatabaseEntry(words[1].getBytes());
|
||
|
||
db.put(null, key, data);
|
||
}
|
||
if (db != null)
|
||
db.close(true);
|
||
return 0;
|
||
} </pre>
|
||
<p>
|
||
With that completed, we are all done updating our application
|
||
for replication.
|
||
|
||
The only remaining
|
||
|
||
|
||
<span>method, <tt class="function">printStocks()</tt>,</span>
|
||
|
||
is unmodified from when we
|
||
originally introduced it. For details on that function, see
|
||
<a href="simpleprogramlisting.html#printstocks_c">
|
||
|
||
|
||
<span>Method: SimpleTxn.printStocks()</span>
|
||
</a>.
|
||
</p>
|
||
<div class="sect2" lang="en" xml:lang="en">
|
||
<div class="titlepage">
|
||
<div>
|
||
<div>
|
||
<h3 class="title"><a id="runningit"></a>Running It</h3>
|
||
</div>
|
||
</div>
|
||
<div></div>
|
||
</div>
|
||
<p>
|
||
To run our replicated application, we need to make
|
||
sure each participating environment has its own unique
|
||
home directory. We can do this by running
|
||
each site on a separate networked machine, but that
|
||
is not strictly necessary; multiple instances of this
|
||
code can run on the same machine provided the
|
||
environment home restriction is observed.
|
||
</p>
|
||
<p>
|
||
To run a process, make sure the environment home
|
||
exists and then start the process using the
|
||
<tt class="literal">-h</tt> option to specify that
|
||
directory. You must also use the <tt class="literal">-m</tt>
|
||
option to identify the local host and port that this
|
||
process will use to listen for replication messages, and
|
||
the <tt class="literal">-o</tt> option to identify the other
|
||
processes in the replication group. Finally, use the
|
||
<tt class="literal">-p</tt> option to specify a priority.
|
||
The process that you designate to have the highest priority will become
|
||
the master.
|
||
</p>
|
||
<pre class="programlisting">> mkdir env1
|
||
> java db.repquote.RepQuoteExample -h env1 -n 2 -m localhost:8080 \
|
||
-o localhost:8081 -p 10
|
||
No stock database yet available.
|
||
No stock database yet available. </pre>
|
||
<p>
|
||
Now, start another process. This time, change the environment
|
||
home to something else, use the <tt class="literal">-m</tt> to at
|
||
least change the port number the process is listening on, and
|
||
use the <tt class="literal">-o</tt> option to identify the host and
|
||
port of the other replication process:
|
||
</p>
|
||
<pre class="programlisting">> mkdir env2
|
||
> java db.repquote.RepQuoteExample -h env2 -n 2 -m localhost:8081 \
|
||
-o localhost:8080 -p 20</pre>
|
||
<p>
|
||
After a short pause, the second process should display the master
|
||
prompt:
|
||
</p>
|
||
<pre class="programlisting">
|
||
QUOTESERVER > </pre>
|
||
<p>
|
||
And the first process should
|
||
display the read-only prompt:
|
||
</p>
|
||
<pre class="programlisting">
|
||
QUOTESERVER (read-only)> </pre>
|
||
<p>
|
||
Now go to the master process and give it a couple of stocks and stock
|
||
prices:
|
||
</p>
|
||
<pre class="programlisting">QUOTESERVER> FAKECO 9.87
|
||
QUOTESERVER> NOINC .23
|
||
QUOTESERVER> </pre>
|
||
<p>
|
||
Then, go to the replica and hit <b class="userinput"><tt>return</tt></b> at the prompt to
|
||
see the new values:
|
||
</p>
|
||
<pre class="programlisting">QUOTESERVER (read-only)>
|
||
Symbol Price
|
||
====== =====
|
||
FAKECO 9.87
|
||
NOINC .23
|
||
QUOTESERVER (read-only)> </pre>
|
||
<p>
|
||
Doing the same at the master results in the same thing:
|
||
</p>
|
||
<pre class="programlisting">QUOTESERVER>
|
||
Symbol Price
|
||
====== =====
|
||
FAKECO 9.87
|
||
NOINC .23
|
||
QUOTESERVER> </pre>
|
||
<p>
|
||
You can change a stock by simply entering the stock value and
|
||
new price at the master's prompt:
|
||
</p>
|
||
<pre class="programlisting">QUOTESERVER> FAKECO 10.01
|
||
QUOTESERVER> </pre>
|
||
<p>
|
||
Then, go to either the master or the replica to see the updated
|
||
database:
|
||
</p>
|
||
<pre class="programlisting">QUOTESERVER>
|
||
Symbol Price
|
||
====== =====
|
||
FAKECO 10.01
|
||
NOINC .23
|
||
QUOTESERVER> </pre>
|
||
<p>
|
||
And on the replica:
|
||
</p>
|
||
<pre class="programlisting">QUOTESERVER (read-only)>
|
||
Symbol Price
|
||
====== =====
|
||
FAKECO 10.01
|
||
NOINC .23
|
||
QUOTESERVER (read-only)> </pre>
|
||
<p>
|
||
Finally, to quit the applications, simply type
|
||
<tt class="literal">quit</tt> at both prompts:
|
||
</p>
|
||
<pre class="programlisting">QUOTESERVER (read-only)> quit
|
||
> </pre>
|
||
<p>
|
||
And on the master as well:
|
||
</p>
|
||
<pre class="programlisting">QUOTESERVER> quit
|
||
> </pre>
|
||
</div>
|
||
</div>
|
||
<div class="navfooter">
|
||
<hr />
|
||
<table width="100%" summary="Navigation footer">
|
||
<tr>
|
||
<td width="40%" align="left"><a accesskey="p" href="processingloop.html">Prev</a> </td>
|
||
<td width="20%" align="center">
|
||
<a accesskey="u" href="fwrkmasterreplica.html">Up</a>
|
||
</td>
|
||
<td width="40%" align="right"> <a accesskey="n" href="addfeatures.html">Next</a></td>
|
||
</tr>
|
||
<tr>
|
||
<td width="40%" align="left" valign="top">Processing Loop </td>
|
||
<td width="20%" align="center">
|
||
<a accesskey="h" href="index.html">Home</a>
|
||
</td>
|
||
<td width="40%" align="right" valign="top"> Chapter 5. Additional Features</td>
|
||
</tr>
|
||
</table>
|
||
</div>
|
||
</body>
|
||
</html>
|