lib/snap_shot.rb lib/snap_shot/adapters/adapter.rb lib/snap_shot/adapters/mysql.rb @@ -1,63 +1,92 @@ -Snapshot +SnapShot ======== -Snapshot is a plugin that takes snapshots of your database and stores them so you can load them later. +SnapShot is a plugin that takes snapshots of your database and stores them so you can load them later. -I wrote Snapshot for a few purposes. While developing my apps, I found myself reseting my db all the time. After that, going through +I wrote SnapShot for a few purposes. While developing my apps, I found myself reseting my db all the time. After that, going through and reconstructing the data from importing xml & yml files, creating some users etc, I found that I needed snapshot I could load. I needed some ruby magic around mysqldump and importing. Of course you can use it for other things. It makes a handy backup utility as well. Requirements ====== -Snapshot only support mysql at the momement. I plan to add support for Postgres & SQLite soon. Commands are execute inside a shell, -so be sure you have mysqldump & mysql in $PATH. I've not tested Snapshot on windows, so if you use windows, good luck. Let me know -how it goes. Snapshot has no other outside requirements +SnapShot only support mysql at the momement. I plan to add support for Postgres & SQLite soon. Commands are execute inside a shell, +so be sure you have mysqldump & mysql in $PATH. I've not tested SnapShot on windows, so if you use windows, good luck. Let me know +how it goes. SnapShot has no other outside requirements. Install ======= Step 1 - ./script/plugin install git://github.com/Adman65/Snapshot.git + ./script/plugin install git://github.com/Adman65/SnapShot.git Step2 - mkdir /path/to/your/app/db/snapshots + rake snapshots:setup Step3 rake -T to see how to use snapshots Usage ====== -Taking a Snapshot +Taking a SnapShot ------- A snapshot is a dump of your database. If you're using mysql, snapshot uses mysqldump. Taking a snapshot is easy. Use rake and pass it a file name to store - rake snapshots:take['AllUsers'] + rake snapshots:take name="ALotOfProducts" Voilla, you've just taken your first snapshot. This creates file in db/snaphots/all_users.snapshot Your snapshot is also tied to a schema version. You can only load snapshots when the snapshot schema and the current schema are the same. So if you want to load a snapshot from the past, migrate down. -Loading a Snapshot +Loading a SnapShot ------- Loading a snapshot is easy as well. Use the rake task with an argument. Forgot what snapshots you have? rake snapshots:list Now load with - rake snapshots:load['AllUsers'] + rake snapshots:load name="ALotOfProducts" Your database is restored in the exact state it was before. All ID's, records, and associations are present again. -Deleting a Snapshot +Deleting a SnapShot ------- You may want to delete a snapshot. Use: - rake snapshots:destroy['AllUsers'] + rake snapshots:destroy name="ALotOfProducts" This will delete the file in db/snapshots -Customizing Snapshot +You may also want to delete all snapshots. + rake snapshots:destroy:all + +Backups ======= +You may also uses SnapShot for backing up your database. It provides you with tools to backup your db, then restore it from the most recent snapshot. +Back up your production database like this + rake snapshots:backups:take RAILS_ENV=production -You may want to change the way Snapshot works. Say for example, you don't want to store your snapshots with your app, but have a different folder +This creates a timestamped snapshot in app/db/snapshots/backups. You can view all your backups by doing: + rake snapshots:backups:list +SnapShot places no limit to how many backups there are. You are only limited by your hard drive space. + +Oh no! You lost your database, but you've been regularly backing up your database. No prob, SnapShot to the resuce. SnapShot's restore capability +drops the database, then creates a blank slate, migrates up the latests snapshot's version, and repopulates the db. Nice huh? + rake snapshots:backups:restore RAILS_ENV=production +And you're back in action! Painless. + + +Customizing SnapShot +======= + +You may want to change the way SnapShot works. Say for example, you don't want to store your snapshots with your app, but have a different folder else where. Simply create a symlink to snapshots ln -s /var/snapshots me/my/app/db/snapshots + +You may also want to save your backup snapshots in a different directory. This can be accomplished by symlinking as well + ln -s /var/myapp/backups /my/app/db/snapshots/backups + -Snapshots are taken using the current rails environment. If you want to take a snapshot of your production db for backup purposes use: - rake snapshots:take['BackUp'] RAILS_ENV=production +Some Caveats +======= +SnapShot only saves things in your database. It doesn't save things like file uploads or other things you may have created outside of the database. +It is up to you to handle those scenarios. +TODO +========= +1. Add Support for Postgres & SQLite +2. Add S3 support Copyright (c) 2009 Adam Hawkins , released under the MIT license README.markdown @@ -1,2 +1,2 @@ # Include hook code here -require 'snapshot' \ No newline at end of file +require 'snap_shot' \ No newline at end of file init.rb @@ -1,36 +1,74 @@ namespace :snapshots do + desc "Creates snapshot directories" + task :setup => :environment do + path = File.join(RAILS_ROOT,'db','snapshots','backups') + FileUtils.mkdir_p(path) unless File.directory?(path) + end + desc "List all snapshots" - task :list do - Dir.glob("#{Snapshot::LOCATION}/*.snapshot").each { |file| puts File.basename(file,'.snapshot')} + task :list => :environment do + Dir.glob(File.join(SnapShot::LOCATION,"/*.snapshot")).each { |file| puts File.basename(file,'.snapshot').camelcase} end desc "Take a snapshot" - task :take, :name, :needs => :environment do |task,args| - require 'snapshot' - result = Snapshot.take args.name - puts (result) ? 'Snapped!' : 'Snap Failed' + task :take => :environment do + result = SnapShot.take :file => ENV['name'] + puts (result) ? 'Snapped' : 'Snap Failed' end desc "Load a snapshot" - task :load, :name, :needs => :environment do |task,args| - require 'snapshot' - result = Snapshot.load args.name + task :load => :environment do + result = SnapShot.load :file => ENV['name'] puts (result) ? 'Loaded Snapshot' : 'Load Failed' end desc "Delete a snapshot" - task :destroy, :name, :needs => :environment do |task, args| - require 'snapshot' - result = Snapshot.delete args.name + task :destroy => :environment do + result = SnapShot.destroy :file => ENV['name'] puts (result) ? 'Deleted Snapshot' : 'Delete Failed' end - desc "Takes a snapshot of the db and puts it in snapshots/backups" - task :backup => :environment do - require 'snapshot' - path = File.join(RAILS_ROOT,'db','snapshots','backups') - FileUtils.mkdir(path) unless File.directory(path) - result = Snapshot.take "backups/#{Time.now.strftime("%Y-%m-%d_%H-%M-%S")}" - puts (result) ? 'Backed up!' : 'Backup Failed' + namespace :destroy do + desc "Delete all snapshosts" + task :all => :environment do + path = File.join(RAILS_ROOT,'db','snapshots','*.snapshot') + files = Dir.glob(path) + files.each do |file| + name = File.basename(file,'.snapshot').camelcase + puts "Deleting #{name}..." + result = SnapShot.destroy :file => name + puts (result) ? 'Deleted Snapshot' : 'Delete Failed' + end + end + end + + + namespace :backup do + desc "Takes a snapshot of the db and puts it in snapshots/backups" + task :take => :environment do + path = File.join(RAILS_ROOT,'db','snapshots','backups') + FileUtils.mkdir(path) unless File.directory?(path) + + result = SnapShot.take :file => Time.now.strftime("%Y-%m-%d-%H-%M-%S"), :path => path + puts (result) ? 'Backed up!' : 'Backup Failed' + end + + desc "Restores your database from the most recent snapshot. If the schema is different, your db is reset and migrated up to snapshot version, then the snapshot is loaded." + task :restore => :environment do + path = File.join(RAILS_ROOT,'db','snapshots','backups') + file = Dir.glob(File.join(path,"*.snapshot")).last + file = File.basename(file,'.snapshot') + result = SnapShot.restore :file => file, :path => path + puts (result) ? 'Restored!' : 'Restore Failed' + end + + desc "Lists all backup snapshots" + task :list => :environment do + Dir.glob(File.join(SnapShot::LOCATION,"backups","*.snapshot")).each do |file| + parts = File.basename(file,'.snapshot').split('_') + parts = parts.map {|part| part.to_i} + puts DateTime.civil(parts[0],parts[1],parts[2],parts[3],parts[4],parts[5]).strftime("%Y-%m-%d %H:%M:%S") + end + end end end \ No newline at end of file tasks/snapshot_tasks.rake lib/snapshot.rb lib/snapshot/adapters/adapter.rb lib/snapshot/adapters/mysql.rb lib/snapshot/errors.rb cda43b1a983c68fbe0645ffcd91eb1e85bfea707 Adman65 Adman1965@gmail.com http://github.com/Adman65/Snapshot/commit/e5f712644a1ab0076223916b42b048d21333d924 e5f712644a1ab0076223916b42b048d21333d924 2009-06-30T01:01:01-07:00 2009-06-30T01:01:01-07:00 Version 0.2 Reworked the rake task to feel like other tasks Created a functional backup utility Added some output to take/load/restore to give the user an idea of what's going on Added some extra funcionality to the rake task db31b18ce4f08448a93c27c7b766764b7b74dadd Adman65 Adman1965@gmail.com