Merging in latest boto.

boto/pyami/installers/ubuntu/ebs.py

 # Copyright (c) 2006-2009 Mitch Garnaat http://garnaat.org/
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish, dis-
 # tribute, sublicense, and/or sell copies of the Software, and to permit
 # persons to whom the Software is furnished to do so, subject to the fol-
 # lowing conditions:
 #
@@ skipping 27 matching lines @@
     volume_id = <the id of the EBS volume, should look like vol-xxxxxxxx>
     logical_volume_name = <the name of the logical volume that contaings 
         a reference to the physical volume to be mounted. If this parameter
         is supplied, it overrides the volume_id setting.>
     device = <the linux device the EBS volume should be mounted on>
     mount_point = <directory to mount device, defaults to /ebs>
 
 """
 import boto
 from boto.manage.volume import Volume
+from boto.exception import EC2ResponseError
 import os, time
 from boto.pyami.installers.ubuntu.installer import Installer
 from string import Template
 
 BackupScriptTemplate = """#!/usr/bin/env python
 # Backup EBS volume
 import boto
 from boto.pyami.scriptbase import ScriptBase
 import traceback
 
 class Backup(ScriptBase):
 
     def main(self):
         try:
             ec2 = boto.connect_ec2()
-            self.run("/usr/sbin/xfs_freeze -f ${mount_point}")
+            self.run("/usr/sbin/xfs_freeze -f ${mount_point}", exit_on_error = True)
             snapshot = ec2.create_snapshot('${volume_id}')
             boto.log.info("Snapshot created: %s " %  snapshot)
         except Exception, e:
             self.notify(subject="${instance_id} Backup Failed", body=traceback.format_exc())
             boto.log.info("Snapshot created: ${volume_id}")
         except Exception, e:
             self.notify(subject="${instance_id} Backup Failed", body=traceback.format_exc())
         finally:
             self.run("/usr/sbin/xfs_freeze -u ${mount_point}")
 
 if __name__ == "__main__":
     b = Backup()
     b.main()
 """
 
 BackupCleanupScript= """#!/usr/bin/env python
 import boto
 from boto.manage.volume import Volume
 
 # Cleans Backups of EBS volumes
 
 for v in Volume.all():
     v.trim_snapshots(True)
 """
     
+TagBasedBackupCleanupScript= """#!/usr/bin/env python
+import boto
+
+# Cleans Backups of EBS volumes
+
+ec2 = boto.connect_ec2()
+ec2.trim_snapshots()
+"""
+
 class EBSInstaller(Installer):
     """
     Set up the EBS stuff
     """
 
     def __init__(self, config_file=None):
         Installer.__init__(self, config_file)
         self.instance_id = boto.config.get('Instance', 'instance-id')
         self.device = boto.config.get('EBS', 'device', '/dev/sdp')
         self.volume_id = boto.config.get('EBS', 'volume_id')
@@ skipping 41 matching lines @@
 
     def create_backup_script(self):
         t = Template(BackupScriptTemplate)
         s = t.substitute(volume_id=self.volume_id, instance_id=self.instance_id,
                          mount_point=self.mount_point)
         fp = open('/usr/local/bin/ebs_backup', 'w')
         fp.write(s)
         fp.close()
         self.run('chmod +x /usr/local/bin/ebs_backup')
 
-    def create_backup_cleanup_script(self):
+    def create_backup_cleanup_script(self, use_tag_based_cleanup = False):
         fp = open('/usr/local/bin/ebs_backup_cleanup', 'w')
-        fp.write(BackupCleanupScript)
+        if use_tag_based_cleanup:
+            fp.write(TagBasedBackupCleanupScript)
+        else:
+            fp.write(BackupCleanupScript)
         fp.close()
         self.run('chmod +x /usr/local/bin/ebs_backup_cleanup')
 
     def handle_mount_point(self):
         boto.log.info('handle_mount_point')
         if not os.path.isdir(self.mount_point):
             boto.log.info('making directory')
             # mount directory doesn't exist so create it
             self.run("mkdir %s" % self.mount_point)
         else:
@@ skipping 37 matching lines @@
 
         # Set up the backup script
         minute = boto.config.get('EBS', 'backup_cron_minute', '0')
         hour = boto.config.get('EBS', 'backup_cron_hour', '4,16')
         self.add_cron("ebs_backup", "/usr/local/bin/ebs_backup", minute=minute, hour=hour)
 
         # Set up the backup cleanup script
         minute = boto.config.get('EBS', 'backup_cleanup_cron_minute')
         hour = boto.config.get('EBS', 'backup_cleanup_cron_hour')
         if (minute != None) and (hour != None):
-            self.create_backup_cleanup_script();
+            # Snapshot clean up can either be done via the manage module, or via the new tag based
+            # snapshot code, if the snapshots have been tagged with the name of the associated 
+            # volume. Check for the presence of the new configuration flag, and use the appropriate
+            # cleanup method / script:
+            use_tag_based_cleanup = boto.config.has_option('EBS', 'use_tag_based_snapshot_cleanup')
+            self.create_backup_cleanup_script(use_tag_based_cleanup);
             self.add_cron("ebs_backup_cleanup", "/usr/local/bin/ebs_backup_cleanup", minute=minute, hour=hour)
 
         # Set up the fstab
         self.update_fstab()
 
     def main(self):
         if not os.path.exists(self.device):
             self.install()
         else:
             boto.log.info("Device %s is already attached, skipping EBS Installer" % self.device)