blavosync 0.3.2 → 0.4.0

data/Blavosync.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{blavosync}
-  s.version = "0.3.2"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["jayronc"]
-  s.date = %q{2010-01-05}
+  s.date = %q{2010-03-19}
   s.description = %q{Sync a remote db and rsync content to your development environment.  Useful for small teams and developers who are not able to do this manually.}
   s.email = %q{jerrodblavos@mac.com}
   s.extra_rdoc_files = [

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.4.0

data/lib/blavosync.rb

@@ -1,3 +1,3 @@
 module Blavosync
-  VERSION = '0.1.3'
+  VERSION = '0.4.0'
 end

data/lib/blavosync/recipes/database.rb

@@ -9,6 +9,9 @@ Capistrano::Configuration.instance(:must_exist).load do
       last_modified = Time.now.to_i
       generate_remote_db_backup
       system "mkdir -p #{tmp_dir}"
+      download(db_schema_backup_zip_file, "#{local_db_schema_backup_file(:env=>from_env, :timestamp=>last_modified)}.#{zip_ext}", :via=> :scp) do|ch, name, sent, total|
+        print "\r\033[1;42m  #{File.basename(name)}: #{sent}/#{total} -- #{(sent.to_f * 100 / total.to_f).to_i}% \033[0m"
+      end
       download(db_backup_zip_file, "#{local_db_backup_file(:env=>from_env, :timestamp=>last_modified)}.#{zip_ext}", :via=> :scp) do|ch, name, sent, total|
         print "\r\033[1;42m  #{File.basename(name)}: #{sent}/#{total} -- #{(sent.to_f * 100 / total.to_f).to_i}% \033[0m"
       end
@@ -19,15 +22,28 @@ Capistrano::Configuration.instance(:must_exist).load do
       variable, which defalts to RAILS_ENV), and imports (via mysql command line tool) it back into the database
       defined in the RESTORE_ENV env variable (defaults to development).
     DESC
+
+
     task :restore_db, :roles => :db do
       mysql_str  = "mysql #{mysql_connection_for(to_env)}"
       mysql_dump = "mysqldump  #{mysql_connection_for(from_env)}"
-      local_db_create = "mysql #{mysql_connection_for(to_env)} -e \"create database if not exists #{mysql_db_for(to_env)}\""
+      local_db_create = "mysqladmin create #{mysql_connection_for(to_env)} " #  "create database if not exists #{mysql_db_for(to_env)}"
+      remote_schema_backup_file = local_db_schema_backup_file(:env => from_env, :timestamp=>most_recent_local_backup(from_env, 'schema')).strip
       remote_backup_file = local_db_backup_file(:env => from_env, :timestamp=>most_recent_local_backup(from_env, 'db')).strip
 
-      puts "\n\033[1;42m Restoring database backup to #{to_env} environment FROM #{remote_backup_file}--#{from_env} using #{mysql_str}\033[0m"
+      puts "\n\033[1;42m Attempting to create #{to_env} database \033[0m"
       system(local_db_create.strip)
       cmd = ""
+
+      puts "\n\033[1;42m Restoring database schema to #{to_env} environment FROM #{remote_schema_backup_file}--#{from_env} using #{mysql_str}\033[0m"
+      cmd << <<-CMD
+        #{unzip} -c #{remote_schema_backup_file}.#{zip_ext} > #{remote_schema_backup_file} &&
+        #{mysql_str} < #{remote_schema_backup_file} &&
+        rm -f #{remote_schema_backup_file}
+      CMD
+
+     puts "\n\033[1;42m Restoring database data to #{to_env} environment FROM #{remote_backup_file}--#{from_env} using #{mysql_str}\033[0m"
+
       cmd << <<-CMD
         #{unzip} -c #{remote_backup_file}.#{zip_ext} > #{remote_backup_file} &&
         #{mysql_str} < #{remote_backup_file} &&

data/lib/blavosync/recipes/local.rb

@@ -14,105 +14,134 @@
 # set :tar_content_backup_file,   fetch(:blavosync_tar_content_backup_file,   "#{shared_path}/backup_#{from_env}_content.tar.#{zip_ext}"   )
 # set :db_backup_file,            fetch(:blavosync_db_backup_file,            "#{shared_path}/backup_#{from_env}_db.sql"                   )
 # set :db_backup_zip_file,        fetch(:blavosync_db_backup_zip_file,        "#{db_backup_file}.#{zip_ext}"                               )
-# 
+#
 Capistrano::Configuration.instance(:must_exist).load do |configuration|
 
   def rails_root
     Pathname.new('.').realpath
   end
-  def content_dir                                                
-    exists?(:content_directory) ? fetch(:content_directory) : "system"                                                     
+  def content_dir
+    exists?(:content_directory) ? fetch(:content_directory) : "system"
   end
-  def content_path                                               
-    File.join(fetch(:shared_path), content_dir)                 
-  end                                              
-  def public_path                                               
-    File.join(fetch(:latest_release), 'public')                 
+  def exlude_table_command
+    exists?(:exclude_tables) ? fetch(:exclude_tables).collect {|table| " --ignore-table=#{mysql_db_for(from_env).strip}.#{table} " }.join(" ") : ""
   end
-  def remote_backup_expires                                      
-    100000                                                       
+
+  def content_path
+    File.join(fetch(:shared_path), content_dir)
+  end
+
+  def content_dir
+    exists?(:content_directory) ? fetch(:content_directory) : "system"
+  end
+
+  def public_path
+    File.join(fetch(:latest_release), 'public')
   end
-  def zip                                                        
-    "gzip"                                                       
+  def remote_backup_expires
+    100000
   end
-  def unzip                                                      
-    "gunzip"                                                     
+  def zip
+    "gzip"
   end
-  def zip_ext                                                    
-    "gz"                                                         
+  def unzip
+    "gunzip"
   end
-  def tmp_dir                                                  
-    "tmp"                                                        
+  def zip_ext
+    "gz"
   end
-  def content_sync_method                                      
-    exists?(:sync_method) ? sync_method : 'rsync'                                                      
+  def tmp_dir
+    "tmp"
   end
-  def from_env                                                  
-    (ENV['FROM_ENV'].nil? ? 'production' : ENV['RAILS_ENV'])     
+  def content_sync_method
+    exists?(:sync_method) ? sync_method : 'rsync'
   end
-  def to_env                                                  
-    (ENV['TO_ENV'].nil? ? 'development' : ENV['TO_ENV'])         
+  def from_env
+    (ENV['FROM_ENV'].nil? ? 'production' : ENV['RAILS_ENV'])
   end
-  def rsync_content_backup_file 
-    "#{shared_path}/#{content_dir}"  
+  def to_env
+    (ENV['TO_ENV'].nil? ? 'development' : ENV['TO_ENV'])
+  end
+  def rsync_content_backup_file
+    "#{shared_path}/#{content_dir}"
+  end
+  def tar_content_backup_file
+    "#{shared_path}/backup_#{from_env}_content.tar.#{zip_ext}"
+  end
+
+  def db_schema_backup_file
+    "#{shared_path}/backup_#{from_env}_schema.sql"
+
   end
-  def tar_content_backup_file                                   
-    "#{shared_path}/backup_#{from_env}_content.tar.#{zip_ext}"   
+
+  def db_schema_backup_zip_file
+    "#{db_schema_backup_file}.#{zip_ext}"
+
   end
-  def db_backup_file                                           
-    "#{shared_path}/backup_#{from_env}_db.sql"                   
+
+  def db_backup_file
+    "#{shared_path}/backup_#{from_env}_db.sql"
   end
-  def db_backup_zip_file                                        
-    "#{db_backup_file}.#{zip_ext}"                               
+
+  def db_backup_zip_file
+    "#{db_backup_file}.#{zip_ext}"
   end
- 
+
   def local_content_backup_dir(args={})
     timestamp = args[:timestamp] || current_timestamp
     "#{tmp_dir}/#{fetch(:application)}-#{from_env}-content-#{timestamp.to_s.strip}"
   end
-  
+
   def generate_remote_tar_content_backup
     run "cd #{fetch(:shared_path)} && tar czf #{rsync_content_backup_file} 'system'"
   end
-  
+
   def local_db_conf(env = nil)
     env ||= fetch(:to_env)
     fetch(:config_structure, :rails).to_sym == :sls ?
       File.join('config', env.to_s, 'database.yml') :
       File.join('config', 'database.yml')
   end
-  
+
   def pluck_pass_str(db_config)
      db_config['password'].nil? ? '' : "-p'#{db_config['password']}'"
   end
-  
+
   def current_timestamp
     @current_timestamp ||= Time.now.to_i.to_s.strip
   end
-  
+
   def retrieve_local_files(env, type)
     `ls -r #{tmp_dir} | awk -F"-" '{ if ($2 ~ /#{env}/ && $3 ~ /#{type}/) { print $4; } }'`.split(' ')
   end
-  
+
   def most_recent_local_backup(env, type)
     retrieve_local_files(env, type).first.to_i
   end
-  
+
   def last_mod_time(path)
     capture("stat -c%Y #{path}") rescue 0
   end
-  
+
   def generate_remote_db_backup
-    run "mysqldump  #{mysql_connection_for(from_env)} > #{db_backup_file}"
+    run "mysqldump --opt --no-data #{mysql_connection_for(from_env)} > #{db_schema_backup_file}"
+    run "mysqldump --no-create-info #{exlude_table_command} #{mysql_connection_for(from_env)} > #{db_backup_file}"
     run "rm -f #{db_backup_zip_file} && #{zip} #{db_backup_file} && rm -f #{db_backup_file}"
+    run "rm -f #{db_schema_backup_zip_file} && #{zip} #{db_schema_backup_file} && rm -f #{db_schema_backup_file}"
   end
-  
+
   def local_db_backup_file(args = {})
     env = args[:env] || 'production'
     timestamp = args[:timestamp] || current_timestamp
     "#{tmp_dir}/#{fetch(:application)}-#{env}-db-#{timestamp.to_s.strip}.sql"
   end
-  
+
+  def local_db_schema_backup_file(args = {})
+    env = args[:env] || 'production'
+    timestamp = args[:timestamp] || current_timestamp
+    "#{tmp_dir}/#{fetch(:application)}-#{env}-schema-#{timestamp.to_s.strip}.sql"
+  end
+
   def mysql_connection_for(environment)
       db_settings = YAML.load_file(local_db_conf(environment))[environment]
       pass = pluck_pass_str(db_settings)
@@ -122,15 +151,15 @@ Capistrano::Configuration.instance(:must_exist).load do |configuration|
       database = (db_settings['database'].nil?) ? nil : " #{db_settings['database']}"
       [user, pass, host, socket, database ].join(" ")
   end
-  
+
   def mysql_db_for(environment)
       restore_from = ENV['FROM'] || 'production'
       @from_db ||= YAML.load_file(local_db_conf(restore_from))[restore_from]
       @from_database ||= (@from_db['database'].nil?) ? nil : " #{@from_db['database']}"
   end
-  
+
   namespace :local do
-  
+
     desc <<-DESC
       Wrapper for local:sync_db and local:sync_content
       $> cap local:sync RAILS_ENV=production RESTORE_ENV=development
@@ -143,9 +172,9 @@ Capistrano::Configuration.instance(:must_exist).load do |configuration|
         rsync_content
       end
     end
-  
+
     desc <<-DESC
-      Wrapper for local:force_backup_db, local:force_backup_content, and the local:sync to get 
+      Wrapper for local:force_backup_db, local:force_backup_content, and the local:sync to get
       a completely fresh set of data from the server
       $> cap local:sync RAILS_ENV=production RESTORE_ENV=development
     DESC
@@ -153,8 +182,8 @@ Capistrano::Configuration.instance(:must_exist).load do |configuration|
       force_backup_db
       force_backup_content
       sync
-    end 
-      
+    end
+
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: blavosync
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors: 
 - jayronc
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-05 00:00:00 -05:00
+date: 2010-03-19 00:00:00 -04:00
 default_executable: 
 dependencies: []