import java.util.Collection;
import java.util.LinkedList;
+import org.simantics.db.Disposable;
import org.simantics.db.Resource;
-import org.simantics.db.common.utils.Logger;
import org.simantics.db.exception.CancelTransactionException;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.impl.graph.WriteGraphImpl;
import org.simantics.db.impl.query.QueryProcessor.SessionTask;
import org.simantics.db.request.WriteTraits;
import org.simantics.utils.datastructures.Pair;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class SessionRequestManager {
+ private static final Logger LOGGER = LoggerFactory.getLogger(SessionRequestManager.class);
+
private static boolean DEBUG = false;
enum State {
public synchronized void startRead(int thread, final SessionRead task) {
- session.queryProvider2.scheduleAlways(thread, new SessionTask(task.object, task.thread, task.syncCaller) {
+ session.queryProvider2.schedule(new SessionTask(true) {
@Override
public void run(int thread) {
transactionState.startReadTransaction(thread);
task.run(thread);
} catch (Throwable t) {
- Logger.defaultLogError(new DatabaseException("Read transaction could not be started", t));
+ LOGGER.error("Read transaction could not be started", t);
if(task.throwable != null)
task.throwable.set(t);
state = State.ERROR;
public synchronized void startReadUpdate(int thread) {
- session.queryProvider2.scheduleAlways(thread, new SessionTask(null, thread) {
+ session.queryProvider2.schedule(new SessionTask(true) {
@Override
public void run(int thread) {
try {
transactionState.stopReadTransaction();
} catch (DatabaseException e) {
- e.printStackTrace();
+ LOGGER.error("Read transaction could not be stopped", e);
}
}
}
-// public synchronized void stopRead(int thread) {
-//
-// try {
-// transactionState.stopReadTransaction();
-// } catch (DatabaseException e) {
-// e.printStackTrace();
-// }
-//
-// }
-
public synchronized void startWrite(int thread, final SessionTask task) {
- session.queryProvider2.scheduleAlways(thread, new SessionTask((WriteTraits)task.object, task.thread) {
+ session.queryProvider2.schedule(new SessionTask(true) {
@Override
public void run(int thread) {
try {
transactionState.startWriteTransaction(thread);
} catch (Throwable t) {
- DatabaseException e = new DatabaseException("Write transaction could not be started", t);
- Logger.defaultLogError(e);
+ LOGGER.error("Write transaction could not be started", t);
return;
}
task.run(thread);
public synchronized void startWriteUpdate(int thread) {
- session.queryProvider2.scheduleAlways(thread, new SessionTask(null, thread) {
+ session.queryProvider2.schedule(new SessionTask(true) {
@Override
public void run(int thread) {
} else {
throw new UnsupportedOperationException("delayedWriteState may only exist when request fails.");
}
+ Disposable.safeDispose(session.clientChanges);
session.clientChanges = new ClientChangesImpl(session);
delayedState.finish();
return;
if(!session.state.isAlive()) return;
WriteState<?> writeState = session.writeState;
+
+ assert(writeState != null);
+
WriteGraphImpl graph = writeState.getGraph();
if(writeState.isExcepted()) {
-
+
if(!(writeState.exception instanceof CancelTransactionException))
- writeState.exception.printStackTrace();
-
+ LOGGER.error("Write request failed", writeState.exception);
+
transactionState.cancelWriteTransaction(graph);
} else {
}
+ Disposable.safeDispose(session.clientChanges);
session.clientChanges = new ClientChangesImpl(session);
WriteState<?> state = session.writeState;
}
-// public synchronized void stopWrite(int thread) {
-//
-// session.clientChanges = new ClientChangesImpl(session);
-//
-// WriteState<?> state = session.writeState;
-//
-// System.err.println("D");
-// state.finish();
-// System.err.println("E");
-//
-// session.writeState = null;
-//
-// }
-
public synchronized void ceased(int thread) {
if(State.WRITE == state) {
if (!reads.isEmpty()) {
final SessionRead read = reads.poll();
- session.queryProvider2.scheduleAlways(thread, new SessionTask(read.object, read.thread, read.syncCaller) {
+ session.queryProvider2.schedule(new SessionTask(true) {
@Override
public void run(int thread) {
} else {
- throw new IllegalStateException("State in ceased should be WRITE or READ or INIT (was " + state + ")");
+ // Spurious wakeup
+
+ //throw new IllegalStateException("State in ceased should be WRITE or READ or INIT (was " + state + ")");
}
assert(State.INIT != state);
if(State.READ == state) {
- session.queryProvider2.schedule(Integer.MIN_VALUE, new SessionTask(task.object, task.thread, task.syncCaller) {
+ session.queryProvider2.schedule(new SessionTask(true) {
@Override
public void run(int thread) {
boolean inUpdate = state == State.WRITE_UPDATE;
+ //System.err.println("schedule write " + task);
+
assert(State.INIT != state);
//task.combine = combine != null ? combine : inUpdate;
if(State.IDLE == state) {
try {
value.second.binaryFile.close();
} catch (IOException e) {
- Logger.defaultLogError("I/O exception while closing random access value file " + value.second.binaryFile.file() + " for resource " + value.first , e);
+ LOGGER.error("I/O exception while closing random access value file " + value.second.binaryFile.file() + " for resource " + value.first , e);
}
}
}