org.argeo.cms/src/org/argeo/cms/internal/backup/SystemBackup.java

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