/** closeFile Close the current file, but keep its path so we can easily open it again. */
public void closeFile() throws NexusException {
try {
if (m_nfFile != null) {
m_nfFile.close();
m_nfFile.finalize();
}
m_nfFile = null;
} catch (Throwable t) {
if (g_mutex.isLocked() && g_curFile.equals(m_sFilePath)) {
if (g_mutex.getHoldCount() - 1 == 0) {
g_curFile = "";
}
g_mutex.unlock();
}
if (t instanceof NexusException) {
throw (NexusException) t;
} else {
t.printStackTrace();
return;
}
}
if (g_mutex.isLocked() && g_curFile.equals(m_sFilePath)) {
if (g_mutex.getHoldCount() - 1 == 0) {
g_curFile = "";
}
g_mutex.unlock();
}
}
public void leave() {
ReentrantLock var1 = this.lock;
try {
if (var1.getHoldCount() == 1) {
this.signalNextWaiter();
}
} finally {
var1.unlock();
}
}
public void writeUnLock(final Object key) {
synchronized (locks) {
final ReentrantLock lock = (ReentrantLock) locks.get(key);
if (lock == null) {
throw new IllegalMonitorStateException("Cannot unlock prior to locking");
}
if (lock.getHoldCount() == 0) {
throw new IllegalMonitorStateException("Cannot unlock prior to locking");
}
lock.unlock();
}
}
private void waitOnBufferFull() {
if ((m_bufferCount > m_maxBufferSize) && (m_mutatorLock.getHoldCount() == 1)) {
// try
// {
// System.out.println("++++++Thread Interrupt+++++++++");
// m_writeThread.interrupt();
// m_lockCondition.await();
submitJob();
// }
// catch (InterruptedException ignored) {}
}
}
public int getHoldCount() {
return lock.getHoldCount();
}
public Future<AsyncQueueReadUnit> read(
SelectionKey key,
ByteBuffer buffer,
AsyncReadCallbackHandler callbackHandler,
AsyncReadCondition condition,
AsyncQueueDataProcessor readPostProcessor)
throws IOException {
if (key == null) {
throw new IOException(
"SelectionKey is null! " + "Probably key was cancelled or connection was closed?");
}
FutureImpl<AsyncQueueReadUnit> future = new FutureImpl<AsyncQueueReadUnit>();
SelectableChannel channel = (SelectableChannel) key.channel();
AsyncQueueEntry channelEntry = readQueue.obtainAsyncQueueEntry(channel);
// Update statistics
channelEntry.totalElementsCount.incrementAndGet();
AsyncQueueReadUnit record = new AsyncQueueReadUnit();
final Queue<AsyncQueueReadUnit> queue = channelEntry.queue;
final AtomicReference<AsyncQueueReadUnit> currentElement = channelEntry.currentElement;
ReentrantLock lock = channelEntry.queuedActionLock;
final int holdState = lock.getHoldCount();
// If AsyncQueue is empty - try to read ByteBuffer here
try {
OperationResult dstResult = channelEntry.tmpResult;
boolean isDirectReadCompleted = false;
if (currentElement.get() == null
&& // Weak comparison for null
lock.tryLock()) {
// Strong comparison for null, because we're in locked region
if (currentElement.compareAndSet(null, record)) {
// Do direct reading
do {
dstResult = doRead((ReadableByteChannel) channel, buffer, readPostProcessor, dstResult);
channelEntry.processedDataSize.addAndGet(dstResult.bytesProcessed);
// If some data was read - we need to check "condition"
// Check is performed for each message separately, not like for TCP
if (dstResult.address != null
&& (!buffer.hasRemaining()
|| (condition != null
&& condition.checkAsyncReadCompleted(key, dstResult.address, buffer)))) {
isDirectReadCompleted = true;
break;
}
} while (dstResult.address != null);
} else {
lock.unlock();
}
}
if (!isDirectReadCompleted && buffer.hasRemaining()) {
// Update statistics
channelEntry.queuedElementsCount.incrementAndGet();
record.set(buffer, callbackHandler, condition, readPostProcessor, future);
boolean isRegisterForReading = false;
// add new element to the queue, if it's not current
if (currentElement.get() != record) {
queue.offer(record); // add to queue
if (!lock.isLocked()) {
isRegisterForReading = true;
}
} else { // if element was read direct (not fully read)
isRegisterForReading = true;
lock.unlock();
}
if (isRegisterForReading) {
registerForReading(key);
}
} else { // If there are no bytes available for reading
boolean isReregister = false;
// Update statistics
channelEntry.processedElementsCount.incrementAndGet();
// If buffer was read directly - set next queue element as current
if (lock.isHeldByCurrentThread()) {
AsyncQueueReadUnit nextRecord = queue.poll();
if (nextRecord != null) { // if there is something in queue
currentElement.set(nextRecord);
lock.unlock();
isReregister = true;
} else { // if nothing in queue
currentElement.set(null);
lock.unlock(); // unlock
if (queue.peek() != null) { // check one more time
isReregister = true;
}
}
}
// Notify callback handler
record.set(buffer, callbackHandler, condition, readPostProcessor, future);
future.setResult(record);
if (callbackHandler != null) {
callbackHandler.onReadCompleted(key, dstResult.address, record);
}
if (isReregister) {
registerForReading(key);
}
}
} catch (Exception e) {
if (record.callbackHandler != null) {
record.callbackHandler.onException(e, key, buffer, queue);
}
onClose(channel);
if (e instanceof IOException) {
throw (IOException) e;
}
throw new IOException(e.getMessage());
} finally {
if (lock.isHeldByCurrentThread() && holdState < lock.getHoldCount()) {
lock.unlock();
}
}
return future;
}
final boolean isStateLocked() {
return m_stateLock.getHoldCount() > 0;
}
