bundles/org.simantics.modeling/src/org/simantics/modeling/utils/ExperimentExistenceWatchdog.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
   3  * in Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.modeling.utils;
  13
  14 import org.eclipse.core.runtime.IProgressMonitor;
  15 import org.eclipse.core.runtime.IStatus;
  16 import org.eclipse.core.runtime.Status;
  17 import org.eclipse.core.runtime.SubMonitor;
  18 import org.eclipse.core.runtime.jobs.Job;
  19 import org.simantics.DatabaseJob;
  20 import org.simantics.Simantics;
  21 import org.simantics.db.ReadGraph;
  22 import org.simantics.db.Resource;
  23 import org.simantics.db.Session;
  24 import org.simantics.db.common.procedure.adapter.ListenerAdapter;
  25 import org.simantics.db.common.request.ParametrizedRead;
  26 import org.simantics.db.common.request.UnaryRead;
  27 import org.simantics.db.exception.DatabaseException;
  28 import org.simantics.db.request.Read;
  29 import org.simantics.simulation.experiment.ExperimentState;
  30 import org.simantics.simulation.experiment.IExperiment;
  31 import org.simantics.simulation.experiment.IExperimentListener;
  32 import org.simantics.ui.workbench.editor.input.InputValidationCombinators;
  33 import org.simantics.utils.ui.ExceptionUtils;
  34
  35 /**
  36  * @author Tuukka Lehtonen
  37  */
  38 public class ExperimentExistenceWatchdog {
  39
  40     public static ExperimentExistenceWatchdog activate(IExperiment experiment, Resource experimentResource) {
  41         ExperimentExistenceWatchdog validator = new ExperimentExistenceWatchdog(experiment, experimentResource,
  42                 InputValidationCombinators.hasURI());
  43         validator.attachExperimentListener();
  44         validator.activateValidation();
  45         return validator;
  46     }
  47
  48     private Session                                   session;
  49     private final Resource                            experimentResource;
  50     private IExperiment                               experiment;
  51     private final ParametrizedRead<Resource, Boolean> inputValidator;
  52     private InputListener                             inputListener;
  53
  54     private ExperimentExistenceWatchdog(IExperiment experiment, Resource experimentResource, ParametrizedRead<Resource, Boolean> inputValidator) {
  55         this.session = Simantics.getSession();
  56         this.experiment = experiment;
  57         this.experimentResource = experimentResource;
  58         this.inputValidator = inputValidator;
  59     }
  60
  61     private void attachExperimentListener() {
  62         experiment.addListener(new IExperimentListener() {
  63             @Override
  64             public void stateChanged(ExperimentState state) {
  65                 if (state == ExperimentState.DISPOSED) {
  66                     if (!isDisposed())
  67                         dispose();
  68                 }
  69             }
  70         });
  71     }
  72
  73     public void dispose() {
  74         deactivateValidation();
  75         experiment = null;
  76         session = null;
  77     }
  78
  79     protected boolean isDisposed() {
  80         return session == null || experimentResource == null || experiment == null;
  81     }
  82
  83     public synchronized void activateValidation() {
  84         if (isDisposed())
  85             throw new IllegalStateException(this + " is disposed");
  86         if (inputListener != null)
  87             return;
  88
  89         inputListener = new InputListener();
  90         session.asyncRequest(validationRequest(), inputListener);
  91     }
  92
  93     public synchronized void deactivateValidation() {
  94         if (isDisposed())
  95             throw new IllegalStateException(this + " is disposed");
  96         if (inputListener == null)
  97             return;
  98         inputListener.dispose();
  99         inputListener = null;
 100     }
 101
 102     /**
 103      * @param input
 104      * @return a read request that returns <code>true</code> for valid inputs
 105      *         and <code>false</code> for non-existent or invalid inputs.
 106      */
 107     private Read<Boolean> validationRequest() {
 108         return new UnaryRead<Resource, Boolean>(experimentResource) {
 109             @Override
 110             public Boolean perform(ReadGraph graph) throws DatabaseException {
 111                 return graph.syncRequest(inputValidator.get(experimentResource));
 112             }
 113         };
 114     }
 115
 116     private class InputListener extends ListenerAdapter<Boolean> {
 117
 118         private boolean disposed = false;
 119
 120         public void dispose() {
 121             disposed = true;
 122         }
 123
 124         @Override
 125         public void execute(Boolean evaluation) {
 126             if (!Boolean.TRUE.equals(evaluation)) {
 127                 scheduleExperimentShutdown(experiment);
 128             }
 129         }
 130
 131         @Override
 132         public void exception(Throwable t) {
 133             ExceptionUtils.logError("ResourceEditorSupport.InputListener received an unexpected exception.", t);
 134         }
 135
 136         @Override
 137         public boolean isDisposed() {
 138             return disposed || ExperimentExistenceWatchdog.this.isDisposed();
 139         }
 140     }
 141
 142     private static void scheduleExperimentShutdown(final IExperiment experiment) {
 143         Job job = new DatabaseJob("Experiment Shutdown Watchdog") {
 144             @Override
 145             protected IStatus run(IProgressMonitor monitor) {
 146                 SubMonitor mon = SubMonitor.convert(monitor, "Shutdown", 100000);
 147                 try {
 148                     experiment.shutdown(mon.newChild(100000));
 149                     return Status.OK_STATUS;
 150                 } finally {
 151                     monitor.done();
 152                 }
 153             }
 154         };
 155         job.schedule();
 156     }
 157
 158 }