blavosync 0.1.0 → 0.2.1

data/Blavosync.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{blavosync}
-  s.version = "0.1.0"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["jayronc"]
@@ -14,22 +14,37 @@ Gem::Specification.new do |s|
   s.email = %q{jerrodblavos@mac.com}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+     "README.markdown"
   ]
   s.files = [
     "Blavosync.gemspec",
+     "History.txt",
      "LICENSE",
-     "README.rdoc",
+     "Manifest.txt",
+     "README.markdown",
      "Rakefile",
      "VERSION",
-     "init.rb",
-     "lib/blavosync.rb"
+     "lib/blavosync.rb",
+     "lib/blavosync/lib/ey_logger.rb",
+     "lib/blavosync/lib/ey_logger_hooks.rb",
+     "lib/blavosync/recipes.rb",
+     "lib/blavosync/recipes/content_rsync.rb",
+     "lib/blavosync/recipes/content_tar.rb",
+     "lib/blavosync/recipes/database.rb",
+     "lib/blavosync/recipes/local.rb",
+     "lib/blavosync/recipes/util.rb",
+     "test/test_blavosync.rb",
+     "test/test_helper.rb"
   ]
   s.homepage = %q{http://github.com/indierockmedia/Blavosync}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{Sync a remote db and rsync content to your development environment.}
+  s.test_files = [
+    "test/test_blavosync.rb",
+     "test/test_helper.rb"
+  ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

data/History.txt

@@ -0,0 +1,2 @@
+== 0.4.12 / 2009-12-29
+  * attempting to build a gem that works with EY-solo

data/Manifest.txt

@@ -0,0 +1,15 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/blavosync.rb
+lib/blavosync/lib/ey_logger.rb
+lib/blavosync/lib/ey_logger_hooks.rb
+lib/blavosync/recipes.rb
+lib/blavosync/recipes/local.rb
+lib/blavosync/recipes/util.rb
+lib/blavosync/recipes/database.rb
+lib/blavosync/recipes/content_rsync.rb
+lib/blavosync/recipes/content_tar.rb
+test/test_blavosync.rb
+test/test_helper.rb

data/README.markdown

@@ -0,0 +1,91 @@
+== blavosync
+
+INSTALLATION:
+Add this line to your config/deploy.rb file
+
+  require 'blavosync/recipes'
+
+USAGE:
+adds the following tasks to projects using capistrano
+
+------------------------------------------------------------
+cap local:backup_content
+------------------------------------------------------------
+Downloads a tarball of shared content (identified by the :shared_content and
+:content _ directories properties) from a deployable environment (RAILS_ENV) to
+the local filesystem.
+
+------------------------------------------------------------
+cap local:backup _ db
+------------------------------------------------------------
+Backs up deployable environment's database and copies it to
+the local machine.
+
+------------------------------------------------------------
+cap local:force _ backup _ content
+------------------------------------------------------------
+Regenerate files.
+
+------------------------------------------------------------
+cap local:force _ backup _ db
+------------------------------------------------------------
+Regenerate files.
+
+------------------------------------------------------------
+cap local:restore _ content
+------------------------------------------------------------
+Restores the backed up content (env var FROM specifies which environment
+was backed up, defaults to RAILS_ENV) to the local development environment app
+
+------------------------------------------------------------
+cap local:restore _ db
+------------------------------------------------------------
+Untars the backup file downloaded from local:backup_db and imports 
+(via mysql command line tool) it back into the development database.
+
+------------------------------------------------------------
+cap local:resync _ db
+------------------------------------------------------------
+Ensure that a fresh remote data dump is retrieved before syncing to the local
+environment
+
+------------------------------------------------------------
+cap local:sync
+------------------------------------------------------------
+Wrapper for local:sync _ db and local:sync _ content
+$> cap local:sync
+
+------------------------------------------------------------
+cap local:sync_content
+------------------------------------------------------------
+Wrapper for local:backup _ content and local:restore _ content
+$> cap local:sync_content
+
+------------------------------------------------------------
+cap local:sync_db
+------------------------------------------------------------
+Wrapper for local:backup _ db and local:restore _ db.
+$> cap local:sync _ db
+
+------------------------------------------------------------
+cap local:sync_init
+------------------------------------------------------------
+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
+
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 jayronc. See LICENSE for details.

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.1

data/lib/blavosync/lib/ey_logger.rb

@@ -0,0 +1,125 @@
+require 'tmpdir'
+require 'fileutils'
+module Capistrano
+  
+  class Logger  
+    
+    def ey_log(level, message, line_prefix = nil)
+      EYLogger.log(level, message, line_prefix) if EYLogger.setup?
+      log_without_ey_logging(level, message, line_prefix)
+    end
+    
+    unless method_defined?(:log_without_ey_logging)
+      alias_method :log_without_ey_logging, :log 
+      alias_method :log, :ey_log
+    end
+    
+    def close
+      device.close if @needs_close
+      EYLogger.close if EYLogger.setup?
+    end
+  end
+  
+  class EYLogger
+    
+    # Sets up the EYLogger to beging capturing capistrano's logging.  You should pass the capistrno configuration
+    # and the deploy type as a string.  The deploy type is for reporting purposes only but must be included.  
+    def self.setup(configuration, deploy_type, options = {})
+      @_configuration = configuration
+      @_deploy_type = deploy_type.gsub(/:/, "_")
+      @_log_path = options[:deploy_log_path] || Dir.tmpdir
+      @_log_path << "/" unless @_log_path =~ /\/$/
+      FileUtils.mkdir_p(@_log_path)
+      @_setup = true
+      @_success = true
+    end
+    
+    def self.log(level, message, line_prefix=nil)
+      return nil unless setup?
+      @release_name = @_configuration[:release_name] if @release_name.nil?
+      @_log_file_path = @_log_path + @release_name + ".log" unless @_log_file_path
+      @_deploy_log_file = File.open(@_log_file_path, "w") if @_deploy_log_file.nil?
+       
+      indent = "%*s" % [Logger::MAX_LEVEL, "*" * (Logger::MAX_LEVEL - level)]
+      message.each do |line|
+        if line_prefix
+          @_deploy_log_file << "#{indent} [#{line_prefix}] #{line.strip}\n"
+        else
+          @_deploy_log_file << "#{indent} #{line.strip}\n"
+        end
+      end
+    end
+    
+    def self.post_process      
+      unless ::Interrupt === $!
+        puts "\n\nPlease wait while the log file is processed\n"
+        # Should dump the stack trace of an exception if there is one
+        error = $!
+        unless error.nil?
+          @_deploy_log_file << error.message << "\n"
+          @_deploy_log_file << error.backtrace.join("\n")
+          @_success = false
+        end
+        self.close
+
+        hooks = [:any]
+        hooks << self.successful? ? :success : :failure
+        puts "Executing Post Processing Hooks"
+        hooks.each do |h|
+          @_post_process_hooks[h].each do |key|
+            @_configuration.parent.find_and_execute_task(key)
+          end
+        end
+        puts "Finished Post Processing Hooks"
+      end
+    end
+    
+    # Adds a post processing hook.  
+    #
+    # Provide a task name to execute.  These tasks are executed after capistrano has actually run its course. 
+    #
+    # Takes a key to control when the hook is executed.'
+    # :any - always executed
+    # :success - only execute on success
+    # :failure - only execute on failure
+    #
+    # ==== Example
+    #  Capistrano::EYLogger.post_process_hook( "ey_logger:upload_log_to_slice", :any) 
+    #
+    def self.post_process_hook(task, key = :any)
+      @_post_process_hooks ||= Hash.new{|h,k| h[k] = []}
+      @_post_process_hooks[key] << task
+    end
+
+    def self.setup?
+      !!@_setup
+    end   
+    
+    def self.deploy_type
+      @_deploy_type
+    end
+    
+    def self.successful?
+      !!@_success
+    end
+    
+    def self.failure?
+      !@_success
+    end
+    
+    def self.log_file_path
+      @_log_file_path
+    end
+    
+    def self.remote_log_file_name
+      @_log_file_name ||= "#{@_configuration[:release_name]}-#{@_deploy_type}-#{self.successful? ? "SUCCESS" : "FAILURE"}.log"
+    end
+    
+    def self.close
+      @_deploy_log_file.flush unless @_deploy_log_file.nil?
+      @_deploy_log_file.close unless @_deploy_log_file.nil?
+      @_setup = false
+    end
+    
+  end
+end

data/lib/blavosync/lib/ey_logger_hooks.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), "ey_logger")
+
+# These tasks are setup to use with the logger as post commit hooks.
+Capistrano::Configuration.instance(:must_exist).load do
+  namespace :ey_logger do
+    task :upload_log_to_slice, :except => { :no_release => true} do
+      logger = Capistrano::EYLogger
+      run "mkdir -p #{shared_path}/deploy_logs"
+      put File.open(logger.log_file_path).read, "#{shared_path}/deploy_logs/#{logger.remote_log_file_name}"
+    end
+  end
+end
+
+Capistrano::EYLogger.post_process_hook("ey_logger:upload_log_to_slice")

data/lib/blavosync/recipes/content_rsync.rb

@@ -0,0 +1,39 @@
+Capistrano::Configuration.instance(:must_exist).load do
+    namespace :local do
+      desc <<-DESC
+        Rsyncs the your production content (identified by the :shared_content and
+        :content_directories properties) from a deployable environment (RAILS_ENV) to the local filesystem.
+      DESC
+      task :rsync_content do
+        from = ENV['FROM'] || 'production'
+        if exists?(:domain)
+          remote_domain = fetch(:domain)
+        end
+        if exists?(:rsync_domain)
+          remote_domain =  fetch(:rsync_domain)
+        end
+        system("rsync -avz -e ssh '#{user}@#{remote_domain}:#{content_path}' '#{rails_root}/tmp/'")
+      end
+
+      desc <<-DESC
+        Creates a symlink to public/system from tmp/system
+      DESC
+      task :rsync_restore_content do
+        # from = ENV['FROM'] || 'production'
+        print "\033[1;45m Linking Assets to public directory \033[0m\n"
+        system "ln -nfs #{rails_root}/tmp/system #{rails_root}/public/system"
+      end
+
+
+      desc <<-DESC
+        Wrapper for local:rsync_content and local:rsync_restore_content
+        $> cap local:rsync RAILS_ENV=production
+      DESC
+      task :rsync do
+        transaction do
+          rsync_content
+          rsync_restore_content
+        end
+      end
+    end  
+end    

data/lib/blavosync/recipes/content_tar.rb

@@ -0,0 +1,64 @@
+Capistrano::Configuration.instance(:must_exist).load do
+
+    namespace :local do
+    desc <<-DESC
+      Downloads a tarball of shared content (identified by the :shared_content and
+      :content_directories properties) from a deployable environment (RAILS_ENV) to the local filesystem.
+    DESC
+    task :backup_content do
+      files = retrieve_local_files('production', 'content')
+      timestamp = most_recent_local_backup(from_env, 'content').to_i
+      last_modified = last_mod_time(content_backup_file).to_i
+      should_redownload = !(timestamp == last_modified)
+      if should_redownload
+        generate_remote_content_backup if last_modified < (Time.now.to_i - (remote_backup_expires))
+        system("mkdir -p #{tmp_dir}")
+        download(content_backup_file, "#{local_content_backup_dir(:env => from_env, :timestamp=>last_modified)}.tar.#{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
+      else
+        print "\r\033[1;42m Your Files are already up-to-date \033[0m\n"
+        @current_timestamp = files.first.to_i
+      end
+      util::tmp::check
+    end
+
+    desc <<-DESC
+      Regenerate files.
+    DESC
+    task :force_backup_content do
+      generate_remote_content_backup
+    end
+
+    desc <<-DESC
+      Restores the backed up content (env var FROM specifies which environment
+      was backed up, defaults to RAILS_ENV) to the local development environment app
+    DESC
+    task :restore_content do
+      timestamp = most_recent_local_backup(from_env, 'content')
+      local_dir = local_content_backup_dir(:env => from_env, :timestamp=>timestamp)
+      print "\033[1;45m Local Dir: #{local_dir} \033[0m\n"
+      system "mkdir -p #{local_dir}"
+      system "tar xzf #{local_dir}.tar.#{zip_ext} -C #{local_dir}"
+      print "\033[1;45m Removing old public/system directory \033[0m\n"
+      system "rm -rf public/system"
+      print "\033[1;45m Moving Assets to public directory \033[0m\n"
+      system "mv #{local_dir}/system public/system"
+      print "\033[1;41m Cleaning up \033[0m\n"
+      system "rm -rf #{local_dir}"
+    end
+
+
+    desc <<-DESC
+      Wrapper for local:backup_content and local:restore_content
+      $> cap local:sync_content RAILS_ENV=production RESTORE_ENV=development
+    DESC
+    task :sync_content do
+      transaction do
+        backup_content
+        restore_content
+      end
+    end
+  end
+
+end

data/lib/blavosync/recipes/database.rb

@@ -0,0 +1,79 @@
+Capistrano::Configuration.instance(:must_exist).load do
+
+    namespace :local do
+    desc <<-DESC
+      Backs up deployable environment's database (identified by the
+      RAILS_ENV environment variable, which defaults to 'production') and copies it to the local machine
+    DESC
+    task :backup_db, :roles => :db do
+      files = retrieve_local_files(from_env, 'db')
+      timestamp = most_recent_local_backup(from_env, 'db').to_i
+      last_modified = last_mod_time(db_backup_zip_file).to_i
+
+      if last_modified < (Time.now.to_i - (remote_backup_expires))
+        generate_remote_db_backup
+        should_redownload = true
+      end
+      should_redownload = !(timestamp == last_modified)
+      if should_redownload
+        system "mkdir -p #{tmp_dir}"
+        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
+      else
+        print "\r\033[1;42m Your Files are already up-to-date \033[0m\n"
+        @current_timestamp = files.first.to_i
+      end
+    end
+
+    desc <<-DESC
+      Regenerate files.
+    DESC
+    task :force_backup_db do
+      generate_remote_db_backup
+    end
+
+    desc <<-DESC
+      Untars the backup file downloaded from local:backup_db (specified via the FROM env
+      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)}\""
+      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"
+      system(local_db_create.strip)
+      cmd = ""
+      cmd << <<-CMD
+        #{unzip} -c #{remote_backup_file}.#{zip_ext} > #{remote_backup_file} &&
+        #{mysql_str} < #{remote_backup_file} &&
+        rm -f #{remote_backup_file}
+      CMD
+      system(cmd.strip)
+      util::tmp::check
+    end
+
+    desc <<-DESC
+      Wrapper for local:backup_db and local:restore_db.
+      $> cap local:sync_db RAILS_ENV=production RESTORE_ENV=development
+    DESC
+    task :sync_db do
+      transaction do
+        backup_db
+        restore_db
+      end
+    end
+
+    desc <<-DESC
+      Ensure that a fresh remote data dump is retrieved before syncing to the local environment.
+    DESC
+    task :resync_db do
+      util::tmp::clean_remote
+      sync_db
+    end
+  end
+
+end

data/lib/blavosync/recipes/local.rb

@@ -0,0 +1,167 @@
+# set :rails_root,                fetch(:blavosync_local_root,                Pathname.new('.').realpath                                   )
+# set :content_dir,               fetch(:blavosync_content_directories,       "system"                                                     )
+# set :content_path,              fetch(:blavosync_content_path,              File.join(fetch(:shared_path), content_dir)    )
+# set :public_path,               fetch(:blavosync_public_path,               File.join(fetch(:latest_release), 'public')    )
+# set :remote_backup_expires,     fetch(:blavosync_remote_backup_expires,     100000                                                       )
+# set :zip,                       fetch(:blavosync_zip_command,               "gzip"                                                       )
+# set :unzip,                     fetch(:blavosync_unzip_command,             "gunzip"                                                     )
+# set :zip_ext,                   fetch(:blavosync_compressed_extension,      "gz"                                                         )
+# set :tmp_dir,                   fetch(:blavosync_tmp_dir,                   "tmp"                                                        )
+# set :content_sync_method,       fetch(:blavosync_content_sync_method,       'rsync'                                                      )
+# set :from_env,                  fetch(:blavosync_from_env,                  (ENV['FROM_ENV'].nil? ? 'production' : ENV['RAILS_ENV'])     )
+# set :to_env,                    fetch(:blavosync_to_env,                    (ENV['TO_ENV'].nil? ? 'development' : ENV['TO_ENV'])         )
+# set :rsync_content_backup_file, fetch(:blavosync_rsync_content_backup_file, "#{shared_path}/system"                                      )
+# 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                                                
+  "system"                                                     
+end
+def content_path                                               
+  File.join(fetch(:shared_path), content_dir)                 
+end                                              
+def public_path                                               
+  File.join(fetch(:latest_release), 'public')                 
+end
+def remote_backup_expires                                      
+  100000                                                       
+end
+def zip                                                        
+  "gzip"                                                       
+end
+def unzip                                                      
+  "gunzip"                                                     
+end
+def zip_ext                                                    
+  "gz"                                                         
+end
+def tmp_dir                                                  
+  "tmp"                                                        
+end
+def content_sync_method                                      
+  'rsync'                                                      
+end
+def from_env                                                  
+  (ENV['FROM_ENV'].nil? ? 'production' : ENV['RAILS_ENV'])     
+end
+def to_env                                                  
+  (ENV['TO_ENV'].nil? ? 'development' : ENV['TO_ENV'])         
+end
+def rsync_content_backup_file                                  
+  "#{shared_path}/system"                                      
+end
+def tar_content_backup_file                                   
+  "#{shared_path}/backup_#{from_env}_content.tar.#{zip_ext}"   
+end
+def db_backup_file                                           
+  "#{shared_path}/backup_#{from_env}_db.sql"                   
+end
+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}")
+  end
+  
+  def server_cache_valid?(path)
+    capture("[ -f #{path} ] || echo '1'").empty? && ((Time.now.to_i - last_mod_time(path)) <= remote_backup_expires)
+  end
+  
+  def generate_remote_db_backup
+    run "mysqldump  #{mysql_connection_for(from_env)} > #{db_backup_file}"
+    run "rm -f #{db_backup_zip_file} && #{zip} #{db_backup_file} && rm -f #{db_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 mysql_connection_for(environment)
+      db_settings = YAML.load_file(local_db_conf(environment))[environment]
+      pass = pluck_pass_str(db_settings)
+      host = (db_settings['host'].nil?) ? nil : "--host=#{db_settings['host']}"
+      socket = (db_settings['socket'].nil?) ? nil : "--socket=#{db_settings['socket']}"
+      user = (db_settings['username'].nil?) ? nil : "-u #{db_settings['username']}"
+      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
+    DESC
+    task :sync, :roles =>:app do
+      sync_db
+      if content_sync_method == 'tar'
+        sync_content
+      else
+        rsync_content
+      end
+    end
+  
+    desc <<-DESC
+      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
+    task :sync_init, :roles =>:app  do
+      force_backup_db
+      force_backup_content
+      sync
+    end 
+      
+  end
+
+end

data/lib/blavosync/recipes/util.rb

@@ -0,0 +1,21 @@
+Capistrano::Configuration.instance(:must_exist).load do
+
+  namespace :util do
+
+    namespace :tmp do
+      desc "[capistrano-extensions]: Displays warning if :tmp_dir has more than 10 files or is greater than 50MB"
+      task :check do
+        #[ 5 -le "`ls -1 tmp/cap | wc -l`" ] && echo "Display Me"
+        cmd = %Q{ [ 10 -le "`ls -1 #{tmp_dir} | wc -l`" ] || [ 50 -le "`du -sh #{tmp_dir} | awk '{print int($1)}'`" ] && printf "\033[1;41m Clean up #{tmp_dir} directory \033[0m\n" && du -sh #{tmp_dir}/*  }
+        system(cmd)
+      end
+
+      desc "[capistrano-extensions]: Remove the current remote env's backups from :tmp_dir"
+      task :clean_remote do
+        system("rm -rf #{rails_root}/#{tmp_dir}/#{configuration.fetch(:application)}-*")
+      end
+
+    end
+  end
+  
+end

data/lib/blavosync/recipes.rb

@@ -0,0 +1,15 @@
+require 'blavosync/lib/ey_logger'
+require 'blavosync/lib/ey_logger_hooks'
+require 'blavosync/recipes/util'
+require 'blavosync/recipes/local'
+require 'blavosync/recipes/database'
+require 'blavosync/recipes/content_tar'
+require 'blavosync/recipes/content_rsync'
+ 
+Capistrano::Configuration.instance(:must_exist).load do
+  
+  default_run_options[:pty] = true if respond_to?(:default_run_options)
+  set :keep_releases, 3
+  set :runner, defer { user }
+  
+end

data/lib/blavosync.rb

@@ -1,295 +1,3 @@
-Capistrano::Configuration.instance(:must_exist).load do
-
-  set :rails_root,                fetch(:blavosync_local_root,                Pathname.new('.').realpath                                   )
-  set :content_dir,               fetch(:blavosync_content_directories,       content_directories ||= "system"                             )
-  set :content_path,              fetch(:blavosync_content_path,              File.join(shared_path, content_dir)                          )
-  set :public_path,               fetch(:blavosync_public_path,               File.join(latest_release, 'public')                          )
-  set :remote_backup_expires,     fetch(:blavosync_remote_backup_expires,     100000                                                       )
-  set :zip,                       fetch(:blavosync_zip_command,               "gzip"                                                       )
-  set :unzip,                     fetch(:blavosync_unzip_command,             "gunzip"                                                     )
-  set :zip_ext,                   fetch(:blavosync_compressed_extension,      "gz"                                                         )
-  set :tmp_dir,                   fetch(:blavosync_tmp_dir,                   "tmp"                                                        )
-  set :content_sync_method,       fetch(:blavosync_content_sync_method,       'rsync'                                                      )
-  set :from_env,                  fetch(:blavosync_from_env,                  (ENV['FROM_ENV'].nil? ? 'production' : ENV['RAILS_ENV'])     )
-  set :to_env,                    fetch(:blavosync_to_env,                    (ENV['TO_ENV'].nil? ? 'development' : ENV['TO_ENV'])         )
-  set :rsync_content_backup_file, fetch(:blavosync_rsync_content_backup_file, "#{shared_path}/system"                                      )
-  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}"                               )
-
-  def local_content_backup_dir(args={})
-    timestamp = args[:timestamp] || current_timestamp
-    "#{tmp_dir}/#{application}-#{from_env}-content-#{timestamp.to_s.strip}"
-  end
-
-  def generate_remote_tar_content_backup
-    run "cd #{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}")
-  end
-
-  def server_cache_valid?(path)
-    capture("[ -f #{path} ] || echo '1'").empty? && ((Time.now.to_i - last_mod_time(path)) <= remote_backup_expires)
-  end
-
-  def generate_remote_db_backup
-    run "mysqldump  #{mysql_connection_for(from_env)} > #{db_backup_file}"
-    run "rm -f #{db_backup_zip_file} && #{zip} #{db_backup_file} && rm -f #{db_backup_file}"
-  end
-
-  def local_db_backup_file(args = {})
-    env = args[:env] || 'production'
-    timestamp = args[:timestamp] || current_timestamp
-    "#{tmp_dir}/#{application}-#{env}-db-#{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)
-      host = (db_settings['host'].nil?) ? nil : "--host=#{db_settings['host']}"
-      socket = (db_settings['socket'].nil?) ? nil : "--socket=#{db_settings['socket']}"
-      user = (db_settings['username'].nil?) ? nil : "-u #{db_settings['username']}"
-      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 :util do
-
-    namespace :tmp do
-      desc "[capistrano-extensions]: Displays warning if :tmp_dir has more than 10 files or is greater than 50MB"
-      task :check do
-        #[ 5 -le "`ls -1 tmp/cap | wc -l`" ] && echo "Display Me"
-        cmd = %Q{ [ 10 -le "`ls -1 #{tmp_dir} | wc -l`" ] || [ 50 -le "`du -sh #{tmp_dir} | awk '{print int($1)}'`" ] && printf "\033[1;41m Clean up #{tmp_dir} directory \033[0m\n" && du -sh #{tmp_dir}/*  }
-        system(cmd)
-      end
-
-      desc "[capistrano-extensions]: Remove the current remote env's backups from :tmp_dir"
-      task :clean_remote do
-        system("rm -rf #{rails_root}/#{tmp_dir}/#{fetch(:application)}-*")
-      end
-
-    end
-  end
-
-  namespace :local do
-
-    desc <<-DESC
-      Wrapper for local:sync_db and local:sync_content
-      $> cap local:sync RAILS_ENV=production RESTORE_ENV=development
-    DESC
-    task :sync do
-      sync_db
-      if content_sync_method == 'tar'
-        sync_content
-      else
-        rsync_content
-      end
-    end
-  
-    desc <<-DESC
-      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
-    task :sync_init do
-      force_backup_db
-      force_backup_content
-      sync
-    end 
-  
-    desc <<-DESC
-      Backs up deployable environment's database (identified by the
-      RAILS_ENV environment variable, which defaults to 'production') and copies it to the local machine
-    DESC
-    task :backup_db, :roles => :db do
-      files = retrieve_local_files(from_env, 'db')
-      timestamp = most_recent_local_backup(from_env, 'db').to_i
-      last_modified = last_mod_time(db_backup_zip_file).to_i
-
-      if last_modified < (Time.now.to_i - (remote_backup_expires))
-        generate_remote_db_backup
-        should_redownload = true
-      end
-      should_redownload = !(timestamp == last_modified)
-      if should_redownload
-        system "mkdir -p #{tmp_dir}"
-        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
-      else
-        print "\r\033[1;42m Your Files are already up-to-date \033[0m\n"
-        @current_timestamp = files.first.to_i
-      end
-    end
-
-    desc <<-DESC
-      Regenerate files.
-    DESC
-    task :force_backup_db do
-      generate_remote_db_backup
-    end
-
-    desc <<-DESC
-      Untars the backup file downloaded from local:backup_db (specified via the FROM env
-      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)}\""
-      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"
-      system(local_db_create.strip)
-      cmd = ""
-      cmd << <<-CMD
-        #{unzip} -c #{remote_backup_file}.#{zip_ext} > #{remote_backup_file} &&
-        #{mysql_str} < #{remote_backup_file} &&
-        rm -f #{remote_backup_file}
-      CMD
-      system(cmd.strip)
-      util::tmp::check
-    end
-
-    desc <<-DESC
-      Wrapper for local:backup_db and local:restore_db.
-      $> cap local:sync_db RAILS_ENV=production RESTORE_ENV=development
-    DESC
-    task :sync_db do
-      transaction do
-        backup_db
-        restore_db
-      end
-    end
-
-    desc <<-DESC
-      Ensure that a fresh remote data dump is retrieved before syncing to the local environment.
-    DESC
-    task :resync_db do
-      util::tmp::clean_remote
-      sync_db
-    end
-
-    desc <<-DESC
-      Rsyncs the your production content (identified by the :shared_content and
-      :content_directories properties) from a deployable environment (RAILS_ENV) to the local filesystem.
-    DESC
-    task :rsync_content do
-      from = ENV['FROM'] || 'production'
-      system("rsync -avz -e ssh '#{user}@#{domain}:#{content_path}' '#{rails_root}/tmp/'")
-    end
-
-    desc <<-DESC
-      Creates a symlink to public/system from tmp/system
-    DESC
-    task :rsync_restore_content do
-      # from = ENV['FROM'] || 'production'
-      print "\033[1;45m Linking Assets to public directory \033[0m\n"
-      system "ln -nfs #{rails_root}/tmp/system #{rails_root}/public/system"
-    end
-
-
-    desc <<-DESC
-      Wrapper for local:rsync_content and local:rsync_restore_content
-      $> cap local:rsync RAILS_ENV=production
-    DESC
-    task :rsync do
-      transaction do
-        rsync_content
-        rsync_restore_content
-      end
-    end
-
-    desc <<-DESC
-      Downloads a tarball of shared content (identified by the :shared_content and
-      :content_directories properties) from a deployable environment (RAILS_ENV) to the local filesystem.
-    DESC
-    task :backup_content do
-      files = retrieve_local_files('production', 'content')
-      timestamp = most_recent_local_backup(from_env, 'content').to_i
-      last_modified = last_mod_time(content_backup_file).to_i
-      should_redownload = !(timestamp == last_modified)
-      if should_redownload
-        generate_remote_content_backup if last_modified < (Time.now.to_i - (remote_backup_expires))
-        system("mkdir -p #{tmp_dir}")
-        download(content_backup_file, "#{local_content_backup_dir(:env => from_env, :timestamp=>last_modified)}.tar.#{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
-      else
-        print "\r\033[1;42m Your Files are already up-to-date \033[0m\n"
-        @current_timestamp = files.first.to_i
-      end
-      util::tmp::check
-    end
-
-    desc <<-DESC
-      Regenerate files.
-    DESC
-    task :force_backup_content do
-      generate_remote_content_backup
-    end
-
-    desc <<-DESC
-      Restores the backed up content (env var FROM specifies which environment
-      was backed up, defaults to RAILS_ENV) to the local development environment app
-    DESC
-    task :restore_content do
-      timestamp = most_recent_local_backup(from_env, 'content')
-      local_dir = local_content_backup_dir(:env => from_env, :timestamp=>timestamp)
-      print "\033[1;45m Local Dir: #{local_dir} \033[0m\n"
-      system "mkdir -p #{local_dir}"
-      system "tar xzf #{local_dir}.tar.#{zip_ext} -C #{local_dir}"
-      print "\033[1;45m Removing old public/system directory \033[0m\n"
-      system "rm -rf public/system"
-      print "\033[1;45m Moving Assets to public directory \033[0m\n"
-      system "mv #{local_dir}/system public/system"
-      print "\033[1;41m Cleaning up \033[0m\n"
-      system "rm -rf #{local_dir}"
-    end
-
-
-    desc <<-DESC
-      Wrapper for local:backup_content and local:restore_content
-      $> cap local:sync_content RAILS_ENV=production RESTORE_ENV=development
-    DESC
-    task :sync_content do
-      transaction do
-        backup_content
-        restore_content
-      end
-    end
-  end
-
+module Blavosync
+  VERSION = '0.1.3'
 end

data/test/test_blavosync.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestBlavosync < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/blavosync'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: blavosync
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - jayronc
@@ -21,15 +21,26 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.rdoc
+- README.markdown
 files: 
 - Blavosync.gemspec
+- History.txt
 - LICENSE
-- README.rdoc
+- Manifest.txt
+- README.markdown
 - Rakefile
 - VERSION
-- init.rb
 - lib/blavosync.rb
+- lib/blavosync/lib/ey_logger.rb
+- lib/blavosync/lib/ey_logger_hooks.rb
+- lib/blavosync/recipes.rb
+- lib/blavosync/recipes/content_rsync.rb
+- lib/blavosync/recipes/content_tar.rb
+- lib/blavosync/recipes/database.rb
+- lib/blavosync/recipes/local.rb
+- lib/blavosync/recipes/util.rb
+- test/test_blavosync.rb
+- test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/indierockmedia/Blavosync
 licenses: []
@@ -58,5 +69,6 @@ rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Sync a remote db and rsync content to your development environment.
-test_files: []
-
+test_files: 
+- test/test_blavosync.rb
+- test/test_helper.rb

data/README.rdoc

@@ -1,118 +0,0 @@
-== blavosync
-
-INSTALLATION:
-Add this line BELOW load 'config/deploy' in your Capfile
-
-require 'blavosync'
-
-
-USAGE:
-adds the following tasks to projects using capistrano
-
-------------------------------------------------------------
-cap local:backup_content
-------------------------------------------------------------
-Downloads a tarball of shared content (identified by the :shared_content and
-:content_directories properties) from a deployable environment (RAILS_ENV) to
-the local filesystem.
-
-------------------------------------------------------------
-cap local:backup_db
-------------------------------------------------------------
-Backs up deployable environment's database (idgit loentified by the
-RAILS_ENV environment variable, which defaults to 'production') and copies it to
-the local machine
-
-------------------------------------------------------------
-cap local:force_backup_content
-------------------------------------------------------------
-Regenerate files.
-
-------------------------------------------------------------
-cap local:force_backup_db
-------------------------------------------------------------
-Regenerate files.
-
-------------------------------------------------------------
-cap local:restore_content
-------------------------------------------------------------
-Restores the backed up content (env var FROM specifies which environment
-was backed up, defaults to RAILS_ENV) to the local development environment app
-
-------------------------------------------------------------
-cap local:restore_db
-------------------------------------------------------------
-Untars the backup file downloaded from local:backup_db (specified via the FROM
-env
-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).
-
-------------------------------------------------------------
-cap local:resync_db
-------------------------------------------------------------
-Ensure that a fresh remote data dump is retrieved before syncing to the local
-environment
-
-------------------------------------------------------------
-cap local:sync
-------------------------------------------------------------
-Wrapper for local:sync_db and local:sync_content
-$> cap local:sync RAILS_ENV=production RESTORE_ENV=development
-
-------------------------------------------------------------
-cap local:sync_content
-------------------------------------------------------------
-Wrapper for local:backup_content and local:restore_content
-$> cap local:sync_content RAILS_ENV=production RESTORE_ENV=development
-
-------------------------------------------------------------
-cap local:sync_db
-------------------------------------------------------------
-Wrapper for local:backup_db and local:restore_db.
-$> cap local:sync_db RAILS_ENV=production RESTORE_ENV=development
-
-------------------------------------------------------------
-cap local:sync_init
-------------------------------------------------------------
-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
-
-CONFIGURATION:
-
-the following variables (with defaults shown) are available in your deploy.rb
-
-
-  set :blavosync_local_root,                Pathname.new('.').realpath                                 
-  set :blavosync_content_directories,       content_directories ||= "system"                           
-  set :blavosync_content_path,              File.join(shared_path, content_dir)                        
-  set :blavosync_public_path,               File.join(latest_release, 'public')                        
-  set :blavosync_remote_backup_expires,     100000                                                     
-  set :blavosync_zip_command,               "gzip"                                                     
-  set :blavosync_unzip_command,             "gunzip"                                                   
-  set :blavosync_compressed_extension,      "gz"                                                       
-  set :blavosync_tmp_dir,                   "tmp"                                                      
-  set :blavosync_content_sync_method,       'rsync'                                                    
-  set :blavosync_from_env,                  (ENV['FROM_ENV'].nil? ? 'production' : ENV['RAILS_ENV'])   
-  set :blavosync_to_env,                    (ENV['TO_ENV'].nil? ? 'development' : ENV['TO_ENV'])       
-  set :blavosync_rsync_content_backup_file, "#{shared_path}/system"                                    
-  set :blavosync_tar_content_backup_file,   "#{shared_path}/backup_#{from_env}_content.tar.#{zip_ext}" 
-  set :blavosync_db_backup_file,            "#{shared_path}/backup_#{from_env}_db.sql"                 
-  set :blavosync_db_backup_zip_file,        "#{db_backup_file}.#{zip_ext}"                             
-
-
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Copyright
-
-Copyright (c) 2009 jayronc. See LICENSE for details.

data/init.rb

@@ -1,3 +0,0 @@
-['lib/blavosync.rb','recipes/shared_sync.rb', 'recipes/content_rsync.rb', 'recipes/content_sync.rb', 'recipes/db_sync.rb'].each do |file| 
-  load Dir[File.join(File.dirname(__FILE__), file)] 
-end