SystemBackup.java

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