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

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