bundles/org.simantics.db.testing/src/org/simantics/db/testing/common/Tests.java

   1 package org.simantics.db.testing.common;
   2
   3
   4 import java.io.File;
   5 import java.io.FileInputStream;
   6 import java.io.InputStream;
   7 import java.util.ArrayList;
   8 import java.util.Collection;
   9
  10 import org.eclipse.core.runtime.Platform;
  11 import org.simantics.DefaultChoiceUserAgent;
  12 import org.simantics.Simantics;
  13 import org.simantics.SimanticsPlatform;
  14 import org.simantics.SimanticsPlatform.OntologyRecoveryPolicy;
  15 import org.simantics.SimanticsPlatform.RecoveryPolicy;
  16 import org.simantics.databoard.Bindings;
  17 import org.simantics.databoard.Files;
  18 import org.simantics.databoard.binding.Binding;
  19 import org.simantics.databoard.binding.error.BindingConstructionException;
  20 import org.simantics.db.Resource;
  21 import org.simantics.db.Session;
  22 import org.simantics.db.Statement;
  23 import org.simantics.db.exception.DatabaseException;
  24 import org.simantics.db.layer0.util.RuntimeEnvironmentRequest;
  25 import org.simantics.db.management.ISessionContextProvider;
  26 import org.simantics.db.management.ISessionContextProviderSource;
  27 import org.simantics.db.management.SessionContext;
  28 import org.simantics.db.management.SessionContextProvider;
  29 import org.simantics.db.management.SingleSessionContextProviderSource;
  30 import org.simantics.db.service.LifecycleSupport;
  31 import org.simantics.db.testing.impl.Configuration;
  32 import org.simantics.graph.db.TransferableGraphs;
  33 import org.simantics.graph.representation.TransferableGraph1;
  34 import org.simantics.scl.osgi.SCLOsgi;
  35
  36 public class Tests {
  37     private static TestHandler testHandler;
  38     public static boolean contains(Collection<Statement> stms, Resource predicate, Resource object) {
  39         for(Statement stm : stms) {
  40             if(stm.getPredicate().equals(predicate) && stm.getObject().equals(object)) return true;
  41         }
  42         return false;
  43     }
  44
  45     public static boolean contains(Collection<Statement> stms, Resource subject, Resource predicate, Resource object) {
  46         for(Statement stm : stms) {
  47             if(stm.getSubject().equals(subject) && stm.getPredicate().equals(predicate) && stm.getObject().equals(object)) return true;
  48         }
  49         return false;
  50     }
  51     public static DatabaseState freshWorkspace(String CORE_DIR, ArrayList<String> fileFilter) throws Exception {
  52         SimanticsPlatform.INSTANCE.resetWorkspace(null, fileFilter);
  53         return newSimanticsWorkspace(null, CORE_DIR);
  54     }
  55     public static void freshDatabase() throws Exception {
  56         DatabaseState state = freshWorkspace(Configuration.get().coreDir, null);
  57         Tests.shutdown(state);
  58     }
  59     public static DatabaseState existingDatabase() throws Exception {
  60         return oldSimanticsWorkspace(null, Configuration.get().coreDir);
  61     }
  62     private static void initSimanticsStuff() {
  63         // Set session context provider.
  64         final ISessionContextProvider provider = new SessionContextProvider(null);
  65         ISessionContextProviderSource source = new SingleSessionContextProviderSource(provider);
  66         Simantics.setSessionContextProviderSource(source);
  67         org.simantics.db.layer0.internal.SimanticsInternal.setSessionContextProviderSource(source);
  68     }
  69     public static DatabaseState newSimanticsWorkspace(TestSettings testSettings, String address) throws Exception {
  70         TestHandler testHandler = Tests.getTestHandler(testSettings, address);
  71         testHandler.initNew();
  72         initSimanticsStuff();
  73         SessionContext sessionContext = SimanticsPlatform.INSTANCE.startUp(Simantics.getDefaultDatabaseDriver(), null, RecoveryPolicy.FixError, OntologyRecoveryPolicy.Merge, true, new DefaultChoiceUserAgent());
  74        return new DatabaseState(address, sessionContext);
  75     }
  76     public static DatabaseState oldSimanticsWorkspace(TestSettings testSettings, String address) throws Exception {
  77         Tests.getTestHandler(testSettings, address);
  78         initSimanticsStuff();
  79         SessionContext sessionContext = SimanticsPlatform.INSTANCE.startUp(Simantics.getDefaultDatabaseDriver(), null, RecoveryPolicy.FixError, OntologyRecoveryPolicy.Merge, false, null);
  80         return new DatabaseState(address, sessionContext);
  81     }
  82 //        for (String ontology : testSettings.getOntologies()) {
  83 //            initOntology(session, ontology);
  84 //        }
  85 //        String[] adapters = testSettings.getAdapters();
  86 //        if(adapters != null) {
  87 //            File[] files = new File[adapters.length];
  88 //            for(int i=0;i<adapters.length;i++)
  89 //                files[i] = new File(testSettings.getWorkspace(), adapters[i]);
  90 //            System.err.println("Loading adapters: " + Arrays.toString(files));
  91 //            AdapterRegistry2.getInstance().initialize(testSettings.getClass().getClassLoader(), null, files);
  92 //            new AdaptionServiceInitializer().initialize(session);
  93 //        }
  94 //        return new DatabaseState(testHandler.getServer(), SessionContext.create(session, false));
  95 //    }
  96 //    @SuppressWarnings("deprecation")
  97 //    private static DatabaseState initPlatform(TestHandler testHandler, boolean fresh) throws Exception {
  98 //            // Starts database server.
  99 //            SimanticsPlatform.INSTANCE.startUpExisting(null, RecoveryPolicy.ThrowError, true);
 100 //            return new DatabaseState(SimanticsPlatform.INSTANCE.server, SimanticsPlatform.INSTANCE.sessionContext);
 101 //        }
 102 //    }
 103 //    private static DatabaseState initDatabase(TestHandler testHandler, boolean fresh) throws DatabaseException {
 104 //        TestSettings settings = TestSettings.getInstance();
 105 //        if (fresh)
 106 //            testHandler.initNew();
 107 //        else
 108 //            testHandler.initOld();
 109 //        Session session = testHandler.getSession();
 110 //        if (fresh) {
 111 //            for(String ontology : settings.getOntologies()) {
 112 //                initOntology(session, ontology);
 113 //            }
 114 //        }
 115 //        String[] adapters = settings.getAdapters();
 116 //        if(adapters != null) {
 117 //            File[] files = new File[adapters.length];
 118 //            for(int i=0;i<adapters.length;i++)
 119 //                files[i] = new File(settings.getWorkspace(), adapters[i]);
 120 //            System.err.println("Loading adapters: " + Arrays.toString(files));
 121 //            AdapterRegistry2.getInstance().initialize(settings.getClass().getClassLoader(), null, files);
 122 //            new AdaptionServiceInitializer().initialize(session);
 123 //        }
 124 //        return new DatabaseState(testHandler.getServer(), SessionContext.create(session, false));
 125 //    }
 126 //    private static DatabaseState initDatabaseDep(TestHandler testHandler, boolean fresh) throws Exception {
 127 //        if (Platform.isRunning())
 128 //            return initPlatform(testHandler, fresh);
 129 //        else
 130 //            return initDatabase(testHandler, fresh);
 131 //    }
 132     public static void shutdown(DatabaseState state) throws Exception {
 133         if (SCLOsgi.MODULE_REPOSITORY != null)
 134             SCLOsgi.MODULE_REPOSITORY.flush();
 135         SCLOsgi.SOURCE_REPOSITORY = null;
 136         SCLOsgi.MODULE_REPOSITORY = null;
 137         SCLOsgi.TEST_REPOSITORY = null;
 138
 139         if (Platform.isRunning()) {
 140             SimanticsPlatform.INSTANCE.shutdown(null);
 141             return;
 142         } // Cleanup without platform code.
 143         if (null == state)
 144             return;
 145         String address = state.getAddress();
 146         try {
 147             if (null != address)
 148                 getTestHandler(null, address).getManagement().shutdown();
 149         } catch (Throwable t) {
 150             System.out.println(t);
 151         }
 152     }
 153
 154     public static void initOntology(Session session, String relative)
 155     throws DatabaseException {
 156         // Open transferable graph file for layer0.
 157         Binding binding;
 158         try {
 159             binding = Bindings.getBinding(TransferableGraph1.class);
 160         } catch (BindingConstructionException e) {
 161             throw new DatabaseException(e);
 162         }
 163         File t = new File(TestSettings.getInstance().getWorkspace(), relative);
 164         if (!t.exists())
 165             throw new DatabaseException("File does not exist. File=" + t + ".");
 166
 167         TransferableGraph1 layer0;
 168         try {
 169             InputStream is = new FileInputStream(t);
 170             layer0 = (TransferableGraph1) Files.readFile(is, binding);
 171             is.close();
 172         } catch (Exception e) {
 173             e.printStackTrace();
 174             throw new DatabaseException(e);
 175         }
 176         try {
 177             TransferableGraphs.importGraph(session, layer0);
 178         } catch (Throwable e) {
 179             e.printStackTrace();
 180             throw new DatabaseException("Failed to init db.", e);
 181         }
 182     }
 183 //    public static TestHandler newTestHandler(TestSettings testSettings, String dbFolderName) throws DatabaseException {
 184 //        return new TestHandler(testSettings, dbFolderName);
 185 //    }
 186     public static TestHandler getTestHandler() throws DatabaseException {
 187         return getTestHandler(null, null);
 188     }
 189     public static TestHandler getTestHandler(TestSettings testSettings, String address) throws DatabaseException {
 190         if (null == testHandler)
 191             testHandler = new TestHandler(testSettings, address);
 192         return testHandler;
 193     }
 194     public static void closeSession(Session session) throws DatabaseException {
 195         try {
 196             LifecycleSupport support = session.getService(LifecycleSupport.class);
 197             support.close(-1, false);
 198             session = null;
 199         } catch (Exception e) {
 200             session = null;
 201             throw new DatabaseException("Sessuion did not close cleanly.");
 202         }
 203     }
 204     public static void killCore() throws DatabaseException {
 205
 206     }
 207 }