Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
net.sf.hajdbc.state.sqlite.SQLiteStateManager Maven / Gradle / Ivy
/*
* HA-JDBC: High-Availability JDBC
* Copyright (C) 2012 Paul Ferraro
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see > implements StateManager, SerializedDurabilityListener
{
// SQLite has minimal concurrency support - and only supports a single writer per-database
// So, mitigate this by using separate databases per table.
private enum DB { STATE, INVOCATION }
private static final Logger logger = LoggerFactory.getLogger(SQLiteStateManager.class);
private static final String STATE_TABLE = "cluster_state";
private static final String DATABASE_COLUMN = "database_id";
private static final String INVOCATION_TABLE = "cluster_invocation";
private static final String INVOKER_TABLE = "cluster_invoker";
private static final String INVOKER_TABLE_INDEX = "cluster_invoker_index";
private static final String TRANSACTION_COLUMN = "tx_id";
private static final String PHASE_COLUMN = "phase_id";
private static final String EXCEPTION_COLUMN = "exception_id";
private static final String RESULT_COLUMN = "result";
static final String CREATE_INVOCATION_SQL = MessageFormat.format("CREATE TABLE {0} ({1} BLOB NOT NULL, {2} INTEGER NOT NULL, {3} INTEGER NOT NULL, PRIMARY KEY ({1}, {2}))", INVOCATION_TABLE, TRANSACTION_COLUMN, PHASE_COLUMN, EXCEPTION_COLUMN);
static final String CREATE_INVOKER_SQL = MessageFormat.format("CREATE TABLE {0} ({1} BLOB NOT NULL, {2} INTEGER NOT NULL, {3} TEXT NOT NULL, {4} BLOB, PRIMARY KEY ({1}, {2}, {3}))", INVOKER_TABLE, TRANSACTION_COLUMN, PHASE_COLUMN, DATABASE_COLUMN, RESULT_COLUMN);
static final String CREATE_INVOKER_INDEX = MessageFormat.format("CREATE INDEX {0} ON {1} ({2}, {3})", INVOKER_TABLE_INDEX, INVOKER_TABLE, TRANSACTION_COLUMN, PHASE_COLUMN);
static final String CREATE_STATE_SQL = MessageFormat.format("CREATE TABLE {0} ({1} TEXT NOT NULL, PRIMARY KEY ({1}))", STATE_TABLE, DATABASE_COLUMN);
private final DatabaseCluster cluster;
private final DurabilityListener listener;
private final File file;
private final PoolFactory poolFactory;
// Control concurrency ourselves, instead of relying of sqljet lock polling.
private final Map locks = new EnumMap(DB.class);
private final Map> pools = new EnumMap>(DB.class);
public SQLiteStateManager(DatabaseCluster cluster, File file, PoolFactory poolFactory)
{
this.cluster = cluster;
this.file = file;
this.poolFactory = poolFactory;
this.listener = new DurabilityListenerAdapter(this, cluster.getTransactionIdentifierFactory());
}
@Override
public boolean isEnabled()
{
return true;
}
@Override
public boolean isValid(Database database) {
return this.getActiveDatabases().contains(database.getId());
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterListener#activated(net.sf.hajdbc.state.DatabaseEvent)
*/
@Override
public void activated(final DatabaseEvent event)
{
Transaction transaction = new Transaction()
{
@Override
public void execute(SqlJetDb db) throws SqlJetException
{
db.getTable(STATE_TABLE).insert(event.getSource());
}
};
try
{
this.execute(transaction, DB.STATE);
}
catch (SqlJetException e)
{
logger.log(Level.ERROR, e);
}
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterListener#deactivated(net.sf.hajdbc.state.DatabaseEvent)
*/
@Override
public void deactivated(final DatabaseEvent event)
{
Transaction transaction = new Transaction()
{
@Override
public void execute(SqlJetDb db) throws SqlJetException
{
ISqlJetTable table = db.getTable(STATE_TABLE);
ISqlJetCursor cursor = table.lookup(table.getPrimaryKeyIndexName(), event.getSource());
try
{
if (!cursor.eof())
{
cursor.delete();
}
}
finally
{
close(cursor);
}
}
};
try
{
this.execute(transaction, DB.STATE);
}
catch (SqlJetException e)
{
logger.log(Level.ERROR, e);
}
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.durability.DurabilityListener#beforeInvocation(net.sf.hajdbc.durability.InvocationEvent)
*/
@Override
public void beforeInvocation(InvocationEvent event)
{
this.listener.beforeInvocation(event);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.durability.DurabilityListener#afterInvocation(net.sf.hajdbc.durability.InvocationEvent)
*/
@Override
public void afterInvocation(InvocationEvent event)
{
this.listener.afterInvocation(event);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.durability.DurabilityListener#beforeInvoker(net.sf.hajdbc.durability.InvokerEvent)
*/
@Override
public void beforeInvoker(InvokerEvent event)
{
this.listener.beforeInvoker(event);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.durability.DurabilityListener#afterInvoker(net.sf.hajdbc.durability.InvokerEvent)
*/
@Override
public void afterInvoker(InvokerEvent event)
{
this.listener.afterInvoker(event);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.Lifecycle#start()
*/
@Override
public void start() throws Exception
{
for (DB db: DB.values())
{
this.locks.put(db, new ReentrantReadWriteLock());
this.pools.put(db, this.poolFactory.createPool(new SQLiteDbPoolProvider(new File(this.file.toURI().resolve(db.name().toLowerCase())))));
}
Transaction stateTransaction = new Transaction()
{
@Override
public void execute(SqlJetDb database) throws SqlJetException
{
ISqlJetSchema schema = database.getSchema();
if (schema.getTable(STATE_TABLE) == null)
{
database.createTable(CREATE_STATE_SQL);
}
else if (Boolean.getBoolean(StateManager.CLEAR_LOCAL_STATE))
{
database.getTable(STATE_TABLE).clear();
}
}
};
Transaction invocationTransaction = new Transaction()
{
@Override
public void execute(SqlJetDb database) throws SqlJetException
{
ISqlJetSchema schema = database.getSchema();
if (schema.getTable(INVOCATION_TABLE) == null)
{
database.createTable(CREATE_INVOCATION_SQL);
}
if (schema.getTable(INVOKER_TABLE) == null)
{
database.createTable(CREATE_INVOKER_SQL);
database.createIndex(CREATE_INVOKER_INDEX);
}
}
};
this.execute(stateTransaction, DB.STATE);
this.execute(invocationTransaction, DB.INVOCATION);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.Lifecycle#stop()
*/
@Override
public void stop()
{
for (Pool pool: this.pools.values())
{
pool.close();
}
this.pools.clear();
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.state.StateManager#getActiveDatabases()
*/
@Override
public Set getActiveDatabases()
{
Query> query = new Query>()
{
@Override
public Set execute(SqlJetDb database) throws SqlJetException
{
Set set = new TreeSet();
ISqlJetTable table = database.getTable(STATE_TABLE);
ISqlJetCursor cursor = table.lookup(table.getPrimaryKeyIndexName());
try
{
if (!cursor.eof())
{
do
{
set.add(cursor.getString(DATABASE_COLUMN));
}
while (cursor.next());
}
return set;
}
finally
{
close(cursor);
}
}
};
try
{
return this.execute(query, DB.STATE);
}
catch (SqlJetException e)
{
logger.log(Level.ERROR, e);
return Collections.emptySet();
}
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.state.StateManager#setActiveDatabases(java.util.Set)
*/
@Override
public void setActiveDatabases(final Set databases)
{
Transaction transaction = new Transaction()
{
@Override
public void execute(SqlJetDb db) throws SqlJetException
{
ISqlJetTable table = db.getTable(STATE_TABLE);
table.clear();
for (String database: databases)
{
table.insert(database);
}
}
};
try
{
this.execute(transaction, DB.STATE);
}
catch (SqlJetException e)
{
logger.log(Level.ERROR, e);
}
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.state.StateManager#recover()
*/
@Override
public Map> recover()
{
final TransactionIdentifierFactory txIdFactory = this.cluster.getTransactionIdentifierFactory();
Query>> invocationQuery = new Query>>()
{
@Override
public Map> execute(SqlJetDb database) throws SqlJetException
{
Map> map = new HashMap>();
ISqlJetCursor cursor = database.getTable(INVOCATION_TABLE).open();
try
{
if (!cursor.eof())
{
do
{
Object txId = txIdFactory.deserialize(cursor.getBlobAsArray(TRANSACTION_COLUMN));
Durability.Phase phase = Durability.Phase.values()[(int) cursor.getInteger(PHASE_COLUMN)];
ExceptionType type = ExceptionType.values()[(int) cursor.getInteger(EXCEPTION_COLUMN)];
map.put(new InvocationEventImpl(txId, phase, type), new HashMap());
}
while (cursor.next());
}
}
finally
{
cursor.close();
}
cursor = database.getTable(INVOKER_TABLE).open();
try
{
if (!cursor.eof())
{
do
{
Object txId = txIdFactory.deserialize(cursor.getBlobAsArray(TRANSACTION_COLUMN));
Durability.Phase phase = Durability.Phase.values()[(int) cursor.getInteger(PHASE_COLUMN)];
Map invokers = map.get(new InvocationEventImpl(txId, phase, null));
if (invokers != null)
{
String databaseId = cursor.getString(DATABASE_COLUMN);
InvokerEvent event = new InvokerEventImpl(txId, phase, databaseId);
if (!cursor.isNull(RESULT_COLUMN))
{
byte[] result = cursor.getBlobAsArray(RESULT_COLUMN);
event.setResult(Objects.deserialize(result));
}
invokers.put(databaseId, event);
}
}
while (cursor.next());
}
}
finally
{
cursor.close();
}
return map;
}
};
try
{
return this.execute(invocationQuery, DB.INVOCATION);
}
catch (SqlJetException e)
{
throw new IllegalStateException(e);
}
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.state.SerializedDurabilityListener#beforeInvocation(byte[], byte, byte)
*/
@Override
public void beforeInvocation(final byte[] transactionId, final byte phase, final byte exceptionType)
{
Transaction transaction = new Transaction()
{
@Override
public void execute(SqlJetDb db) throws SqlJetException
{
db.getTable(INVOCATION_TABLE).insert(transactionId, phase, exceptionType);
}
};
try
{
this.execute(transaction, DB.INVOCATION);
}
catch (SqlJetException e)
{
logger.log(Level.ERROR, e);
}
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.state.SerializedDurabilityListener#afterInvocation(byte[], byte)
*/
@Override
public void afterInvocation(final byte[] transactionId, final byte phase)
{
Transaction transaction = new Transaction()
{
@Override
public void execute(SqlJetDb db) throws SqlJetException
{
ISqlJetTable table = db.getTable(INVOCATION_TABLE);
ISqlJetCursor cursor = table.lookup(table.getPrimaryKeyIndexName(), transactionId, phase);
try
{
if (!cursor.eof())
{
cursor.delete();
}
}
finally
{
close(cursor);
}
table = db.getTable(INVOKER_TABLE);
cursor = table.lookup(INVOKER_TABLE_INDEX, transactionId, phase);
try
{
if (!cursor.eof())
{
do
{
cursor.delete();
}
while (cursor.next());
}
}
finally
{
close(cursor);
}
}
};
try
{
this.execute(transaction, DB.INVOCATION);
}
catch (SqlJetException e)
{
logger.log(Level.ERROR, e);
}
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.state.SerializedDurabilityListener#beforeInvoker(byte[], byte, java.lang.String)
*/
@Override
public void beforeInvoker(final byte[] transactionId, final byte phase, final String databaseId)
{
Transaction transaction = new Transaction()
{
@Override
public void execute(SqlJetDb db) throws SqlJetException
{
db.getTable(INVOKER_TABLE).insert(transactionId, phase, databaseId);
}
};
try
{
this.execute(transaction, DB.INVOCATION);
}
catch (SqlJetException e)
{
logger.log(Level.ERROR, e);
}
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.state.SerializedDurabilityListener#afterInvoker(byte[], byte, java.lang.String, byte[])
*/
@Override
public void afterInvoker(final byte[] transactionId, final byte phase, final String databaseId, final byte[] result)
{
Transaction transaction = new Transaction()
{
@Override
public void execute(SqlJetDb db) throws SqlJetException
{
ISqlJetTable table = db.getTable(INVOKER_TABLE);
ISqlJetCursor cursor = table.lookup(table.getPrimaryKeyIndexName(), transactionId, phase, databaseId);
try
{
if (!cursor.eof())
{
cursor.updateByFieldNames(Collections.singletonMap(RESULT_COLUMN, result));
}
}
finally
{
close(cursor);
}
}
};
try
{
this.execute(transaction, DB.INVOCATION);
}
catch (SqlJetException e)
{
logger.log(Level.ERROR, e);
}
}
static void close(ISqlJetCursor cursor)
{
try
{
cursor.close();
}
catch (SqlJetException e)
{
logger.log(Level.WARN, e);
}
}
private void execute(Transaction transaction, DB db) throws SqlJetException
{
Pool pool = this.pools.get(db);
Lock lock = this.locks.get(db).writeLock();
SqlJetDb database = pool.take();
lock.lock();
try
{
database.beginTransaction(SqlJetTransactionMode.WRITE);
try
{
transaction.execute(database);
database.commit();
}
catch (SqlJetException e)
{
try
{
database.rollback();
}
catch (SqlJetException ex)
{
logger.log(Level.WARN, ex);
}
throw e;
}
}
finally
{
lock.unlock();
pool.release(database);
}
}
private T execute(Query query, DB db) throws SqlJetException
{
Pool pool = this.pools.get(db);
Lock lock = this.locks.get(db).readLock();
SqlJetDb database = pool.take();
lock.lock();
try
{
database.beginTransaction(SqlJetTransactionMode.READ_ONLY);
try
{
return query.execute(database);
}
finally
{
database.commit();
}
}
finally
{
lock.unlock();
pool.release(database);
}
}
interface Query
{
T execute(SqlJetDb database) throws SqlJetException;
}
interface Transaction
{
void execute(SqlJetDb database) throws SqlJetException;
}
}
