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