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

   1 package org.simantics.backup.db;
   2
   3 import java.nio.file.Path;
   4 import java.util.concurrent.Callable;
   5 import java.util.concurrent.Future;
   6 import java.util.concurrent.FutureTask;
   7
   8 import org.simantics.backup.BackupException;
   9 import org.simantics.backup.IBackupProvider;
  10 import org.simantics.scl.runtime.function.Function1;
  11 import org.simantics.scl.runtime.function.Function2;
  12 import org.simantics.scl.runtime.tuple.Tuple0;
  13
  14 public class ModelledBackup implements IBackupProvider {
  15
  16     private final Function1<Tuple0, Object> lockFunc;
  17     private final Function2<String, Integer, Function1<Tuple0, String>> backupFunc;
  18     private final Function1<Tuple0, Object> unlockFunc;
  19     private final Function2<String, Integer, Object> restoreFunc;
  20
  21     private ModelledBackup(
  22             Function1<Tuple0, Object> lockFunc,
  23             Function2<String, Integer, Function1<Tuple0, String>> backupFunc,
  24             Function1<Tuple0, Object> unlockFunc,
  25             Function2<String, Integer, Object> restoreFunc) {
  26         this.lockFunc = lockFunc;
  27         this.backupFunc = backupFunc;
  28         this.unlockFunc = unlockFunc;
  29         this.restoreFunc = restoreFunc;
  30     }
  31
  32     @Override
  33     public void lock() {
  34         lockFunc.apply(Tuple0.INSTANCE);
  35     }
  36
  37     @Override
  38     public Future<BackupException> backup(Path targetPath, int revision) {
  39
  40         final Function1<Tuple0, String> fn = backupFunc.apply(targetPath.toString(), revision);
  41
  42         final FutureTask<BackupException> futureTask = new FutureTask<BackupException>(new Callable<BackupException>() {
  43                         @Override
  44                         public BackupException call() throws Exception {
  45                                 try {
  46                                         String error = fn.apply(Tuple0.INSTANCE);
  47                                         if (error != null) {
  48                                                 return new BackupException(error);
  49                                         } else {
  50                                                 return null;
  51                                         }
  52                                 } catch (Throwable t) {
  53                                         return new BackupException(t);
  54                                 }
  55                         }
  56         });
  57
  58         Thread thread = new Thread(futureTask, "Backup Provider Thread " + backupFunc.toString());
  59         thread.start();
  60
  61         return futureTask;
  62     }
  63
  64     @Override
  65     public void unlock() {
  66         unlockFunc.apply(Tuple0.INSTANCE);
  67     }
  68
  69     @Override
  70     public void restore(Path fromPath, int revision) {
  71         restoreFunc.apply(fromPath.toString(), revision);
  72     }
  73
  74     public static IBackupProvider modelledBackup(
  75             Function1<Tuple0, Object> lockFunc,
  76             Function2<String, Integer, Function1<Tuple0, String>> backupFunc,
  77             Function1<Tuple0, Object> unlockFunc,
  78             Function2<String, Integer, Object> restoreFunc) {
  79
  80         return new ModelledBackup(lockFunc, backupFunc, unlockFunc, restoreFunc);
  81     }
  82 }