/** Creates the environment and runs a transaction */
public static void main(String[] argv) throws Exception {
String dir = "./tmp";
// environment is transactional
EnvironmentConfig envConfig = new EnvironmentConfig();
envConfig.setTransactional(true);
envConfig.setInitializeCache(true);
envConfig.setInitializeLocking(true);
if (create) {
envConfig.setAllowCreate(true);
}
Environment env = new Environment(new File(dir), envConfig);
// create the application and run a transaction
HelloDatabaseWorld worker = new HelloDatabaseWorld(env);
TransactionRunner runner = new TransactionRunner(env);
try {
// open and access the database within a transaction
runner.run(worker);
} finally {
// close the database outside the transaction
worker.close();
}
}
public TpcbExample(
File home,
int accounts,
int branches,
int tellers,
int history,
int cachesize,
boolean noSync)
throws DatabaseException, FileNotFoundException {
this.accounts = accounts;
this.branches = branches;
this.tellers = tellers;
this.history = history;
EnvironmentConfig config = new EnvironmentConfig();
config.setErrorStream(System.err);
config.setErrorPrefix(progname);
config.setLockDetectMode(LockDetectMode.DEFAULT);
config.setCacheSize(cachesize == 0 ? 4 * 1024 * 1024 : cachesize);
config.setTxnNoSync(noSync);
config.setLockDetectMode(LockDetectMode.DEFAULT);
config.setAllowCreate(true);
config.setInitializeCache(true);
config.setTransactional(true);
config.setInitializeLocking(true);
config.setInitializeLogging(true);
dbenv = new Environment(home, config);
}
private EnvironmentConfig makeBasicConfig() {
EnvironmentConfig ec = new EnvironmentConfig();
ec.setAllowCreate(true);
ec.setInitializeCache(true);
ec.setInitializeLocking(true);
ec.setInitializeLogging(true);
ec.setInitializeReplication(true);
ec.setTransactional(true);
ec.setReplicationManagerAckPolicy(ReplicationManagerAckPolicy.ALL);
ec.setRunRecovery(true);
ec.setThreaded(true);
if (Boolean.getBoolean("VERB_REPLICATION")) ec.setVerbose(VerboseConfig.REPLICATION, true);
return (ec);
}
public static EnvironmentConfig makeBasicConfig() {
EnvironmentConfig ec = new EnvironmentConfig();
ec.setAllowCreate(true);
ec.setInitializeCache(true);
ec.setInitializeLocking(true);
ec.setInitializeLogging(true);
ec.setInitializeReplication(true);
ec.setTransactional(true);
ec.setThreaded(true);
ec.setReplicationInMemory(true);
ec.setCacheSize(256 * 1024 * 1024);
if (Boolean.getBoolean("VERB_REPLICATION")) ec.setVerbose(VerboseConfig.REPLICATION, true);
return (ec);
}
private EventExampleDPL(File envHome) throws DatabaseException, FileNotFoundException {
/* Open a transactional Berkeley DB engine environment. */
System.out.println("-> Creating a BDB environment");
EnvironmentConfig envConfig = new EnvironmentConfig();
envConfig.setAllowCreate(true);
envConfig.setTransactional(true);
envConfig.setInitializeCache(true);
envConfig.setInitializeLocking(true);
env = new Environment(envHome, envConfig);
/* Initialize the data access object. */
init();
cal = Calendar.getInstance();
}
static {
EnvironmentConfig config;
config = newEnvConfig();
BDB = new TestEnv("bdb", config);
if (DbCompat.CDB) {
config = newEnvConfig();
DbCompat.setInitializeCDB(config, true);
CDB = new TestEnv("cdb", config);
} else {
CDB = null;
}
config = newEnvConfig();
config.setTransactional(true);
DbCompat.setInitializeLocking(config, true);
TXN = new TestEnv("txn", config);
}
void copyConfig(EnvironmentConfig copyToConfig) {
DbCompat.setInitializeCache(copyToConfig, DbCompat.getInitializeCache(config));
DbCompat.setInitializeLocking(copyToConfig, DbCompat.getInitializeLocking(config));
DbCompat.setInitializeCDB(copyToConfig, DbCompat.getInitializeCDB(config));
copyToConfig.setTransactional(config.getTransactional());
}
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 (RepRemoteHost host = appConfig.getFirstOtherHost();
host != null;
host = appConfig.getNextOtherHost()) {
envConfig.replicationManagerAddRemoteSite(host.getAddress(), host.isPeer());
}
if (appConfig.totalSites > 0) envConfig.setReplicationNumSites(appConfig.totalSites);
/*
* Set replication group election priority for this environment.
* An election first selects the site with the most recent log
* records as the new master. If multiple sites have the most
* recent log records, the site with the highest priority value
* is selected as master.
*/
envConfig.setReplicationPriority(appConfig.priority);
envConfig.setCacheSize(RepConfig.CACHESIZE);
envConfig.setTxnNoSync(true);
envConfig.setEventHandler(new RepQuoteEventHandler());
/*
* Set the policy that determines how master and client sites
* handle acknowledgement of replication messages needed for
* permanent records. The default policy of "quorum" requires only
* a quorum of electable peers sufficient to ensure a permanent
* record remains durable if an election is held. The "all" option
* requires all clients to acknowledge a permanent replication
* message instead.
*/
envConfig.setReplicationManagerAckPolicy(appConfig.ackPolicy);
/*
* Set the threshold for the minimum and maximum time the client
* waits before requesting retransmission of a missing message.
* Base these values on the performance and load characteristics
* of the master and client host platforms as well as the round
* trip message time.
*/
envConfig.setReplicationRequestMin(20000);
envConfig.setReplicationRequestMax(500000);
/*
* Configure deadlock detection to ensure that any deadlocks
* are broken by having one of the conflicting lock requests
* rejected. DB_LOCK_DEFAULT uses the lock policy specified
* at environment creation time or DB_LOCK_RANDOM if none was
* specified.
*/
envConfig.setLockDetectMode(LockDetectMode.DEFAULT);
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 RepQuoteEnvironment(appConfig.getHome(), envConfig);
} catch (FileNotFoundException e) {
System.err.println("FileNotFound exception: " + e);
System.err.println("Ensure that the environment directory is pre-created.");
ret = 1;
}
if (appConfig.bulk) dbenv.setReplicationConfig(ReplicationConfig.BULK, true);
/*
* Configure heartbeat timeouts so that repmgr monitors the
* health of the TCP connection. Master sites broadcast a heartbeat
* at the frequency specified by the DB_REP_HEARTBEAT_SEND timeout.
* Client sites wait for message activity the length of the
* DB_REP_HEARTBEAT_MONITOR timeout before concluding that the
* connection to the master is lost. The DB_REP_HEARTBEAT_MONITOR
* timeout should be longer than the DB_REP_HEARTBEAT_SEND timeout.
*/
dbenv.setReplicationTimeout(ReplicationTimeoutType.HEARTBEAT_SEND, 5000000);
dbenv.setReplicationTimeout(ReplicationTimeoutType.HEARTBEAT_MONITOR, 10000000);
/* The following base replication features may also be useful to your
* application. See Berkeley DB documentation for more details.
* - Master leases: Provide stricter consistency for data reads
* on a master site.
* - Timeouts: Customize the amount of time Berkeley DB waits
* for such things as an election to be concluded or a master
* lease to be granted.
* - Delayed client synchronization: Manage the master site's
* resources by spreading out resource-intensive client
* synchronizations.
* - Blocked client operations: Return immediately with an error
* instead of waiting indefinitely if a client operation is
* blocked by an ongoing client synchronization.
*
* The following repmgr features may also be useful to your
* application. See Berkeley DB documentation for more details.
* - Two-site strict majority rule - In a two-site replication
* group, require both sites to be available to elect a new
* master.
* - Timeouts - Customize the amount of time repmgr waits
* for such things as waiting for acknowledgements or attempting
* to reconnect to other sites.
* - Site list - return a list of sites currently known to repmgr.
*/
/* Start checkpoint and log archive support threads. */
ckpThr = new CheckpointThread(dbenv);
ckpThr.start();
lgaThr = new LogArchiveThread(dbenv, envConfig);
lgaThr.start();
/* Start replication manager. */
dbenv.replicationManagerStart(3, appConfig.startPolicy);
return ret;
}
/** Open all storage containers, indices, and catalogs. */
public SampleDatabase(String homeDirectory) throws DatabaseException, FileNotFoundException {
// Open the Berkeley DB environment in transactional mode.
//
System.out.println("Opening environment in: " + homeDirectory);
EnvironmentConfig envConfig = new EnvironmentConfig();
envConfig.setTransactional(true);
envConfig.setAllowCreate(true);
envConfig.setInitializeCache(true);
envConfig.setInitializeLocking(true);
env = new Environment(new File(homeDirectory), envConfig);
// Set the Berkeley DB config for opening all stores.
//
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setTransactional(true);
dbConfig.setAllowCreate(true);
dbConfig.setType(DatabaseType.BTREE);
// Create the Serial class catalog. This holds the serialized class
// format for all database records of serial format.
//
Database catalogDb = env.openDatabase(null, CLASS_CATALOG, null, dbConfig);
javaCatalog = new StoredClassCatalog(catalogDb);
// Open the Berkeley DB database for the part, supplier and shipment
// stores. The stores are opened with no duplicate keys allowed.
//
partDb = env.openDatabase(null, PART_STORE, null, dbConfig);
supplierDb = env.openDatabase(null, SUPPLIER_STORE, null, dbConfig);
shipmentDb = env.openDatabase(null, SHIPMENT_STORE, null, dbConfig);
// Open the SecondaryDatabase for the city index of the supplier store,
// and for the part and supplier indices of the shipment store.
// Duplicate keys are allowed since more than one supplier may be in
// the same city, and more than one shipment may exist for the same
// supplier or part. A foreign key constraint is defined for the
// supplier and part indices to ensure that a shipment only refers to
// existing part and supplier keys. The CASCADE delete action means
// that shipments will be deleted if their associated part or supplier
// is deleted.
//
SecondaryConfig secConfig = new SecondaryConfig();
secConfig.setTransactional(true);
secConfig.setAllowCreate(true);
secConfig.setType(DatabaseType.BTREE);
secConfig.setSortedDuplicates(true);
secConfig.setKeyCreator(
new SupplierByCityKeyCreator(
javaCatalog, SupplierKey.class, SupplierData.class, String.class));
supplierByCityDb =
env.openSecondaryDatabase(null, SUPPLIER_CITY_INDEX, null, supplierDb, secConfig);
secConfig.setForeignKeyDatabase(partDb);
secConfig.setForeignKeyDeleteAction(ForeignKeyDeleteAction.CASCADE);
secConfig.setKeyCreator(
new ShipmentByPartKeyCreator(
javaCatalog, ShipmentKey.class, ShipmentData.class, PartKey.class));
shipmentByPartDb =
env.openSecondaryDatabase(null, SHIPMENT_PART_INDEX, null, shipmentDb, secConfig);
secConfig.setForeignKeyDatabase(supplierDb);
secConfig.setForeignKeyDeleteAction(ForeignKeyDeleteAction.CASCADE);
secConfig.setKeyCreator(
new ShipmentBySupplierKeyCreator(
javaCatalog, ShipmentKey.class, ShipmentData.class, SupplierKey.class));
shipmentBySupplierDb =
env.openSecondaryDatabase(null, SHIPMENT_SUPPLIER_INDEX, null, shipmentDb, secConfig);
}
public void run() {
String homedirName = baseDirName + threadNumber;
TestUtils.removeDir(homedirName);
try {
homedir = new File(homedirName);
homedir.mkdir();
} catch (Exception e) {
TestUtils.DEBUGOUT(
2, "Warning: initialization had a problem creating a clean directory.\n" + e);
}
try {
homedir = new File(homedirName);
} catch (NullPointerException npe) {
// can't really happen :)
}
TestUtils.DEBUGOUT(1, "Creating worker: " + threadNumber);
envConfig = new EnvironmentConfig();
envConfig.setErrorStream(TestUtils.getErrorStream());
envConfig.setErrorPrefix("RepmgrElectionTest test(" + threadNumber + ")");
envConfig.setAllowCreate(true);
envConfig.setRunRecovery(true);
envConfig.setThreaded(true);
envConfig.setInitializeLocking(true);
envConfig.setInitializeLogging(true);
envConfig.setInitializeCache(true);
envConfig.setTransactional(true);
envConfig.setTxnNoSync(true);
envConfig.setInitializeReplication(true);
envConfig.setVerboseReplication(false);
ReplicationManagerSiteConfig localConfig =
new ReplicationManagerSiteConfig(address, basePort + threadNumber);
localConfig.setLocalSite(true);
envConfig.addReplicationManagerSite(localConfig);
envConfig.setReplicationPriority(priorities[threadNumber]);
envConfig.setEventHandler(this);
envConfig.setReplicationManagerAckPolicy(ReplicationManagerAckPolicy.ALL);
if (masterThreadIndex >= 0) {
// If we already have the master, then set it as the bootstrap helper,
// otherwise, set local site as new master.
ReplicationManagerSiteConfig remoteConfig =
new ReplicationManagerSiteConfig(address, basePort + masterThreadIndex);
remoteConfig.setBootstrapHelper(true);
envConfig.addReplicationManagerSite(remoteConfig);
}
try {
dbenv = new Environment(homedir, envConfig);
} catch (FileNotFoundException e) {
fail("Unexpected FNFE in standard environment creation." + e);
} catch (DatabaseException dbe) {
fail("Unexpected database exception came from environment create." + dbe);
}
try {
// If we do not have master, then set local site as new master.
if (masterThreadIndex == -1)
dbenv.replicationManagerStart(NUM_WORKER_THREADS, ReplicationManagerStartPolicy.REP_MASTER);
else
dbenv.replicationManagerStart(NUM_WORKER_THREADS, ReplicationManagerStartPolicy.REP_CLIENT);
} catch (DatabaseException dbe) {
fail("Unexpected database exception came from replicationManagerStart." + dbe);
}
TestUtils.DEBUGOUT(1, "Started replication site: " + threadNumber);
lastSiteStarted = true;
try {
java.lang.Thread.sleep(1000 * (1 + threadNumber));
} catch (InterruptedException ie) {
}
if (masterThreadIndex != -1) {
// Wait for "Start-up done" for each client, then add next client.
ReplicationStats rs = null;
int i = 0;
do {
try {
java.lang.Thread.sleep(2000);
} catch (InterruptedException e) {
}
try {
rs = dbenv.getReplicationStats(StatsConfig.DEFAULT);
} catch (DatabaseException dbe) {
dbe.printStackTrace();
fail("Unexpected database exception came from getReplicationStats." + dbe);
}
} while (!rs.getStartupComplete() && i++ < maxLoopWait);
assertTrue(rs.getStartupComplete());
}
}