bundles/org.simantics.backup.db/src/org/simantics/backup/db/ModelledBackupProvider.java

   1 package org.simantics.backup.db;
   2
   3 import java.nio.file.Path;
   4 import java.util.ArrayList;
   5 import java.util.HashSet;
   6 import java.util.List;
   7 import java.util.concurrent.Callable;
   8 import java.util.concurrent.ExecutionException;
   9 import java.util.concurrent.Future;
  10 import java.util.concurrent.FutureTask;
  11
  12 import org.eclipse.core.runtime.CoreException;
  13 import org.eclipse.core.runtime.IStatus;
  14 import org.eclipse.core.runtime.MultiStatus;
  15 import org.eclipse.core.runtime.Status;
  16 import org.simantics.Simantics;
  17 import org.simantics.backup.Activator;
  18 import org.simantics.backup.BackupException;
  19 import org.simantics.backup.Backups;
  20 import org.simantics.backup.IBackupProvider;
  21 import org.simantics.backup.ontology.BackupResource;
  22 import org.simantics.db.ReadGraph;
  23 import org.simantics.db.Resource;
  24 import org.simantics.db.common.request.UniqueRead;
  25 import org.simantics.db.exception.DatabaseException;
  26 import org.simantics.db.layer0.adapter.Instances;
  27 import org.simantics.db.layer0.util.Layer0Utils;
  28 import org.simantics.db.layer0.variable.Variable;
  29 import org.simantics.db.layer0.variable.Variables;
  30
  31 public class ModelledBackupProvider implements IBackupProvider {
  32
  33     List<IBackupProvider> modelledBackups = new ArrayList<>();
  34
  35     public ModelledBackupProvider() {
  36         // Should this be on the constructor or can there be dynamic ontologies?
  37         this.modelledBackups = getModelledBackups();
  38         }
  39
  40     @Override
  41     public void lock() throws BackupException {
  42         Backups.lock(modelledBackups);
  43     }
  44
  45     @Override
  46     public Future<BackupException> backup(Path targetPath, int revision) throws BackupException {
  47         final List<Future<BackupException>> backups = new ArrayList<>();
  48         final List<Exception> exceptions = new ArrayList<>(backups.size());
  49         for (IBackupProvider modelledBackup : modelledBackups) {
  50             try {
  51                 Future<BackupException> future = modelledBackup.backup(targetPath, revision);
  52                 backups.add(future);
  53             } catch (BackupException e) {
  54                 exceptions.add(e);
  55             }
  56         }
  57         FutureTask<BackupException> task = new FutureTask<>(new Callable<BackupException>() {
  58
  59             @Override
  60             public BackupException call() throws Exception {
  61                 for (Future<BackupException> f : backups) {
  62                     try {
  63                         Exception exception = f.get();
  64                         if (exception != null)
  65                             exceptions.add(exception);
  66                     } catch (InterruptedException | ExecutionException e) {
  67                         exceptions.add(e);
  68                     }
  69                 }
  70                 BackupException problem = null;
  71                 // Throw BackupException if any of the backup operations failed.
  72                 if (!exceptions.isEmpty()) {
  73                     IStatus[] ss = exceptions.stream()
  74                             .map(e -> new Status(IStatus.ERROR, Activator.BUNDLE_ID, e.getMessage(), e))
  75                             .toArray(IStatus[]::new);
  76                     problem = new BackupException(new CoreException(new MultiStatus(Activator.BUNDLE_ID, 0, ss,
  77                             "Backup operation(s) failed to complete.", null)));
  78                 }
  79                 return problem;
  80             }
  81         });
  82         new Thread(task).run();
  83         return task;
  84     }
  85
  86     @Override
  87     public void unlock() throws BackupException {
  88         Backups.unlock(modelledBackups);
  89     }
  90
  91     @Override
  92     public void restore(Path fromPath, int revision) throws BackupException {
  93         for (IBackupProvider modelledBackup : modelledBackups) {
  94             modelledBackup.restore(fromPath, revision);
  95         }
  96     }
  97
  98
  99     private List<IBackupProvider> getModelledBackups() {
 100         List<IBackupProvider> modelledProviders = new ArrayList<>(0);
 101         try {
 102              modelledProviders = Simantics.getSession().syncRequest(new UniqueRead<List<IBackupProvider>>() {
 103
 104                 @Override
 105                 public List<IBackupProvider> perform(ReadGraph graph) throws DatabaseException {
 106                     BackupResource BACKUP = BackupResource.getInstance(graph);
 107                     Instances query = graph.adapt(BACKUP.ModelledBackupProvider, Instances.class);
 108
 109                     HashSet<Resource> providers = new HashSet<>();
 110
 111                     List<Resource> ontologies = Layer0Utils.listOntologies(graph);
 112                     for (Resource ontology : ontologies) {
 113                         for(Resource provider : query.find(graph, ontology)) {
 114                             providers.add(provider);
 115                         }
 116                     }
 117                     List<IBackupProvider> modelledBackups = new ArrayList<>();
 118                     for (Resource provider : providers) {
 119                         Variable variable = Variables.getVariable(graph, provider);
 120                         IBackupProvider modelledBackup = variable.getPropertyValue(graph, "instance");
 121                         modelledBackups.add(modelledBackup);
 122                     }
 123
 124                     return modelledBackups;
 125                 }
 126             });
 127         } catch (DatabaseException e) {
 128             e.printStackTrace();
 129         }
 130         return modelledProviders;
 131     }
 132
 133 }