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);
                       });
                 }
               });
         });
   }
 }
Example #2
0
 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));
       });
 }
Example #3
0
 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);
   }
 }
Example #6
0
 public static void offerTask(Runnable aTask) {
   assert tasks != null : "Scripts tasks are not initialized";
   Scripts.getContext().incAsyncsCount();
   tasks.accept(aTask);
 }