capistrano-fast_remote_cache 1.0.0

data/.gitignore

@@ -0,0 +1,18 @@
+.DS_Store
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3@capistrano-fast_remote_cache

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fast_remote_cache.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,24 @@
+Original plugin Copyright (c) 2008 by 37signals, LLC
+
+Copyright 2012 New Leaders
+
+MIT License
+
+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,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+# Capistrano Fast Remote Cache
+
+A gem built from the original 37 Signals fast_remote_cache rails plugin. Think of this gem as one less deprecation message for your stubborn Rails apps.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem "capistrano-fast_remote_cache"
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install capistrano-fast_remote_cache
+
+## Usage
+
+In your deploy.rb or Capfile:
+
+    require "capistrano/fast_remote_cache"
+
+Set the Capistrano deployment strategy in the same file with:
+
+    set :deploy_via, :fast_remote_cache
+
+_Note the stragey name!_
+
+To exclude certain directories or files from being deployed, set the copy_exclude variable (can also include glob patterns):
+
+    set :copy_exclude, %w(test .git doc config/database.yml)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## From the Original Plugin README
+
+The FastRemoteCache is a custom deployment strategy that specializes the standard RemoteCache strategy. It works just like the RemoteCache, but instead of actually copying the cache to the final release directory, it uses a custom "copy.rb" script to hard link the files. This allows the copy stage to be very fast.
+
+For small applications, and especially for those that aren't bundling vendor/rails, this won't make much of a difference. But for large applications the speed-up will be significant.
+
+### Dependencies
+
+* Capistrano 2 or later (http://www.capify.org)
+
+### Assumptions
+
+The FastRemoteCache, as the RemoteCache, assumes that your source repository is accessible from both your local (deploying) host, as well as the remote (target) hosts. If either of these is not true, you will not be able to use the FastRemoteCache strategy.
+
+Furthermore, it assumes that you have Ruby (1.8.6, preferably) installed on the target machines. If it is not installed in a standard location, you can set the :ruby variable to the location of the ruby executable.
+
+### Tips
+
+For the fastest possible deploys:
+
+* Always deploy as the same user. If you're part of a team where everyone can (and does) deploy, create a new user (e.g., "deploy") and set it up so that your team can all log in as this user. Make sure this user also has read access to your source code repository.
+* Avoid sudo if at all possible. set(:use_sudo, false), and then make sure that the deploy user has sufficient permissions to start and stop the mongrels, write to the necessary directories, etc.
+* Disable the "group_writable" setting: set(:group_writable, false). This is only necessary when you have multiple users deploying.
+* Don't include Rails (or other large libraries) in your application. Yes, it is convenient to include them, but they bloat your app and make checkouts and copies much slower. You have to balance convenience in development versus speed of deployment. Find a compromise that works for you.
+
+### License
+
+This code is released under the MIT license, and is copyright (c) 2008 by 37signals, LLC. Please see the accompanying LICENSE file for the full text of the license.
+
+Modified for Gem release by New Leaders 2012.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/capistrano-fast_remote_cache.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/capistrano/fast_remote_cache/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Don Morrison"]
+  gem.email         = ["dmorrison@newleaders.com"]
+  gem.description   = %q{Gem version of the 37 Signals Capistrano Fast Remote Cache (fast_remote_cache) Rails plugin}
+  gem.summary       = %q{Gem version of the 37 Signals Capistrano Fast Remote Cache (fast_remote_cache) Rails plugin}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "capistrano-fast_remote_cache"
+  gem.require_paths = ["lib"]
+  gem.version       = Capistrano::FastRemoteCache::VERSION
+
+  gem.add_dependency "capistrano", ">=2.0.0"
+end

data/lib/capistrano-fast_remote_cache.rb

@@ -0,0 +1 @@
+require "capistrano/fast_remote_cache/version"

data/lib/capistrano/fast_remote_cache.rb

@@ -0,0 +1,57 @@
+# ---------------------------------------------------------------------------
+# This is a recipe definition file for Capistrano. The tasks are documented
+# below.
+# ---------------------------------------------------------------------------
+# This file is distributed under the terms of the MIT license by 37signals,
+# LLC, and is copyright (c) 2008 by the same. See the LICENSE file distributed
+# with this file for the complete text of the license.
+# ---------------------------------------------------------------------------
+# Modified by New Leaders for capistrano-fast_remote_cache gem
+#
+
+# Add the top-level directory to the load path because the ridiculous
+# capistrano/recipes/deploy/strategy path is hardcoded in
+# capistrano/lib/capistrano/recipes/deploy/strategy.rb
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "fast_remote_cache"))
+
+module Capistrano
+  # We only want to hook onto Capistrano when the Configuration module is
+  # present. Hat tip to the rvm-capistrano gem.
+  if const_defined? :Configuration
+    Configuration.instance(true).load do
+      namespace :fast_remote_cache do
+
+        desc <<-DESC
+          Perform any setup required by fast_remote_cache. This is called
+          automatically after deploy:setup, but may be invoked manually to configure
+          a new machine. It is also necessary to invoke when you are switching to the
+          fast_remote_cache strategy for the first time.
+        DESC
+        task :setup, :except => { :no_release => true } do
+          if deploy_via == :fast_remote_cache
+            strategy.setup!
+          else
+            logger.important "you're including the fast_remote_cache strategy, but not using it!"
+          end
+        end
+
+        desc <<-DESC
+          Updates the remote cache. This is handy for either priming a new box so
+          the cache is all set for the first deploy, or for preparing for a large
+          deploy by making sure the cache is updated before the deploy goes through.
+          Either way, this will happen automatically as part of a deploy; this task
+          is purely convenience for giving admins more control over the deployment.
+        DESC
+        task :prepare, :except => { :no_release => true } do
+          if deploy_via == :fast_remote_cache
+            strategy.prepare!
+          else
+            logger.important "#{current_task.fully_qualified_name} only works with the fast_remote_cache strategy"
+          end
+        end
+      end
+
+      after "deploy:setup", "fast_remote_cache:setup"
+    end
+  end
+end

data/lib/capistrano/fast_remote_cache/capistrano/recipes/deploy/strategy/fast_remote_cache.rb

@@ -0,0 +1,48 @@
+# ---------------------------------------------------------------------------
+# This implements a specialization of the standard Capistrano RemoteCache
+# deployment strategy. The most significant difference between this strategy
+# and the RemoteCache is the way the cache is copied to the final release
+# directory: it uses the bundled "copy.rb" script to use hard links to the
+# files instead of actually copying, so the copy stage is much, much faster.
+# ---------------------------------------------------------------------------
+# This file is distributed under the terms of the MIT license by 37signals,
+# LLC, and is copyright (c) 2008 by the same. See the LICENSE file distributed
+# with this file for the complete text of the license.
+# ---------------------------------------------------------------------------
+# Modified by New Leaders for capistrano-fast_remote_cache gem
+#
+
+# Magic path added to the load path by capistrano
+require 'capistrano/recipes/deploy/strategy/remote_cache'
+
+class Capistrano::Deploy::Strategy::FastRemoteCache < Capistrano::Deploy::Strategy::RemoteCache
+  def check!
+    super.check do |d|
+      d.remote.command(configuration.fetch(:ruby, "ruby"))
+      d.remote.directory(bin_path)
+      d.remote.file(File.join(bin_path, "copy.rb"))
+    end
+  end
+
+  def setup!
+    run "mkdir -p #{bin_path}"
+    upload(File.join(File.dirname(__FILE__), "utilities", "copy.rb"), File.join(bin_path, "copy.rb"))
+  end
+
+  def prepare!
+    update_repository_cache
+  end
+
+  private
+
+    def bin_path
+      @bin_path ||= File.join(configuration[:shared_path], "bin")
+    end
+
+    def copy_repository_cache
+      logger.trace "copying the cached version to #{configuration[:release_path]}"
+      ruby = configuration.fetch(:ruby, "ruby")
+      excludes = Array(configuration[:copy_exclude]).join(" ")
+      run "#{ruby} #{File.join(bin_path, 'copy.rb')} #{repository_cache} #{configuration[:release_path]} #{excludes} && #{mark}"
+    end
+end

data/lib/capistrano/fast_remote_cache/capistrano/recipes/deploy/strategy/utilities/copy.rb

@@ -0,0 +1,53 @@
+# ---------------------------------------------------------------------------
+# A simple copy script for doing hard links and symbolic links instead of
+# explicit copies. Some OS's will already have a utility to do this, but
+# some won't; this file suffices in either case.
+#
+# Usage: ruby copy.rb <source> <target> <exclude> ...
+#
+# The <source> directory is recursively descended, and hard links to all of
+# the files are created in corresponding locations under <target>. Symbolic
+# links in <source> map to symbolic links in <target> that point to the same
+# destination.
+#
+# All arguments after <target> are taken to be exclude patterns. Any file
+# or directory in <source> that matches any of those patterns will be
+# skipped, and will thus not be present in <target>.
+# ---------------------------------------------------------------------------
+# This file is distributed under the terms of the MIT license by 37signals,
+# LLC, and is copyright (c) 2008 by the same. See the LICENSE file distributed
+# with this file for the complete text of the license.
+# ---------------------------------------------------------------------------
+require 'fileutils'
+
+from = ARGV.shift or abort "need source directory"
+to   = ARGV.shift or abort "need target directory"
+
+exclude = ARGV
+
+from = File.expand_path(from)
+to   = File.expand_path(to)
+
+Dir.chdir(from) do
+  FileUtils.mkdir_p(to)
+  queue = Dir.glob("*", File::FNM_DOTMATCH)
+  while queue.any?
+    item = queue.shift
+    name = File.basename(item)
+
+    next if name == "." || name == ".."
+    next if exclude.any? { |pattern| File.fnmatch(pattern, item) }
+
+    source = File.join(from, item)
+    target = File.join(to, item)
+
+    if File.symlink?(item)
+      FileUtils.ln_s(File.readlink(source), target)
+    elsif File.directory?(item)
+      queue += Dir.glob("#{item}/*", File::FNM_DOTMATCH)
+      FileUtils.mkdir_p(target, :mode => File.stat(item).mode)
+    else
+      FileUtils.ln(source, target)
+    end
+  end
+end

data/lib/capistrano/fast_remote_cache/version.rb

@@ -0,0 +1,5 @@
+module Capistrano
+  module FastRemoteCache
+    VERSION = "1.0.0"
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: capistrano-fast_remote_cache
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Don Morrison
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: Gem version of the 37 Signals Capistrano Fast Remote Cache (fast_remote_cache)
+  Rails plugin
+email:
+- dmorrison@newleaders.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- capistrano-fast_remote_cache.gemspec
+- lib/capistrano-fast_remote_cache.rb
+- lib/capistrano/fast_remote_cache.rb
+- lib/capistrano/fast_remote_cache/capistrano/recipes/deploy/strategy/fast_remote_cache.rb
+- lib/capistrano/fast_remote_cache/capistrano/recipes/deploy/strategy/utilities/copy.rb
+- lib/capistrano/fast_remote_cache/version.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Gem version of the 37 Signals Capistrano Fast Remote Cache (fast_remote_cache)
+  Rails plugin
+test_files: []