bundles/org.simantics.scl.db/src/org/simantics/scl/db/SCLFunctions.java

   1 package org.simantics.scl.db;
   2
   3 import java.io.IOException;
   4
   5 import org.cojen.classfile.TypeDesc;
   6 import org.simantics.Simantics;
   7 import org.simantics.db.ReadGraph;
   8 import org.simantics.db.Resource;
   9 import org.simantics.db.VirtualGraph;
  10 import org.simantics.db.WriteGraph;
  11 import org.simantics.db.common.procedure.adapter.SyncListenerAdapter;
  12 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
  13 import org.simantics.db.common.request.BinaryRead;
  14 import org.simantics.db.common.request.DelayedWriteRequest;
  15 import org.simantics.db.common.request.ReadRequest;
  16 import org.simantics.db.common.request.UnaryRead;
  17 import org.simantics.db.common.request.WriteRequest;
  18 import org.simantics.db.common.request.WriteResultRequest;
  19 import org.simantics.db.exception.DatabaseException;
  20 import org.simantics.db.layer0.util.Layer0Utils;
  21 import org.simantics.db.layer0.variable.Variables;
  22 import org.simantics.db.request.Read;
  23 import org.simantics.db.service.ClusterControl;
  24 import org.simantics.db.service.QueryControl;
  25 import org.simantics.db.service.SerialisationSupport;
  26 import org.simantics.db.service.VirtualGraphSupport;
  27 import org.simantics.layer0.utils.triggers.IActivationManager;
  28 import org.simantics.scl.compiler.environment.specification.EnvironmentSpecification;
  29 import org.simantics.scl.compiler.errors.Failable;
  30 import org.simantics.scl.compiler.internal.codegen.types.JavaTypeTranslator;
  31 import org.simantics.scl.compiler.module.Module;
  32 import org.simantics.scl.compiler.module.repository.ImportFailureException;
  33 import org.simantics.scl.compiler.runtime.RuntimeEnvironment;
  34 import org.simantics.scl.compiler.types.Type;
  35 import org.simantics.scl.osgi.SCLOsgi;
  36 import org.simantics.scl.runtime.SCLContext;
  37 import org.simantics.scl.runtime.function.Function;
  38 import org.simantics.scl.runtime.function.Function1;
  39 import org.simantics.scl.runtime.reporting.SCLReportingHandler;
  40 import org.simantics.scl.runtime.tuple.Tuple;
  41 import org.simantics.scl.runtime.tuple.Tuple0;
  42 import org.simantics.utils.DataContainer;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45
  46 @SuppressWarnings({"rawtypes", "unchecked"})
  47 public class SCLFunctions {
  48
  49     private static final Logger LOGGER = LoggerFactory.getLogger(SCLFunctions.class);
  50
  51     public static final String GRAPH = "graph";
  52
  53     public static <T> T safeExec(final Function f) {
  54         try {
  55             return (T)f.apply(Tuple0.INSTANCE);
  56         } catch (Throwable t) {
  57             LOGGER.error("safeExec caught exception", t);
  58             return null;
  59         }
  60     }
  61
  62     public static void asyncRead(final Function f) throws DatabaseException {
  63         final SCLContext context = SCLContext.createDerivedContext();
  64         Simantics.getSession().asyncRequest(new ReadRequest() {
  65             @Override
  66             public void run(ReadGraph graph) throws DatabaseException {
  67                 SCLContext.push(context);
  68                 context.put(GRAPH, graph);
  69                 try {
  70                     f.apply(Tuple0.INSTANCE);
  71                 } finally {
  72                     SCLContext.pop();
  73                 }
  74             }
  75         });
  76     }
  77
  78     public static <T> T syncRead(final Function f) throws DatabaseException {
  79         final SCLContext context = SCLContext.getCurrent();
  80         Object graph = context.get(GRAPH);
  81         if (graph != null) {
  82             return (T)f.apply(Tuple0.INSTANCE);
  83         } else {
  84             return Simantics.getSession().syncRequest(new Read<T>() {
  85                 @Override
  86                 public T perform(ReadGraph graph) throws DatabaseException {
  87                     SCLContext.push(context);
  88                     ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
  89                     try {
  90                         return (T)f.apply(Tuple0.INSTANCE);
  91                     } finally {
  92                         context.put(GRAPH, oldGraph);
  93                         SCLContext.pop();
  94                     }
  95                 }
  96             });
  97         }
  98     }
  99
 100     public static void asyncWrite(final Function f) throws DatabaseException {
 101         SCLContext context = SCLContext.createDerivedContext();
 102         if (Simantics.peekSession() != null) {
 103             Simantics.getSession().asyncRequest(new WriteRequest() {
 104                 @Override
 105                 public void perform(WriteGraph graph) throws DatabaseException {
 106                     SCLContext.push(context);
 107                     context.put(GRAPH, graph);
 108                     try {
 109                         f.apply(Tuple0.INSTANCE);
 110                     } finally {
 111                         SCLContext.pop();
 112                     }
 113                 }
 114             });
 115         } else {
 116             LOGGER.warn("No session available for asynchronous write requests");
 117         }
 118     }
 119
 120     public static <T> T syncWrite(final Function f) throws DatabaseException {
 121         final SCLContext context = SCLContext.getCurrent();
 122         Object graph = context.get(GRAPH);
 123         if (graph != null) {
 124             return (T)f.apply(Tuple0.INSTANCE);
 125         } else {
 126             final SCLReportingHandler printer = (SCLReportingHandler)SCLContext.getCurrent().get(SCLReportingHandler.REPORTING_HANDLER);
 127             return Simantics.getSession().syncRequest(new WriteResultRequest<T>() {
 128                 @Override
 129                 public T perform(WriteGraph graph) throws DatabaseException {
 130                     SCLContext.push(context);
 131                     SCLReportingHandler oldPrinter = (SCLReportingHandler)context.put(SCLReportingHandler.REPORTING_HANDLER, printer);
 132                     ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
 133                     try {
 134                         return (T)f.apply(Tuple0.INSTANCE);
 135                     } finally {
 136                         context.put(GRAPH, oldGraph);
 137                         context.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
 138                         SCLContext.pop();
 139                     }
 140                 }
 141             });
 142         }
 143     }
 144
 145     public static <T> T delayedSyncWrite(final Function f) throws DatabaseException {
 146         final SCLContext context = SCLContext.getCurrent();
 147         final DataContainer<T> dc = new DataContainer<T>(null);
 148
 149         DelayedWriteRequest request = new DelayedWriteRequest() {
 150             @Override
 151             public void perform(WriteGraph graph) throws DatabaseException {
 152                 final SCLContext context = SCLContext.getCurrent();
 153                 SCLContext.push(context);
 154                 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
 155                 try {
 156                     dc.set((T)f.apply(Tuple0.INSTANCE));
 157                 } finally {
 158                     context.put(GRAPH, oldGraph);
 159                     SCLContext.pop();
 160                 }
 161             }
 162         };
 163
 164         Object graph = context.get(GRAPH);
 165         if (graph != null) {
 166             if (graph instanceof WriteGraph) {
 167                 ((WriteGraph)graph).syncRequest(request);
 168             } else {
 169                 throw new DatabaseException("Caller is inside a read transaction.");
 170             }
 171         } else {
 172             Simantics.getSession().syncRequest(request);
 173         }
 174         return dc.get();
 175     }
 176
 177     public static <T> T virtualSyncWriteMem(WriteGraph graph, String virtualGraphId, final Function f) throws DatabaseException {
 178         final SCLContext context = SCLContext.getCurrent();
 179         VirtualGraphSupport vgs = graph.getService(VirtualGraphSupport.class);
 180         VirtualGraph vg = vgs.getMemoryPersistent(virtualGraphId);
 181         return graph.syncRequest(new WriteResultRequest<T>(vg) {
 182             @Override
 183             public T perform(WriteGraph graph) throws DatabaseException {
 184                 SCLContext.push(context);
 185                 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
 186                 try {
 187                     return (T)f.apply(Tuple0.INSTANCE);
 188                 } finally {
 189                     context.put(GRAPH, oldGraph);
 190                     SCLContext.pop();
 191                 }
 192             }
 193         });
 194     }
 195
 196     public static <T> T virtualSyncWriteWS(WriteGraph graph, String virtualGraphId, final Function f) throws DatabaseException {
 197         final SCLContext context = SCLContext.getCurrent();
 198         VirtualGraphSupport vgs = graph.getService(VirtualGraphSupport.class);
 199         VirtualGraph vg = vgs.getWorkspacePersistent(virtualGraphId);
 200         return graph.syncRequest(new WriteResultRequest<T>(vg) {
 201             @Override
 202             public T perform(WriteGraph graph) throws DatabaseException {
 203                 SCLContext.push(context);
 204                 ReadGraph oldGraph = (ReadGraph)context.put(GRAPH, graph);
 205                 try {
 206                     return (T)f.apply(Tuple0.INSTANCE);
 207                 } finally {
 208                     context.put(GRAPH, oldGraph);
 209                     SCLContext.pop();
 210                 }
 211             }
 212         });
 213     }
 214
 215     public static <T> T readValue(final String uri) throws DatabaseException {
 216         return Simantics.getSession().syncRequest(new Read<T>() {
 217             @Override
 218             public T perform(ReadGraph graph) throws DatabaseException {
 219                 return Variables.getVariable(graph, uri).getValue(graph);
 220             }
 221         });
 222     }
 223
 224     public static <T> void writeValue(final String uri, final T value) throws DatabaseException {
 225         Simantics.getSession().syncRequest(new WriteRequest() {
 226             @Override
 227             public void perform(WriteGraph graph) throws DatabaseException {
 228                 Variables.getVariable(graph, uri).setValue(graph, value);
 229             }
 230         });
 231     }
 232
 233     public static void activateOnce(Resource r) {
 234         Simantics.getSession().getService(IActivationManager.class).activateOnce(r);
 235     }
 236
 237     public static void syncActivateOnce(WriteGraph graph, Resource r) throws DatabaseException {
 238         graph.getService(IActivationManager.class).activateOnce(graph, r);
 239     }
 240
 241     public static Resource resourceFromId(ReadGraph graph, long id) throws DatabaseException, IOException {
 242         SerialisationSupport ss = graph.getService(SerialisationSupport.class);
 243         return ss.getResource(id);
 244     }
 245
 246     public static void disableDependencies(WriteGraph graph) {
 247         Layer0Utils.setDependenciesIndexingDisabled(graph, true);
 248     }
 249
 250     public static void enableDependencies(WriteGraph graph) {
 251         Layer0Utils.setDependenciesIndexingDisabled(graph, false);
 252     }
 253
 254     public static void collectClusters() {
 255         Simantics.getSession().getService(ClusterControl.class).collectClusters(Integer.MAX_VALUE);
 256     }
 257
 258     public static class SCLUnaryRead extends BinaryRead<Function1<Object,Object>, Object, Object> {
 259
 260                 public SCLUnaryRead(Function1<Object, Object> parameter1, Object parameter2) {
 261                         super(parameter1, parameter2);
 262                 }
 263
 264                 @Override
 265                 public Object perform(ReadGraph graph) throws DatabaseException {
 266                         return Simantics.applySCLRead(graph, parameter, parameter2);
 267                 }
 268
 269     }
 270
 271     public static Object unaryQuery(ReadGraph graph, Function1<Object,Object> fn, Object value) throws DatabaseException {
 272         return graph.syncRequest(new SCLUnaryRead(fn, value));
 273     }
 274
 275     public static Object unaryQueryCached(ReadGraph graph, Function1<Object,Object> fn, Object value) throws DatabaseException {
 276         return graph.syncRequest(new SCLUnaryRead(fn, value), TransientCacheAsyncListener.<Object>instance());
 277     }
 278
 279
 280     private static class Subquery extends UnaryRead<Function, Object> {
 281
 282         public Subquery(Function q) {
 283             super(q);
 284         }
 285
 286         @Override
 287         public Object perform(ReadGraph graph) throws DatabaseException {
 288             return Simantics.applySCLRead(graph, parameter, Tuple0.INSTANCE);
 289         }
 290
 291     }
 292
 293     public static Object subquery(ReadGraph graph, Function q) throws DatabaseException {
 294         return graph.syncRequest(new Subquery(q));
 295     }
 296
 297     public static Object subqueryC(ReadGraph graph, Function q) throws DatabaseException {
 298         return graph.syncRequest(new Subquery(q), TransientCacheAsyncListener.<Object>instance());
 299     }
 300
 301     public static void subqueryL(ReadGraph graph, Function query, Function executeCallback, Function1<Throwable, Tuple> exceptionCallback, Function1<Tuple0, Boolean> isDisposedCallback) throws DatabaseException {
 302         graph.syncRequest(new Subquery(query), new SyncListenerAdapter<Object>() {
 303             @Override
 304             public void execute(ReadGraph graph, Object result) throws DatabaseException {
 305                 Simantics.applySCLRead(graph, executeCallback, result);
 306             }
 307
 308             @Override
 309             public void exception(ReadGraph graph, Throwable t) throws DatabaseException {
 310                 Simantics.applySCLRead(graph, exceptionCallback, t);
 311             }
 312
 313             @Override
 314             public boolean isDisposed() {
 315                 return isDisposedCallback.apply(Tuple0.INSTANCE);
 316             }
 317         });
 318     }
 319
 320     public static Object possibleFromDynamic(Type expectedType, String moduleName, Object value) {
 321
 322         try {
 323
 324
 325             Failable<Module> failable = SCLOsgi.MODULE_REPOSITORY.getModule(moduleName);
 326             Module module = failable.getResult();
 327
 328                 RuntimeEnvironment env = SCLOsgi.MODULE_REPOSITORY.createRuntimeEnvironment(
 329                                 EnvironmentSpecification.of(moduleName, ""), module.getParentClassLoader());
 330
 331             JavaTypeTranslator tr = new JavaTypeTranslator(env.getEnvironment());
 332             TypeDesc desc = tr.toTypeDesc(expectedType);
 333             String className = desc.getFullName();
 334             Class<?> clazz = env.getMutableClassLoader().loadClass(className);
 335             if (!clazz.isAssignableFrom(value.getClass()))
 336                 return null;
 337
 338         } catch (ImportFailureException | ClassNotFoundException e) {
 339         }
 340         return value;
 341     }
 342
 343     public static void restrictQueries(ReadGraph graph, int amount, int step, int maxTimeInMs) {
 344
 345                 QueryControl qc = graph.getService(QueryControl.class);
 346                 long start = System.currentTimeMillis();
 347                 while(true) {
 348                         int current = qc.count();
 349                         if(current < amount) return;
 350                         qc.gc(graph, step);
 351                         long duration = System.currentTimeMillis() - start;
 352                         if(duration > maxTimeInMs) return;
 353                 }
 354
 355     }
 356
 357     public static int countQueries(ReadGraph graph) {
 358
 359                 QueryControl qc = graph.getService(QueryControl.class);
 360                 return qc.count();
 361
 362     }
 363
 364 }