public void startModelValidating() {
if (!isModelValid() && !validationStarted) {
validationStarted = true;
EventQueue.invokeLater(
() -> {
Scripts.LocalContext context = Scripts.getContext();
RP.execute(
() -> {
Scripts.setContext(context);
try {
validateModel();
} catch (Exception ex) {
Logger.getLogger(PlatypusDataObject.class.getName())
.log(Level.WARNING, ex.getMessage(), ex);
} finally {
Scripts.setContext(null);
EventQueue.invokeLater(
() -> {
validationStarted = false;
setModelValid(true);
});
}
});
});
}
}
public void process(Runnable aTask) {
Scripts.LocalContext context = Scripts.getContext();
Runnable taskWrapper =
() -> {
Scripts.setContext(context);
try {
aTask.run();
} finally {
Scripts.setContext(null);
}
};
queue.offer(taskWrapper);
offerTask(
() -> {
// Runnable processedTask = taskWrapper;
int version;
int newVersion;
Thread thisThread = Thread.currentThread();
do {
version = queueVersion.get();
// Zombie counter ...
newVersion = version + 1;
if (newVersion == Integer.MAX_VALUE) {
newVersion = 0;
}
/* moved to top of body
if (processedTask != null) {//Single attempt to offer aTask.
queue.offer(processedTask);
processedTask = null;
}
*/
if (worker.compareAndSet(null, thisThread)) { // Worker electing.
try {
// already single threaded environment
if (global == null) {
Scripts.Space.this.initSpaceGlobal();
}
// Zombie processing ...
Runnable task = queue.poll();
while (task != null) {
task.run();
task = queue.poll();
}
} catch (Throwable t) {
Logger.getLogger(Scripts.class.getName()).log(Level.SEVERE, null, t);
} finally {
boolean setted = worker.compareAndSet(thisThread, null);
assert setted : "Worker electing assumption failed"; // Always successfull CAS.
}
}
} while (!queueVersion.compareAndSet(version, newVersion));
});
}
public void schedule(JSObject aJsTask, long aTimeout) {
Scripts.LocalContext context = Scripts.getContext();
bio.submit(
() -> {
try {
Thread.sleep(aTimeout);
Scripts.setContext(context);
try {
process(
() -> {
aJsTask.call(null, new Object[] {});
});
} finally {
Scripts.setContext(null);
}
} catch (InterruptedException ex) {
Logger.getLogger(Scripts.class.getName()).log(Level.SEVERE, null, ex);
}
});
}
/**
* Checks module roles.
*
* @param anAllowedRoles
* @param aSubjectName
* @throws AccessControlException
*/
public static void checkPrincipalPermission(Set<String> anAllowedRoles, String aSubjectName)
throws AccessControlException {
if (anAllowedRoles != null && !anAllowedRoles.isEmpty()) {
try {
PlatypusPrincipal principal = (PlatypusPrincipal) Scripts.getContext().getPrincipal();
if (principal == null || !principal.hasAnyRole(anAllowedRoles)) {
throw new AccessControlException(
String.format(
"Access denied to %s for '%s'.", // NOI18N
aSubjectName, principal != null ? principal.getName() : null),
principal instanceof AnonymousPlatypusPrincipal ? new AuthPermission("*") : null);
}
} catch (Exception ex) {
if (ex instanceof AccessControlException) {
throw ex;
} else {
throw new AccessControlException(ex.getMessage());
}
}
}
}
@Override
public void handle(
Session aSession, Consumer<CommitRequest.Response> onSuccess, Consumer<Exception> onFailure) {
try {
DatabasesClient client = getServerCore().getDatabasesClient();
List<Change> changes =
ChangesJSONReader.read(getRequest().getChangesJson(), Scripts.getSpace());
ChangesSortProcess process =
new ChangesSortProcess(
changes,
(Map<String, List<Change>> changeLogs) -> {
try {
client.commit(
changeLogs,
(Integer aUpdated) -> {
if (onSuccess != null) {
onSuccess.accept(new CommitRequest.Response(aUpdated));
}
},
onFailure);
} catch (Exception ex) {
Logger.getLogger(CommitRequestHandler.class.getName())
.log(Level.SEVERE, null, ex);
}
},
onFailure);
if (changes.isEmpty()) {
if (onSuccess != null) {
onSuccess.accept(new CommitRequest.Response(0));
}
} else {
changes
.stream()
.forEach(
(change) -> {
try {
((LocalQueriesProxy) serverCore.getQueries())
.getQuery(
change.entityName,
Scripts.getSpace(),
(SqlQuery aQuery) -> {
if (aQuery.isPublicAccess()) {
AccessControlException aex =
checkWritePrincipalPermission(
(PlatypusPrincipal) Scripts.getContext().getPrincipal(),
change.entityName,
aQuery.getWriteRoles());
if (aex != null) {
process.complete(null, null, aex, null);
} else {
process.complete(change, aQuery, null, null);
}
} else {
process.complete(
null,
null,
new AccessControlException(
String.format(
"Public access to query %s is denied while commiting changes for it's entity.",
change.entityName)),
null);
}
},
(Exception ex) -> {
process.complete(null, null, null, ex);
});
} catch (Exception ex) {
Logger.getLogger(CommitRequestHandler.class.getName())
.log(Level.SEVERE, null, ex);
}
});
}
} catch (Exception ex) {
onFailure.accept(ex);
}
}
public static void offerTask(Runnable aTask) {
assert tasks != null : "Scripts tasks are not initialized";
Scripts.getContext().incAsyncsCount();
tasks.accept(aTask);
}