bundles/org.simantics.db.services/src/org/simantics/db/services/activation/ActivationManager.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.db.services.activation;
  13
  14 import org.simantics.db.Disposable;
  15 import org.simantics.db.ReadGraph;
  16 import org.simantics.db.Resource;
  17 import org.simantics.db.Session;
  18 import org.simantics.db.WriteGraph;
  19 import org.simantics.db.common.CommentMetadata;
  20 import org.simantics.db.common.request.WriteRequest;
  21 import org.simantics.db.common.utils.CommonDBUtils;
  22 import org.simantics.db.common.utils.Logger;
  23 import org.simantics.db.common.utils.NameUtils;
  24 import org.simantics.db.exception.DatabaseException;
  25 import org.simantics.layer0.utils.queries.QueryExecutor2;
  26 import org.simantics.layer0.utils.triggers.IActivation;
  27 import org.simantics.layer0.utils.triggers.IActivationManager;
  28 import org.simantics.layer0.utils.triggers.IModification;
  29 import org.simantics.layer0.utils.triggers.ITrigger;
  30 import org.simantics.operation.Layer0X;
  31 import org.simantics.utils.logging.TimeLogger;
  32 import org.simantics.utils.threads.logger.IThreadLogger;
  33 import org.simantics.utils.threads.logger.ThreadLogger;
  34
  35 @SuppressWarnings("deprecation") // No replacement given so now way to fix this error.
  36 public class ActivationManager implements IActivationManager, Disposable {
  37
  38         Session session;
  39         static IThreadLogger threadLogger = ThreadLogger.getInstance();
  40
  41         class Activation extends QueryExecutor2 implements IActivation {
  42                 final boolean DEBUG = false;
  43                 final boolean BREAK_INFINITE_ACTIVATION_LOOPS = true;
  44
  45                 /**
  46                  * After {@value InfiniteLoop} the activation will be forcibly
  47                  * deactivated if {@link #BREAK_INFINITE_ACTIVATION_LOOPS} is
  48                  * <code>true</code>.
  49                  */
  50                 final int INFINITE_LOOP_COUNT = 100;
  51
  52                 Resource resource;
  53                 int transactionCount = 0;
  54                 boolean disposed = false;
  55                 boolean runOnce = false;
  56
  57                 public Activation(Resource resource) {
  58                         this.resource = resource;
  59                 }
  60
  61                 public void runOnceAndDeactivate() {
  62                         runOnce = true;
  63                 }
  64
  65                 @Override
  66                 public void run(ReadGraph g) throws DatabaseException {
  67 //                      ITask task = threadLogger.begin("Activation.perform");
  68                         Layer0X L0X = Layer0X.getInstance(g);
  69                         for(Resource r : g.getObjects(resource, L0X.HasTrigger))
  70                                 if(calcModification(g, r) != null)
  71                                         execute(g, r);
  72 //                      task.finish();
  73                 }
  74
  75                 private IModification calcModification(ReadGraph g, Resource trigger) throws DatabaseException {
  76 //                      new Exception().printStackTrace();
  77                         //ITask task = ThreadLogger.getInstance().begin("Activation.calcModification");
  78                         IModification modi = g.syncRequest(g.adapt(trigger, ITrigger.class));
  79                         //task.finish();
  80                         return modi;
  81                 }
  82
  83                 private WriteRequest getRequest(final Resource trigger) {
  84                         return new WriteRequest() {
  85                 @Override
  86                 public void perform(WriteGraph g) throws DatabaseException {
  87                     int count = 0;
  88                     while (true) {
  89
  90                         CommonDBUtils.selectClusterSet(g, trigger);
  91
  92                         TimeLogger.log("ActivationManager: start calculating modification");
  93                         IModification modification = calcModification(g, trigger);
  94                         TimeLogger.log("ActivationManager: finished calculating modification");
  95                         if (modification != null)
  96                             ++count;
  97                         else {
  98                             if (count > 0) {
  99                                 CommentMetadata cm = g.getMetadata(CommentMetadata.class);
 100                                 String msg = "ActivationManager modification count=" + count;
 101                                 g.addMetadata(cm.add(msg));
 102                                 if (DEBUG)
 103                                     System.out.println("DEBUG: " + msg);
 104                             }
 105                             if(runOnce)
 106                                 deactivate();
 107                             return;
 108                         }
 109                         if (BREAK_INFINITE_ACTIVATION_LOOPS) {
 110                             if (count > INFINITE_LOOP_COUNT) {
 111                                 deactivate();
 112                                 String msg = "Possible dynamic activation loop. Forcing break."
 113                                         + "Loop count was " + count
 114                                         + ". Activated resource was "
 115                                         + NameUtils.getURIOrSafeNameInternal(g, resource) + ".";
 116                                 System.out.println("WARNING: " + msg);
 117                                 throw new DatabaseException(msg);
 118                             }
 119                         }
 120                         try {
 121                             modification.perform(g);
 122                             TimeLogger.log("ActivationManager: performed modification");
 123                         } catch (DatabaseException e) {
 124                             deactivate();
 125                             throw e;
 126                         }
 127                     }
 128                 }
 129             };
 130                 }
 131
 132         private void executeOnce(WriteGraph graph, final Resource trigger) throws DatabaseException {
 133             getRequest(trigger).perform(graph);
 134 //              graph.syncRequest(getRequest(trigger));
 135         }
 136
 137                 private void execute(final ReadGraph graph, final Resource trigger) {
 138             graph.asyncRequest(getRequest(trigger));
 139         }
 140
 141                 @Override
 142                 public void deactivate() {
 143                         disposed = true;
 144                 }
 145
 146                 @Override
 147                 public boolean isDisposed() {
 148                         return disposed || session == null;
 149                 }
 150
 151         }
 152
 153         public ActivationManager(Session session) {
 154                 this.session = session;
 155         }
 156
 157         @Override
 158         public IActivation activate(Resource r) {
 159             Session s = session;
 160             if (s == null)
 161                 throw new IllegalStateException("ActivationManager is disposed");
 162                 Activation activation = new Activation(r);
 163                 try {
 164                         activation.execute(session);
 165                 } catch (DatabaseException e) {
 166                         Logger.defaultLogError(e);
 167                 }
 168                 return activation;
 169         }
 170
 171         @Override
 172         public IActivation activate(WriteGraph graph, Resource r) throws DatabaseException {
 173             Session s = session;
 174             if (s == null)
 175                 throw new IllegalStateException("ActivationManager is disposed");
 176                 Activation activation = new Activation(r);
 177                 activation.execute(graph);
 178                 return activation;
 179         }
 180
 181         @Override
 182         public void activateOnce(Resource resource) {
 183                 activate(resource).runOnceAndDeactivate();
 184         }
 185
 186         @Override
 187         public void activateOnce(WriteGraph graph, Resource resource) throws DatabaseException {
 188
 189             Session s = session;
 190             if (s == null)
 191                 throw new IllegalStateException("ActivationManager is disposed");
 192
 193             Layer0X L0X = Layer0X.getInstance(graph);
 194                 for(Resource r : graph.getObjects(resource, L0X.HasTrigger)) {
 195                         new Activation(resource).executeOnce(graph, r);
 196                 }
 197
 198
 199         }
 200
 201         @Override
 202         public void dispose() {
 203             session = null;
 204         }
 205
 206 }