capistrano-config 0.0.5 → 0.1.0

data/README.md

@@ -21,25 +21,91 @@ Or install it yourself as:
 This recipes will try to update application config during Capistrano `deploy` tasks.
 
 To enable this recipe, add following in your `config/deploy.rb`.
-The template of `config/config.yml` will be read from either `./config/templates/config/config.yml` or `./config/templates/config/config.yml.erb` by default.
 
-    # in "config/deploy.rb"
-    require 'capistrano-config'
-    set(:config_files, %w(config/config.yml))
+The configuration file `config/config.yml` will be generated from template in `config/templates` by default.
+(The template will be used is either `config/templates/config/config.yml.erb` or `config/templates/config/config.yml`.)
 
-Following options are available to manage your configuration files.
+    # config/deploy.rb
+    require "capistrano-config"
+    set :config_files, ["config/config.yml"]
 
+## Examples
+
+### Setting up shared configuration
+
+You might not want to generate configuration files on everytime of deployment.
+There is _shared_ mode to generate configuration files just once during `deploy:setup`.
+
+This is the configuration example for shared configuration mode.
+
+    # config/deploy.rb
+    set :config_use_shared, true
+    set :config_files, ["config/config.yml"]
+
+The generated configuration files will be installed in `#{shared_path}/config/config.yml` during `deploy:setup`.
+After the setup of shared configuration, symlink will be created at `#{release_path}/config/config.yml` during `deploy`.
+
+If you want to update the shared configuration files, invoke `config:setup` will do that.
+
+    % cap config:setup
+
+### Setting up local configuration
+
+With some build system, you might need to update some of local files during deployment.
+There is _local_ mode to help you.
+
+This is the configuration example for local configuration mode.
+
+    # config/deploy.rb
+    set :config_update_locally, true
+    set :config_files, ["config/config.yml"]
+
+The local configuration files will be updated during `deploy`.
+
+### Setting up files with special parameters
+
+You can set file parameters for each files with defining `:config_files` as a Hash.
+The value of Hash will be passed to `safe_put` of [capistrano-file-transfer-ext](https://github.com/yyuu/capistran-file-transfer-ext).
+
+    # config/deploy.rb
+    set :config_files do
+      {
+        "config/secret.yml" => { :owner => "user", :group => "user", :mode => "640" }
+      }
+    end
+
+If you want to apply for all configuration files, you can use `:config_files_options`.
+
+   # config/deploy.rb
+    set :config_files, ["config/secret.yml", "config/credentials.yml"]
+    set :config_files_options, :owner => "user", :group => "user", :mode => "640"
+
+### Setting up files with absolute paths
+
+If the configuration file name starts with "/", it will be treated as absolute path.
+
+    # config/deploy.rb
+    set :config_files do
+      {
+        "/etc/init/foo.cnf" => { :configure_except => :local, :owner => "root", :group => "root", :mode => "644", :run_method => :sudo },
+      }
+    end
+
+
+## Reference
+
+These options are available to manage your configuration files.
+
+ * `:config_files` - the definition of configuration files as in an array or a hash.
+    if given as hash, the key should be the value should be the file options.
  * `:config_update_remotely` - specify whether update config files on remote machines or not. `true` by default.
  * `:config_update_locally` - specify whether update config files on local machines or not. `false` by default.
- * `:config_use_sudo_locally` - specify whether use `sudo` or not on local execution. `false` by default.
- * `:config_use_sudo_remotely` - specify whether use `sudo` or not on remote execution. `true` by default.
+ * `:config_use_shared` - set `true` if you want to use _shared_ config. `false` by default.
  * `:config_path` - specify configuration base directory on remote machines. use `release_path` by default.
  * `:config_path_local` - specify configuration base directory on local machine. use `.` by default.
- * `:config_template_path` - specify configuration template directory on local machine. use `./config/templates` by default.
- * `:config_files` - specify list of configuration files in relative path. empty by default.
- * `:config_readable_files` - list of files which should be readable. empty by default.
- * `:config_writable_files` - list of files which should be writable. empty by default.
- * `:config_executable_files` - list of files which should be executable. empty by default.
+ * `:config_template_path` - specify configuration template directory on local machine. use `config/templates` by default.
+ * `:config_files_options` - the hash to be used as parameters for configuration files.
+
 
 ## Contributing
 

data/capistrano-config.gemspec

@@ -18,6 +18,9 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.add_dependency("capistrano")
-  gem.add_dependency("capistrano-file-resources")
-  gem.add_dependency("capistrano-file-transfer-ext", "~> 0.0.3")
+  gem.add_dependency("capistrano-file-resources", "~> 0.0.1")
+  gem.add_dependency("capistrano-file-transfer-ext", "~> 0.1.0")
+  gem.add_development_dependency("net-scp", "~> 1.0.4")
+  gem.add_development_dependency("net-ssh", "~> 2.2.2")
+  gem.add_development_dependency("vagrant", "~> 1.0.6")
 end

data/lib/capistrano-config.rb

@@ -9,36 +9,60 @@ module Capistrano
       configuration.load {
         namespace(:config) {
           _cset(:config_path) { release_path }
-          _cset(:config_path_local) { File.expand_path('.') }
-          _cset(:config_template_path) { File.join(File.expand_path('.'), 'config', 'templates') }
+          _cset(:config_path_local) { File.expand_path(".") }
+          _cset(:config_template_path) { File.expand_path("config/templates") }
           _cset(:config_files, [])
 
           _cset(:config_use_shared, false)
-          _cset(:config_shared_path) { File.join(shared_path, 'config') }
+          _cset(:config_shared_path) { File.join(shared_path, "config") }
 
-          _cset(:config_readable_mode, "a+r")
+          _cset(:config_readable_mode, "444")
           _cset(:config_readable_files, [])
-          _cset(:config_writable_mode, "a+rw")
+          _cset(:config_writable_mode, "644")
           _cset(:config_writable_files, [])
-          _cset(:config_executable_mode, "a+rx")
+          _cset(:config_executable_mode, "755")
           _cset(:config_executable_files, [])
           _cset(:config_remove_files, [])
+          _cset(:config_files_options, {:install => :if_modified})
+
+          def _normalize_config_files(fs, options={})
+            options = config_files_options.merge(options)
+            case fs
+            when Array
+              fs = Hash[fs.map { |f|
+                if config_executable_files.include?(f)
+                  options[:mode] = config_executable_mode
+                elsif config_writable_files.include?(f)
+                  options[:mode] = config_writable_mode
+                elsif config_readable_files.include?(f)
+                  options[:mode] = config_readable_mode
+                end
+                [f, options]
+              }]
+            when Hash
+              fs
+            else
+              raise TypeError.new("unexpected type: #{fs.class}")
+            end
+          end
+
+          def _target?(s, options={})
+            except = Array(options[:configure_except]).flatten.map { |s| s.to_sym }
+            only = Array(options[:configur_only]).flatten.map { |s| s.to_sym }
+            ( except.empty? or not(except.include?(s)) ) and ( only.empty? or only.include?(s) )
+          end
 
           desc("Setup shared application config.")
           task(:setup, :roles => :app, :except => { :no_release => true }) {
             if config_use_shared
-              config_files.each do |f|
-                safe_put(template(f, :path => config_template_path), File.join(config_shared_path, f), :place => :if_modified)
+              _normalize_config_files(config_files).each do |file, options|
+                if _target?(:shared, options)
+                  safe_put(template(file, :path => config_template_path), File.join(config_shared_path, file), options)
+                end
               end
-              execute = []
-              execute << "#{try_sudo} chmod #{config_readable_mode} #{config_readable_files.map { |f| File.join(config_shared_path, f).dump }.join(' ')}" unless config_readable_files.empty?
-              execute << "#{try_sudo} chmod #{config_writable_mode} #{config_writable_files.map { |f| File.join(config_shared_path, f).dump }.join(' ')}" unless config_writable_files.empty?
-              execute << "#{try_sudo} chmod #{config_executable_mode} #{config_executable_files.map { |f| File.join(config_shared_path, f).dump }.join(' ')}" unless config_executable_files.empty?
-              execute << "#{try_sudo} rm -f #{config_remove_files.map { |f| File.join(config_shared_path, f).dump }.join(' ')}" unless config_remove_files.empty?
-              run(execute.join(" && ")) unless execute.empty?
             end
           }
-          after 'deploy:setup', 'config:setup'
+          after "deploy:setup", "config:setup"
 
           desc("Update applicatin config.")
           task(:update, :roles => :app, :except => { :no_release => true }) {
@@ -47,39 +71,41 @@ module Capistrano
               update_locally if fetch(:config_update_locally, false)
             }
           }
-          after 'deploy:finalize_update', 'config:update'
+          after "deploy:finalize_update", "config:update"
+
+          def _destination_file(file, options={})
+            file.start_with?("/") ? file : File.join(options.fetch(:path, "."), file)
+          end
 
           task(:update_remotely, :roles => :app, :except => { :no_release => true }) {
-            if config_use_shared
-              execute = []
-              config_files.each do |f|
-                execute << "( rm -f #{File.join(config_path, f).dump}; " +
-                           "ln -sf #{File.join(config_shared_path, f).dump} #{File.join(config_path, f).dump} )"
-              end
-              run(execute.join(" && ")) unless execute.empty?
-            else
-              config_files.each do |f|
-                safe_put(template(f, :path => config_template_path), File.join(config_path, f), :place => :if_modified)
+            execute = []
+            _normalize_config_files(config_files).each do |file, options|
+              destination = _destination_file(file, :path => config_path)
+              if config_use_shared and _target?(:shared, options)
+                execute << "( rm -f #{destination.dump}; " +
+                           "ln -sf #{File.join(config_shared_path, file).dump} #{destination.dump} )"
+              elsif _target?(:remote, options)
+                safe_put(template(file, :path => config_template_path), destination, options)
               end
-              execute = []
-              execute << "#{try_sudo} chmod #{config_readable_mode} #{config_readable_files.map { |f| File.join(config_path, f).dump }.join(' ')}" unless config_readable_files.empty?
-              execute << "#{try_sudo} chmod #{config_writable_mode} #{config_writable_files.map { |f| File.join(config_path, f).dump }.join(' ')}" unless config_writable_files.empty?
-              execute << "#{try_sudo} chmod #{config_executable_mode} #{config_executable_files.map { |f| File.join(config_path, f).dump }.join(' ')}" unless config_executable_files.empty?
-              execute << "#{try_sudo} rm -f #{config_remove_files.map { |f| File.join(config_path, f).dump }.join(' ')}" unless config_remove_files.empty?
-              run(execute.join(" && ")) unless execute.empty?
             end
+            run(execute.join(" && ")) unless execute.empty?
           }
 
+          def safe_put_locally(body, to, options={})
+            File.write(to, body)
+            if options.key?(:mode)
+              mode = options[:mode].is_a?(Numeric) ? options[:mode].to_s(8) : options[:mode].to_s
+              run_locally("chmod #{mode.dump} #{to.dump}")
+            end
+          end
+
           task(:update_locally, :roles => :app, :except => { :no_release => true }) {
-            config_files.each do |f|
-              File.write(File.join(config_path_local, f), template(f, :path => config_template_path))
+            _normalize_config_files(config_files).each do |file, options|
+              if _target?(:local, options)
+                destination = _destination_file(file, :path => config_path_local)
+                safe_put_locally(template(file, :path => config_template_path), destination, options)
+              end
             end
-            execute = []
-            execute << "#{try_sudo} chmod #{config_readable_mode} #{config_readable_files.map { |f| File.join(config_path_local, f).dump }.join(' ')}" unless config_readable_files.empty?
-            execute << "#{try_sudo} chmod #{config_writable_mode} #{config_writable_files.map { |f| File.join(config_path_local, f).dump }.join(' ')}" unless config_writable_files.empty?
-            execute << "#{try_sudo} chmod #{config_executable_mode} #{config_executable_files.map { |f| File.join(config_path_local, f).dump }.join(' ')}" unless config_executable_files.empty?
-            execute << "#{try_sudo} rm -f #{config_remove_files.map { |f| File.join(config_path_local, f).dump }.join(' ')}" unless config_remove_files.empty?
-            run(execute.join(" && ")) unless execute.empty?
           }
         }
       }
@@ -91,4 +117,4 @@ if Capistrano::Configuration.instance
   Capistrano::Configuration.instance.extend(Capistrano::ConfigRecipe)
 end
 
-# vim:set ft=ruby :
+# vim:set ft=ruby sw=2 ts=2 :

data/lib/capistrano-config/version.rb

@@ -1,5 +1,5 @@
 module Capistrano
   module ConfigRecipe
-    VERSION = "0.0.5"
+    VERSION = "0.1.0"
   end
 end

data/test/centos6-64/.gitignore

@@ -0,0 +1,5 @@
+/.bundle
+/.vagrant
+/known_hosts
+/tmp
+/vendor

data/test/centos6-64/Capfile

@@ -0,0 +1,2 @@
+load "deploy"
+load "../config/deploy"

data/test/centos6-64/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec(:path => "../..")

data/test/centos6-64/Vagrantfile

@@ -0,0 +1,99 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant::Config.run do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "centos6-64"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  config.vm.box_url = "http://developer.nrel.gov/downloads/vagrant-boxes/CentOS-6.3-x86_64-v20130101.box"
+
+  # Boot with a GUI so you can see the screen. (Default is headless)
+  # config.vm.boot_mode = :gui
+
+  # Assign this VM to a host-only network IP, allowing you to access it
+  # via the IP. Host-only networks can talk to the host machine as well as
+  # any other machines on the same network, but cannot be accessed (through this
+  # network interface) by any external networks.
+  config.vm.network :hostonly, "192.168.33.10"
+
+  # Assign this VM to a bridged network, allowing you to connect directly to a
+  # network using the host's network device. This makes the VM appear as another
+  # physical device on your network.
+  # config.vm.network :bridged
+
+  # Forward a port from the guest to the host, which allows for outside
+  # computers to access the VM, whereas host only networking does not.
+  # config.vm.forward_port 80, 8080
+
+  # Share an additional folder to the guest VM. The first argument is
+  # an identifier, the second is the path on the guest to mount the
+  # folder, and the third is the path on the host to the actual folder.
+  # config.vm.share_folder "v-data", "/vagrant_data", "../data"
+
+  # Enable provisioning with Puppet stand alone.  Puppet manifests
+  # are contained in a directory path relative to this Vagrantfile.
+  # You will need to create the manifests directory and a manifest in
+  # the file precise-amd64.pp in the manifests_path directory.
+  #
+  # An example Puppet manifest to provision the message of the day:
+  #
+  # # group { "puppet":
+  # #   ensure => "present",
+  # # }
+  # #
+  # # File { owner => 0, group => 0, mode => 0644 }
+  # #
+  # # file { '/etc/motd':
+  # #   content => "Welcome to your Vagrant-built virtual machine!
+  # #               Managed by Puppet.\n"
+  # # }
+  #
+  # config.vm.provision :puppet do |puppet|
+  #   puppet.manifests_path = "manifests"
+  #   puppet.manifest_file  = "precise-amd64.pp"
+  # end
+
+  # Enable provisioning with chef solo, specifying a cookbooks path, roles
+  # path, and data_bags path (all relative to this Vagrantfile), and adding 
+  # some recipes and/or roles.
+  #
+  # config.vm.provision :chef_solo do |chef|
+  #   chef.cookbooks_path = "../my-recipes/cookbooks"
+  #   chef.roles_path = "../my-recipes/roles"
+  #   chef.data_bags_path = "../my-recipes/data_bags"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { :mysql_password => "foo" }
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision :chef_client do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # If you're using the Opscode platform, your validator client is
+  # ORGNAME-validator, replacing ORGNAME with your organization name.
+  #
+  # IF you have your own Chef Server, the default validation client name is
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
+end

data/test/centos6-64/run.sh

@@ -0,0 +1,7 @@
+#!/bin/sh -e
+
+bundle exec vagrant up
+bundle exec cap test_all
+bundle exec vagrant halt
+
+# vim:set ft=sh :

data/test/config/deploy.rb

@@ -0,0 +1,368 @@
+set :application, "capistrano-config"
+set :repository,  "."
+set :deploy_to do
+  File.join("/home", user, application)
+end
+set :deploy_via, :copy
+set :scm, :none
+set :use_sudo, false
+set :user, "vagrant"
+set :password, "vagrant"
+set :ssh_options, {:user_known_hosts_file => "/dev/null"}
+
+role :web, "192.168.33.10"
+role :app, "192.168.33.10"
+role :db,  "192.168.33.10", :primary => true
+
+$LOAD_PATH.push(File.expand_path("../../lib", File.dirname(__FILE__)))
+require "capistrano-config"
+require "tempfile"
+
+def _invoke_command(cmdline, options={})
+  via = options.delete(:via)
+  if via == :run_locally
+    run_locally(cmdline)
+  else
+    invoke_command(cmdline, options)
+  end
+end
+
+def assert_file_content(file, content, options={})
+  begin
+    if options[:via] == :run_locally
+      remote_content = File.read(file)
+    else
+      tempfile = Tempfile.new("tmp")
+      download(file, tempfile.path)
+      remote_content = tempfile.read
+    end
+    abort if content != remote_content
+  rescue
+    logger.debug("assert_file_content(#{file}, #{content}) failed.")
+    _invoke_command("cat #{file.dump}", options)
+    raise
+  end
+end
+
+def assert_symlink(file, link_to, options={})
+  begin
+    _invoke_command("test -h #{file.dump} && test #{link_to.dump} = $(readlink #{file.dump})")
+  rescue
+    logger.debug("assert_symlink(#{file}, #{link_to}) failed.")
+    _invoke_command("ls -l #{file.dump}", options)
+    raise
+  end
+end
+
+def assert_file_mode(mode, file, options={})
+  mode = mode.to_i(8) if mode.is_a?(String)
+  smode = "%c%c%c%c%c%c%c%c%c%c" % [
+    ?-,
+    mode & 0400 == 0 ? ?- : ?r, mode & 0200 == 0 ? ?- : ?w, mode & 0100 == 0 ? ?- : ?x,
+    mode & 0040 == 0 ? ?- : ?r, mode & 0020 == 0 ? ?- : ?w, mode & 0010 == 0 ? ?- : ?x,
+    mode & 0004 == 0 ? ?- : ?r, mode & 0002 == 0 ? ?- : ?w, mode & 0001 == 0 ? ?- : ?x,
+  ]
+  begin
+    _invoke_command("test #{smode.dump} = $(ls -l #{file.dump} | cut -d ' ' -f 1)", options)
+  rescue
+    logger.debug("assert_file_mode(#{mode.to_s(8)}, #{file}) failed.")
+    _invoke_command("ls -l #{file.dump}", options)
+    raise
+  end
+end
+
+def assert_file_owner(uid, file, options={})
+  uid = uid.to_i
+  # `stat -c` => GNU, `stat -f` => BSD
+  begin
+    _invoke_command("test #{uid} -eq $( stat -c '%u' #{file.dump} || stat -f '%u' #{file.dump} )", options)
+  rescue
+    logger.debug("assert_file_owner(#{uid}, #{file}) failed.")
+    _invoke_command("ls -l #{file.dump}", options)
+    raise
+  end
+end
+
+def assert_file_group(gid, file, options={})
+  gid = gid.to_i
+  # `stat -c` => GNU, `stat -f` => BSD
+  begin
+    _invoke_command("test #{gid} -eq $( stat -c '%g' #{file.dump} || stat -f '%g' #{file.dump} )", options)
+  rescue
+    logger.debug("assert_file_group(#{gid}, #{file}) failed.")
+    _invoke_command("ls -l #{file.dump}", options)
+    raise
+  end
+end
+
+task(:test_all) {
+  find_and_execute_task("test_default")
+  find_and_execute_task("test_with_options")
+  find_and_execute_task("test_with_remote")
+  find_and_execute_task("test_with_local")
+  find_and_execute_task("test_with_shared")
+}
+
+namespace(:test_default) {
+  task(:default) {
+    methods.grep(/^test_/).each do |m|
+      send(m)
+    end
+  }
+  before "test_default", "test_default:setup"
+  after "test_default", "test_default:teardown"
+
+  task(:setup) {
+    run("rm -rf #{deploy_to.dump}")
+    run_locally("mkdir -p tmp/local")
+    set(:config_template_path, "tmp")
+    set(:config_files, %w(foo bar baz))
+    set(:config_executable_files, %w(foo))
+    set(:config_path_local, "tmp/local")
+    set(:config_use_shared, true)
+    set(:config_update_remotely, true)
+    set(:config_update_locally, true)
+#   find_and_execute_task("deploy:setup")
+  }
+
+  task(:teardown) {
+    run_locally("rm -rf tmp")
+    run("rm -rf #{deploy_to.dump}")
+  }
+
+  task(:test_deploy) {
+    # xxx
+    run_locally("rm -f tmp/foo; echo xxx > tmp/foo")
+    run_locally("rm -f tmp/bar; echo xxx > tmp/bar")
+    run_locally("rm -f tmp/baz; echo xxx > tmp/baz")
+    find_and_execute_task("deploy:setup")
+    assert_file_content(File.join(config_shared_path, "foo"), File.read("tmp/foo"))
+
+    # yyy
+    run_locally("rm -f tmp/foo; echo yyy > tmp/foo")
+    run_locally("rm -f tmp/bar; echo yyy > tmp/bar")
+    run_locally("rm -f tmp/baz; echo yyy > tmp/baz")
+    find_and_execute_task("deploy")
+    assert_file_content(File.join(config_shared_path, "foo"), "xxx\n")
+    assert_symlink(File.join(config_path, "foo"), File.join(config_shared_path, "foo"))
+    assert_file_content(File.join(config_path_local, "foo"), "yyy\n", :via => :run_locally)
+
+    # executable?
+    run("test -x #{File.join(config_shared_path, "foo").dump}")
+    run_locally("test -x #{File.join(config_path_local, "foo").dump}")
+  }
+}
+
+namespace(:test_with_options) {
+  task(:default) {
+    methods.grep(/^test_/).each do |m|
+      send(m)
+    end
+  }
+  before "test_with_options", "test_with_options:setup"
+  after "test_with_options", "test_with_options:teardown"
+
+  task(:setup) {
+    sudo("rm -f /etc/__privileged__")
+    run("rm -rf #{deploy_to.dump}")
+    run_locally("mkdir -p tmp/local")
+    set(:config_template_path, "tmp")
+    set(:config_files, {
+      "secret" => {:mode => 0640},
+      "/etc/__privileged__" => { :configure_except => :local, :run_method => :sudo, :owner => 0, :group => 0 },
+    })
+    set(:config_path_local, "tmp/local")
+    set(:config_use_shared, false)
+    set(:config_update_remotely, true)
+    set(:config_update_locally, true)
+    find_and_execute_task("deploy:setup")
+  }
+
+  task(:teardown) {
+    run_locally("rm -rf tmp")
+    run("rm -rf #{deploy_to.dump}")
+    sudo("rm -f /etc/__privileged__")
+  }
+
+  task(:test_deploy) {
+    run_locally("rm -f tmp/secret; echo secret > tmp/secret")
+    run_locally("rm -f tmp/etc/__privileged__; mkdir -p tmp/etc; echo __privileged__ > tmp/etc/__privileged__")
+    find_and_execute_task("deploy")
+    assert_file_content(File.join(config_path, "secret"), File.read("tmp/secret"))
+    assert_file_mode(0640, File.join(config_path, "secret"))
+
+    assert_file_content("/etc/__privileged__", File.read("tmp/etc/__privileged__"))
+    assert_file_owner(0, "/etc/__privileged__")
+    assert_file_group(0, "/etc/__privileged__")
+  }
+}
+
+namespace(:test_with_remote) {
+  task(:default) {
+    methods.grep(/^test_/).each do |m|
+      send(m)
+    end
+  }
+  before "test_with_remote", "test_with_remote:setup"
+  after "test_with_remote", "test_with_remote:teardown"
+
+  task(:setup) {
+    run("rm -rf #{deploy_to.dump}")
+    run_locally("mkdir -p tmp/local")
+    set(:config_template_path, "tmp")
+    set(:config_files, %w(foo bar baz))
+    set(:config_executable_files, %w(foo))
+    set(:config_path_local, "tmp/local")
+    set(:config_use_shared, false)
+    set(:config_update_remotely, true)
+    set(:config_update_locally, false)
+    find_and_execute_task("deploy:setup")
+  }
+
+  task(:teardown) {
+    run_locally("rm -rf tmp")
+    run("rm -rf #{deploy_to.dump}")
+  }
+
+  task(:test_deploy) {
+    run_locally("rm -f tmp/foo; echo foo > tmp/foo")
+    run_locally("rm -f tmp/bar; echo bar > tmp/bar")
+    run_locally("rm -f tmp/baz; echo baz > tmp/baz")
+    find_and_execute_task("deploy")
+    assert_file_content(File.join(config_path, "foo"), File.read("tmp/foo"))
+    assert_file_content(File.join(config_path, "bar"), File.read("tmp/bar"))
+    assert_file_content(File.join(config_path, "baz"), File.read("tmp/baz"))
+  }
+
+  task(:test_redeploy) {
+    run_locally("rm -f tmp/foo; echo bar > tmp/foo")
+    run_locally("rm -f tmp/bar; echo baz > tmp/bar")
+    run_locally("rm -f tmp/baz; echo foo > tmp/baz")
+    find_and_execute_task("deploy")
+    assert_file_content(File.join(config_path, "foo"), File.read("tmp/foo"))
+    assert_file_content(File.join(config_path, "bar"), File.read("tmp/bar"))
+    assert_file_content(File.join(config_path, "baz"), File.read("tmp/baz"))
+  }
+}
+
+namespace(:test_with_local) {
+  task(:default) {
+    methods.grep(/^test_/).each do |m|
+      send(m)
+    end
+  }
+  before "test_with_local", "test_with_local:setup"
+  after "test_with_local", "test_with_local:teardown"
+
+  task(:setup) {
+    run("rm -rf #{deploy_to.dump}")
+    run_locally("mkdir -p tmp/local")
+    set(:config_template_path, "tmp")
+    set(:config_files, %w(foo bar baz))
+    set(:config_executable_files, %w(foo))
+    set(:config_path_local, "tmp/local")
+    set(:config_use_shared, false)
+    set(:config_update_remotely, false)
+    set(:config_update_locally, true)
+    find_and_execute_task("deploy:setup")
+  }
+
+  task(:teardown) {
+    run_locally("rm -rf tmp")
+    run("rm -rf #{deploy_to.dump}")
+  }
+
+  task(:test_deploy) {
+    run_locally("rm -f tmp/foo; echo foo > tmp/foo")
+    run_locally("rm -f tmp/bar; echo bar > tmp/bar")
+    run_locally("rm -f tmp/baz; echo baz > tmp/baz")
+    find_and_execute_task("deploy")
+    assert_file_content(File.join(config_path_local, "foo"), File.read("tmp/foo"), :via => :run_locally)
+    assert_file_content(File.join(config_path_local, "bar"), File.read("tmp/bar"), :via => :run_locally)
+    assert_file_content(File.join(config_path_local, "baz"), File.read("tmp/baz"), :via => :run_locally)
+  }
+
+  task(:test_redeploy) {
+    run_locally("rm -f tmp/foo; echo bar > tmp/foo")
+    run_locally("rm -f tmp/bar; echo baz > tmp/bar")
+    run_locally("rm -f tmp/baz; echo foo > tmp/baz")
+    find_and_execute_task("deploy")
+    assert_file_content(File.join(config_path_local, "foo"), File.read("tmp/foo"), :via => :run_locally)
+    assert_file_content(File.join(config_path_local, "bar"), File.read("tmp/bar"), :via => :run_locally)
+    assert_file_content(File.join(config_path_local, "baz"), File.read("tmp/baz"), :via => :run_locally)
+  }
+}
+
+namespace(:test_with_shared) {
+  task(:default) {
+    methods.grep(/^test_/).each do |m|
+      send(m)
+    end
+  }
+  before "test_with_shared", "test_with_shared:setup"
+  after "test_with_shared", "test_with_shared:teardown"
+
+  task(:setup) {
+    run("rm -rf #{deploy_to.dump}")
+    run_locally("mkdir -p tmp/local")
+    set(:config_template_path, "tmp")
+    set(:config_files, %w(foo bar baz))
+    set(:config_executable_files, %w(foo))
+    set(:config_path_local, "tmp/local")
+    set(:config_use_shared, true)
+    set(:config_update_remotely, true)
+    set(:config_update_locally, false)
+#   find_and_execute_task("deploy:setup")
+  }
+
+  task(:teardown) {
+    run_locally("rm -rf tmp")
+    run("rm -rf #{deploy_to.dump}")
+  }
+
+  task(:test_setup) {
+    run_locally("rm -f tmp/foo; echo foo > tmp/foo")
+    run_locally("rm -f tmp/bar; echo bar > tmp/bar")
+    run_locally("rm -f tmp/baz; echo baz > tmp/baz")
+    find_and_execute_task("deploy:setup")
+    assert_file_content(File.join(config_shared_path, "foo"), File.read("tmp/foo"))
+    assert_file_content(File.join(config_shared_path, "bar"), File.read("tmp/bar"))
+    assert_file_content(File.join(config_shared_path, "baz"), File.read("tmp/baz"))
+  }
+
+  task(:test_resetup) {
+    run_locally("rm -f tmp/foo; echo bar > tmp/foo")
+    run_locally("rm -f tmp/bar; echo baz > tmp/bar")
+    run_locally("rm -f tmp/baz; echo foo > tmp/baz")
+    find_and_execute_task("deploy:setup")
+    assert_file_content(File.join(config_shared_path, "foo"), File.read("tmp/foo"))
+    assert_file_content(File.join(config_shared_path, "bar"), File.read("tmp/bar"))
+    assert_file_content(File.join(config_shared_path, "baz"), File.read("tmp/baz"))
+  }
+
+  task(:test_deploy) {
+    find_and_execute_task("deploy")
+    assert_symlink(File.join(config_path, "foo"), File.join(config_shared_path, "foo"))
+    assert_symlink(File.join(config_path, "bar"), File.join(config_shared_path, "bar"))
+    assert_symlink(File.join(config_path, "baz"), File.join(config_shared_path, "baz"))
+  }
+
+  task(:test_redeploy) {
+    find_and_execute_task("deploy")
+    assert_symlink(File.join(config_path, "foo"), File.join(config_shared_path, "foo"))
+    assert_symlink(File.join(config_path, "bar"), File.join(config_shared_path, "bar"))
+    assert_symlink(File.join(config_path, "baz"), File.join(config_shared_path, "baz"))
+  }
+
+  task(:test_update_config) {
+    run_locally("rm -f tmp/foo; echo unu > tmp/foo")
+    run_locally("rm -f tmp/bar; echo du  > tmp/bar")
+    run_locally("rm -f tmp/baz; echo tri > tmp/baz")
+    find_and_execute_task("config:setup")
+    assert_file_content(File.join(config_path, "foo"), File.read("tmp/foo"))
+    assert_file_content(File.join(config_path, "bar"), File.read("tmp/bar"))
+    assert_file_content(File.join(config_path, "baz"), File.read("tmp/baz"))
+  }
+}
+
+# vim:set ft=ruby sw=2 ts=2 :

data/test/precise64/.gitignore

@@ -0,0 +1,5 @@
+/.bundle
+/.vagrant
+/known_hosts
+/tmp
+/vendor

data/test/precise64/Capfile

@@ -0,0 +1,2 @@
+load "deploy"
+load "../config/deploy"

data/test/precise64/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec(:path => "../..")

data/test/precise64/Vagrantfile

@@ -0,0 +1,99 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant::Config.run do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "precise64"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  config.vm.box_url = "http://files.vagrantup.com/precise64.box"
+
+  # Boot with a GUI so you can see the screen. (Default is headless)
+  # config.vm.boot_mode = :gui
+
+  # Assign this VM to a host-only network IP, allowing you to access it
+  # via the IP. Host-only networks can talk to the host machine as well as
+  # any other machines on the same network, but cannot be accessed (through this
+  # network interface) by any external networks.
+  config.vm.network :hostonly, "192.168.33.10"
+
+  # Assign this VM to a bridged network, allowing you to connect directly to a
+  # network using the host's network device. This makes the VM appear as another
+  # physical device on your network.
+  # config.vm.network :bridged
+
+  # Forward a port from the guest to the host, which allows for outside
+  # computers to access the VM, whereas host only networking does not.
+  # config.vm.forward_port 80, 8080
+
+  # Share an additional folder to the guest VM. The first argument is
+  # an identifier, the second is the path on the guest to mount the
+  # folder, and the third is the path on the host to the actual folder.
+  # config.vm.share_folder "v-data", "/vagrant_data", "../data"
+
+  # Enable provisioning with Puppet stand alone.  Puppet manifests
+  # are contained in a directory path relative to this Vagrantfile.
+  # You will need to create the manifests directory and a manifest in
+  # the file precise-amd64.pp in the manifests_path directory.
+  #
+  # An example Puppet manifest to provision the message of the day:
+  #
+  # # group { "puppet":
+  # #   ensure => "present",
+  # # }
+  # #
+  # # File { owner => 0, group => 0, mode => 0644 }
+  # #
+  # # file { '/etc/motd':
+  # #   content => "Welcome to your Vagrant-built virtual machine!
+  # #               Managed by Puppet.\n"
+  # # }
+  #
+  # config.vm.provision :puppet do |puppet|
+  #   puppet.manifests_path = "manifests"
+  #   puppet.manifest_file  = "precise-amd64.pp"
+  # end
+
+  # Enable provisioning with chef solo, specifying a cookbooks path, roles
+  # path, and data_bags path (all relative to this Vagrantfile), and adding 
+  # some recipes and/or roles.
+  #
+  # config.vm.provision :chef_solo do |chef|
+  #   chef.cookbooks_path = "../my-recipes/cookbooks"
+  #   chef.roles_path = "../my-recipes/roles"
+  #   chef.data_bags_path = "../my-recipes/data_bags"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { :mysql_password => "foo" }
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision :chef_client do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # If you're using the Opscode platform, your validator client is
+  # ORGNAME-validator, replacing ORGNAME with your organization name.
+  #
+  # IF you have your own Chef Server, the default validation client name is
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
+end

data/test/precise64/run.sh

@@ -0,0 +1,7 @@
+#!/bin/sh -e
+
+bundle exec vagrant up
+bundle exec cap test_all
+bundle exec vagrant halt
+
+# vim:set ft=sh :

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-config
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-27 00:00:00.000000000 Z
+date: 2013-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -32,17 +32,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.1
 - !ruby/object:Gem::Dependency
   name: capistrano-file-transfer-ext
   requirement: !ruby/object:Gem::Requirement
@@ -50,7 +50,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,7 +58,55 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: net-scp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+- !ruby/object:Gem::Dependency
+  name: vagrant
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.6
 description: a capistrano recipe to manage configurations files.
 email:
 - yamashita@geishatokyo.com
@@ -74,6 +122,17 @@ files:
 - capistrano-config.gemspec
 - lib/capistrano-config.rb
 - lib/capistrano-config/version.rb
+- test/centos6-64/.gitignore
+- test/centos6-64/Capfile
+- test/centos6-64/Gemfile
+- test/centos6-64/Vagrantfile
+- test/centos6-64/run.sh
+- test/config/deploy.rb
+- test/precise64/.gitignore
+- test/precise64/Capfile
+- test/precise64/Gemfile
+- test/precise64/Vagrantfile
+- test/precise64/run.sh
 homepage: https://github.com/yyuu/capistrano-config
 licenses: []
 post_install_message: 
@@ -98,4 +157,15 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: a capistrano recipe to manage configurations files.
-test_files: []
+test_files:
+- test/centos6-64/.gitignore
+- test/centos6-64/Capfile
+- test/centos6-64/Gemfile
+- test/centos6-64/Vagrantfile
+- test/centos6-64/run.sh
+- test/config/deploy.rb
+- test/precise64/.gitignore
+- test/precise64/Capfile
+- test/precise64/Gemfile
+- test/precise64/Vagrantfile
+- test/precise64/run.sh