org.argeo.slc.cms/src/org/argeo/slc/backup/vfs/SystemBackup.java

   1 package org.argeo.slc.backup.vfs;
   2
   3 import java.util.ArrayList;
   4 import java.util.HashMap;
   5 import java.util.List;
   6 import java.util.Map;
   7
   8 import org.apache.commons.vfs2.FileObject;
   9 import org.apache.commons.vfs2.FileSystemException;
  10 import org.apache.commons.vfs2.FileSystemManager;
  11 import org.apache.commons.vfs2.FileSystemOptions;
  12 import org.apache.commons.vfs2.Selectors;
  13 import org.apache.commons.vfs2.UserAuthenticator;
  14 import org.apache.commons.vfs2.impl.DefaultFileSystemConfigBuilder;
  15 import org.argeo.api.cms.CmsLog;
  16 import org.argeo.cms.util.LangUtils;
  17
  18 /**
  19  * Combines multiple backups and transfer them to a remote location. Purges
  20  * remote and local data based on certain criteria.
  21  */
  22 public class SystemBackup implements Runnable {
  23         private final static CmsLog log = CmsLog.getLog(SystemBackup.class);
  24
  25         private FileSystemManager fileSystemManager;
  26         private UserAuthenticator userAuthenticator = null;
  27
  28         private String backupsBase;
  29         private String systemName;
  30
  31         private List<AtomicBackup> atomicBackups = new ArrayList<AtomicBackup>();
  32         private BackupPurge backupPurge = new SimpleBackupPurge();
  33
  34         private Map<String, UserAuthenticator> remoteBases = new HashMap<String, UserAuthenticator>();
  35
  36         @Override
  37         public void run() {
  38                 if (atomicBackups.size() == 0)
  39                         throw new MaintenanceException("No atomic backup listed");
  40                 List<String> failures = new ArrayList<String>();
  41
  42                 SimpleBackupContext backupContext = new SimpleBackupContext(fileSystemManager, backupsBase, systemName);
  43
  44                 // purge older backups
  45                 FileSystemOptions opts = new FileSystemOptions();
  46                 try {
  47                         DefaultFileSystemConfigBuilder.getInstance().setUserAuthenticator(opts, userAuthenticator);
  48                 } catch (Exception e) {
  49                         throw new MaintenanceException("Cannot create authentication", e);
  50                 }
  51
  52                 try {
  53
  54                         backupPurge.purge(fileSystemManager, backupsBase, systemName, backupContext.getDateFormat(), opts);
  55                 } catch (Exception e) {
  56                         failures.add("Purge " + backupsBase + " failed: " + e.getMessage());
  57                         log.error("Purge of " + backupsBase + " failed", e);
  58                 }
  59
  60                 // perform backup
  61                 for (AtomicBackup atomickBackup : atomicBackups) {
  62                         try {
  63                                 String target = atomickBackup.backup(fileSystemManager, backupsBase, backupContext, opts);
  64                                 if (log.isDebugEnabled())
  65                                         log.debug("Performed backup " + target);
  66                         } catch (Exception e) {
  67                                 String msg = "Atomic backup " + atomickBackup.getName() + " failed: "
  68                                                 + LangUtils.chainCausesMessages(e);
  69                                 failures.add(msg);
  70                                 log.error(msg);
  71                                 if (log.isTraceEnabled())
  72                                         log.trace("Stacktrace of atomic backup " + atomickBackup.getName() + " failure.", e);
  73                         }
  74                 }
  75
  76                 // dispatch to remote
  77                 for (String remoteBase : remoteBases.keySet()) {
  78                         FileObject localBaseFo = null;
  79                         FileObject remoteBaseFo = null;
  80                         UserAuthenticator auth = remoteBases.get(remoteBase);
  81
  82                         // authentication
  83                         FileSystemOptions remoteOpts = new FileSystemOptions();
  84                         try {
  85                                 DefaultFileSystemConfigBuilder.getInstance().setUserAuthenticator(remoteOpts, auth);
  86                                 backupPurge.purge(fileSystemManager, remoteBase, systemName, backupContext.getDateFormat(), remoteOpts);
  87                         } catch (Exception e) {
  88                                 failures.add("Purge " + remoteBase + " failed: " + e.getMessage());
  89                                 log.error("Cannot purge " + remoteBase, e);
  90                         }
  91
  92                         try {
  93                                 localBaseFo = fileSystemManager.resolveFile(backupsBase + '/' + backupContext.getRelativeFolder(),
  94                                                 opts);
  95                                 remoteBaseFo = fileSystemManager.resolveFile(remoteBase + '/' + backupContext.getRelativeFolder(),
  96                                                 remoteOpts);
  97                                 remoteBaseFo.copyFrom(localBaseFo, Selectors.SELECT_ALL);
  98                                 if (log.isDebugEnabled())
  99                                         log.debug("Copied backup to " + remoteBaseFo + " from " + localBaseFo);
 100                                 // }
 101                         } catch (Exception e) {
 102                                 failures.add("Dispatch to " + remoteBase + " failed: " + e.getMessage());
 103                                 log.error("Cannot dispatch backups from " + backupContext.getRelativeFolder() + " to " + remoteBase, e);
 104                         }
 105                         BackupUtils.closeFOQuietly(localBaseFo);
 106                         BackupUtils.closeFOQuietly(remoteBaseFo);
 107                 }
 108
 109                 int failureCount = 0;
 110                 if (failures.size() > 0) {
 111                         StringBuffer buf = new StringBuffer();
 112                         for (String failure : failures) {
 113                                 buf.append('\n').append(failureCount).append(" - ").append(failure);
 114                                 failureCount++;
 115                         }
 116                         throw new MaintenanceException(failureCount + " error(s) when running the backup,"
 117                                         + " check the logs and the backups as soon as possible." + buf);
 118                 }
 119         }
 120
 121         public void setFileSystemManager(FileSystemManager fileSystemManager) {
 122                 this.fileSystemManager = fileSystemManager;
 123         }
 124
 125         public void setBackupsBase(String backupsBase) {
 126                 this.backupsBase = backupsBase;
 127         }
 128
 129         public void setSystemName(String name) {
 130                 this.systemName = name;
 131         }
 132
 133         public void setAtomicBackups(List<AtomicBackup> atomicBackups) {
 134                 this.atomicBackups = atomicBackups;
 135         }
 136
 137         public void setBackupPurge(BackupPurge backupPurge) {
 138                 this.backupPurge = backupPurge;
 139         }
 140
 141         public void setUserAuthenticator(UserAuthenticator userAuthenticator) {
 142                 this.userAuthenticator = userAuthenticator;
 143         }
 144
 145         public void setRemoteBases(Map<String, UserAuthenticator> remoteBases) {
 146                 this.remoteBases = remoteBases;
 147         }
 148
 149         // public static void main(String args[]) {
 150         // while (true) {
 151         // try {
 152         // StandardFileSystemManager fsm = new StandardFileSystemManager();
 153         // fsm.init();
 154         //
 155         // SystemBackup systemBackup = new SystemBackup();
 156         // systemBackup.setSystemName("mySystem");
 157         // systemBackup
 158         // .setBackupsBase("/home/mbaudier/dev/src/commons/server/runtime/org.argeo.server.core/target");
 159         // systemBackup.setFileSystemManager(fsm);
 160         //
 161         // List<AtomicBackup> atomicBackups = new ArrayList<AtomicBackup>();
 162         //
 163         // MySqlBackup mySqlBackup = new MySqlBackup("root", "", "test");
 164         // atomicBackups.add(mySqlBackup);
 165         // PostgreSqlBackup postgreSqlBackup = new PostgreSqlBackup(
 166         // "argeo", "argeo", "gis_template");
 167         // atomicBackups.add(postgreSqlBackup);
 168         // SvnBackup svnBackup = new SvnBackup(
 169         // "/home/mbaudier/tmp/testsvnrepo");
 170         // atomicBackups.add(svnBackup);
 171         //
 172         // systemBackup.setAtomicBackups(atomicBackups);
 173         //
 174         // Map<String, UserAuthenticator> remoteBases = new HashMap<String,
 175         // UserAuthenticator>();
 176         // StaticUserAuthenticator userAuthenticator = new StaticUserAuthenticator(
 177         // null, "demo", "demo");
 178         // remoteBases.put("sftp://localhost/home/mbaudier/test",
 179         // userAuthenticator);
 180         // systemBackup.setRemoteBases(remoteBases);
 181         //
 182         // systemBackup.run();
 183         //
 184         // fsm.close();
 185         // } catch (FileSystemException e) {
 186         // // TODO Auto-generated catch block
 187         // e.printStackTrace();
 188         // System.exit(1);
 189         // }
 190         //
 191         // // wait
 192         // try {
 193         // Thread.sleep(120 * 1000);
 194         // } catch (InterruptedException e) {
 195         // e.printStackTrace();
 196         // }
 197         // }
 198         // }
 199 }