/** * Not reentrant lock acquisition operation (ie {@link #tryAcquire()}). * It tries to acquire the lock until will succeed (ie {@link AcquireResult#Done})or got interrupted (ie {@link AcquireResult#Exit}). * After each failed attempt is performed a {@link Pauser#idle} call. */ default AcquireResult tryAcquire(ExitCondition exitCondition, Pauser pauser) { while (exitCondition.keepRunning()) { if (tryAcquire()) { return AcquireResult.Done; } else { pauser.idle(); } } return AcquireResult.Exit; }
@Override public void close() throws SQLException { stop(); } }
/** * It release the lock itself and all the resources used by it (eg connections, file handlers) */ @Override default void close() throws Exception { release(); }
@Test(timeout = 10000) public void shouldStartIfTableExistInitialized() throws Exception { final TestJDBCDriver fakeDriver = createFakeDriver(true); fakeDriver.start(); final JdbcSharedStateManager sharedStateManager = createSharedStateManager(); sharedStateManager.stop(); try { fakeDriver.destroy(); } finally { fakeDriver.stop(); } }
public static TestJDBCDriver usingConnectionUrl(String jdbcConnectionUrl, String jdbcDriverClass, SQLProvider provider, boolean initialize) { TestJDBCDriver driver = new TestJDBCDriver(initialize); driver.setSqlProvider(provider); driver.setJdbcConnectionUrl(jdbcConnectionUrl); driver.setJdbcDriverClass(jdbcDriverClass); return driver; }
@Test(timeout = 10000) public void shouldStartTwoIfTableNotExist() throws Exception { final JdbcSharedStateManager liveSharedStateManager = createSharedStateManager(); final JdbcSharedStateManager backupSharedStateManager = createSharedStateManager(); backupSharedStateManager.stop(); try { liveSharedStateManager.destroy(); } finally { liveSharedStateManager.stop(); } } }
@Override public synchronized void stop() throws Exception { if (isStarted()) { try { this.scheduledLiveLock.stop(); this.scheduledBackupLock.stop(); } finally { super.stop(); this.sharedStateManager.close(); this.sharedStateManager = null; this.scheduledLiveLock = null; this.scheduledBackupLock = null; } } }
@Override public SimpleString readNodeId() { final UUID nodeId = this.sharedStateManager.readNodeId(); LOGGER.debugf("readNodeId nodeId = %s", nodeId); setUUID(nodeId); return getNodeId(); }
public static JdbcSharedStateManager usingConnectionUrl(String holderId, long locksExpirationMillis, String jdbcConnectionUrl, String jdbcDriverClass, SQLProvider provider) { return JdbcSharedStateManager.usingConnectionUrl(holderId, -1, null, locksExpirationMillis, jdbcConnectionUrl, jdbcDriverClass, provider); }
@Override public void awaitLiveStatus() { LOGGER.debug("ENTER awaitLiveStatus"); try { while (readSharedState() != SharedStateManager.State.LIVE) { pauser.idle(); } } finally { LOGGER.debug("EXIT awaitLiveStatus"); } }
@Override public boolean isHeld() { return checkValidHolderId(Objects::nonNull); }
private void setLive() { writeSharedState(SharedStateManager.State.LIVE); }
static ScheduledLeaseLock of(ScheduledExecutorService scheduledExecutorService, ArtemisExecutor executor, String lockName, LeaseLock lock, long renewPeriodMillis, IOCriticalErrorListener ioCriticalErrorListener) { return new ActiveMQScheduledLeaseLock(scheduledExecutorService, executor, lockName, lock, renewPeriodMillis, ioCriticalErrorListener); }
@Override protected void finalize() throws Throwable { close(); }
@Override protected void finalize() throws Throwable { stop(); }
@Test(timeout = 10000) public void shouldStartIfTableExistEmpty() throws Exception { final TestJDBCDriver fakeDriver = createFakeDriver(false); fakeDriver.start(); final JdbcSharedStateManager sharedStateManager = createSharedStateManager(); sharedStateManager.stop(); try { fakeDriver.destroy(); } finally { fakeDriver.stop(); } }
@Test(timeout = 10000) public void shouldStartIfTableNotExist() throws Exception { final JdbcSharedStateManager sharedStateManager = createSharedStateManager(); try { sharedStateManager.destroy(); } finally { sharedStateManager.stop(); } }
@Override public boolean isHeldByCaller() { return checkValidHolderId(this.holderId::equals); }
private void setFailingBack() { writeSharedState(SharedStateManager.State.FAILING_BACK); }