bundles/org.simantics.db.layer0/src/org/simantics/db/layer0/util/RuntimeEnvironmentRequest.java

   1 package org.simantics.db.layer0.util;
   2
   3 import java.util.HashMap;
   4 import java.util.Map;
   5
   6 import org.simantics.db.ReadGraph;
   7 import org.simantics.db.Resource;
   8 import org.simantics.db.common.request.ParametrizedPrimitiveRead;
   9 import org.simantics.db.common.request.UnaryRead;
  10 import org.simantics.db.exception.DatabaseException;
  11 import org.simantics.db.layer0.internal.SimanticsInternal;
  12 import org.simantics.db.procedure.Listener;
  13 import org.simantics.db.request.Read;
  14 import org.simantics.scl.compiler.environment.specification.EnvironmentSpecification;
  15 import org.simantics.scl.compiler.module.repository.ImportFailureException;
  16 import org.simantics.scl.compiler.module.repository.UpdateListener;
  17 import org.simantics.scl.compiler.runtime.RuntimeEnvironment;
  18 import org.simantics.scl.osgi.SCLOsgi;
  19 import org.simantics.scl.runtime.SCLContext;
  20
  21 /**
  22  * Finds the runtime environment of a model or other index root.
  23  *
  24  * @author Hannu Niemist&ouml;
  25  * @author Antti Villberg
  26  */
  27 public class RuntimeEnvironmentRequest extends UnaryRead<Resource, RuntimeEnvironment> {
  28
  29     public RuntimeEnvironmentRequest(Resource parameter) {
  30         super(parameter);
  31     }
  32
  33     protected void fillEnvironmentSpecification(EnvironmentSpecification environmentSpecification) {
  34     }
  35
  36     static class UpdateListenerImpl implements UpdateListener {
  37
  38         final EnvironmentSpecification environmentSpecification;
  39         final Listener<RuntimeEnvironment> callback;
  40
  41         UpdateListenerImpl(EnvironmentSpecification environmentSpecification, Listener<RuntimeEnvironment> callback) {
  42                 this.environmentSpecification = environmentSpecification;
  43                 this.callback = callback;
  44         }
  45
  46         @Override
  47         public void notifyAboutUpdate() {
  48                 if(callback.isDisposed()) {
  49                         return;
  50                 }
  51                 getRuntimeEnvironment(environmentSpecification, callback, this);
  52         }
  53
  54         final public static void getRuntimeEnvironment(EnvironmentSpecification environmentSpecification, Listener<RuntimeEnvironment> callback, UpdateListenerImpl listener) {
  55
  56                         try {
  57
  58                         SCLContext context = SCLContext.getCurrent();
  59
  60                         RuntimeEnvironment env;
  61                         Object graph = context.get("graph");
  62                         if(graph == null)
  63                     try {
  64                         env = SimanticsInternal.getSession().syncRequest(new Read<RuntimeEnvironment>() {
  65                             @Override
  66                             public RuntimeEnvironment perform(ReadGraph graph) throws DatabaseException {
  67
  68                                 SCLContext sclContext = SCLContext.getCurrent();
  69                                 Object oldGraph = sclContext.get("graph");
  70                                 try {
  71                                         sclContext.put("graph", graph);
  72                                     return SCLOsgi.MODULE_REPOSITORY.createRuntimeEnvironment(
  73                                             environmentSpecification,
  74                                             callback.getClass().getClassLoader(), listener);
  75                                 } catch (ImportFailureException e) {
  76                                     throw new DatabaseException(e);
  77                                 } catch (Throwable t) {
  78                                     throw new DatabaseException(t);
  79                                 } finally {
  80                                     sclContext.put("graph", oldGraph);
  81                                 }
  82                             }
  83                         });
  84                     } catch (DatabaseException e) {
  85                         callback.exception(e);
  86                         return;
  87                     }
  88                 else
  89                             env = SCLOsgi.MODULE_REPOSITORY.createRuntimeEnvironment(
  90                                     environmentSpecification,
  91                                     callback.getClass().getClassLoader(), listener);
  92                         callback.execute(env);
  93                         } catch (ImportFailureException e) {
  94                                 callback.exception(new DatabaseException(e));
  95                         }
  96
  97         }
  98
  99     };
 100
 101     // This is needed to prevent garbage collection from collecting UpdateListenerImpls
 102     // -ModuleRepository only makes a weak reference to the listener
 103     final static Map<String, UpdateListenerImpl> map = new HashMap<String, UpdateListenerImpl>();
 104
 105     @Override
 106     public RuntimeEnvironment perform(ReadGraph graph)
 107             throws DatabaseException {
 108         final EnvironmentSpecification environmentSpecification = EnvironmentSpecification.of(
 109                 "Builtin", "",
 110                 "Prelude", "",
 111                 "Simantics/All", "");
 112         fillEnvironmentSpecification(environmentSpecification);
 113         Resource mainModule = Layer0Utils.getPossibleChild(graph, parameter, "SCLMain");
 114         String mainModuleUri;
 115         if(mainModule != null) {
 116             mainModuleUri = graph.getURI(mainModule);
 117             environmentSpecification.importModule(mainModuleUri, "");
 118         }
 119         else
 120             mainModuleUri = graph.getURI(parameter) + "/#"; // Add something dummy to the model uri that cannot be in a real URI
 121
 122             return graph.syncRequest(new ParametrizedPrimitiveRead<String, RuntimeEnvironment>(mainModuleUri) {
 123
 124                 @Override
 125                 public void register(ReadGraph graph, Listener<RuntimeEnvironment> procedure) {
 126
 127                         SCLContext context = SCLContext.getCurrent();
 128                         Object oldGraph = context.put("graph", graph);
 129                         try {
 130
 131                                 if(procedure.isDisposed()) {
 132                                         UpdateListenerImpl.getRuntimeEnvironment(environmentSpecification, procedure, null);
 133                                 } else {
 134                                         UpdateListenerImpl impl = new UpdateListenerImpl(environmentSpecification, procedure);
 135                                         impl.notifyAboutUpdate();
 136                                                 map.put(parameter, impl);
 137                                 }
 138
 139                         } finally {
 140                                 context.put("graph", oldGraph);
 141                         }
 142
 143                 }
 144
 145                 @Override
 146                 public void unregistered() {
 147                         map.remove(parameter);
 148                 }
 149
 150             });
 151     }
 152
 153     @Override
 154     public int hashCode() {
 155         return 31*getClass().hashCode() + super.hashCode();
 156     }
 157
 158     public static void flush() {
 159         map.clear();
 160     }
 161
 162 }