capistrano-provisioning 0.0.3

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Sam Phillips
+
+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.mdown

@@ -0,0 +1,229 @@
+# Capistrano Provisioning
+
+Capistrano Provisioning is an extension to Capistrano that allows you to define clusters of servers and run provisioning tasks on them, such as installing users. It is a replacement for the fabric gem (http://rubygems.org/gems/fabric).
+
+## A word of caution
+
+This software is in alpha - we're releasing early so we can start using this gem in anger.
+
+## Installation
+
+### With bundler
+
+Add the following to your Gemfile:
+
+    gem 'capistrano-provisioning'
+
+If your bundler environment isn't initialised yet, you'll need to add something like this to your deploy.rb/Capfile:
+
+    require 'rubygems'
+    require 'bundler'
+
+    Bundler.setup
+    require 'capistrano-provisioning/recipes'   
+
+### Without bundler
+
+    gem install capistrano-provisioning
+    
+Either within your Capfile, or your deploy.rb, add:
+
+    require 'capistrano-provisioning/recipes'
+
+## Usage
+
+Once you have required the gem, the `cluster` command is available to you within capistrano recipes.
+
+The simplest usage of this would be something like:
+
+    cluster :web, 'web1.example.com'
+    
+In fact, this is shorthand for the following:
+
+    cluster :web do
+      servers 'web1.example.com'
+    end
+    
+Both of these would add a cap task called 'web'; calling this will mean any task specified later in the chain will run on the 'web' cluster. Eg:
+
+    cap web invoke COMMAND='uptime'
+    
+Which will run the 'uptime' command on 'web1.example.com'.
+
+You can specify multiple remote hosts like so:
+
+    cluster :web, 'web1.example.com', 'web2.example.com'
+
+So... this far it's quite similar to cap's own 'role' syntax. After this, however, life gets interesting...
+
+### Chaining
+
+If you want to run a task on multiple clusters, simply chain them as so:
+
+    cap web db invoke COMMAND='uptime'
+    
+... Assuming that you've defined a web and a db cluster!
+
+This will also work with namespaced clusters.
+
+### Installing users
+
+Specify the users that belong on a cluster as so:
+
+    cluster :web do
+      servers 'web1.example.com'
+      users 'bob', 'joe'
+    end
+    
+And put these users' public ssh keys in config/keys directory as so `config/keys/bob.pub` and `config/keys/joe.pub`
+    
+Running:
+
+    cap web install_users
+    
+... will now create these users on the servers if they don't exist, and add the keys to their authorized_keys file.
+
+You can specify groups as so:
+
+    cluster :web do
+      servers 'web1.example.com'
+      users 'bob', 'joe', :groups => ['some_group']
+      users 'rupert'
+    end
+    
+This will add Bob and Joe to some_group (:groups is an array, so add as many as you like), but won't add Rupert.
+
+### Bootstrapping
+
+To specify a block of code that is to be run to 'bootstrap' a server, do this:
+
+    cluster :web do
+      servers 'web1.example.com'
+      bootstrap do
+        run 'some_command'
+      end
+    end
+
+Run the following:
+
+    cap web run_bootstrap
+    
+And `some_command` will be run on the servers.
+
+### Namespaces and default users
+
+Namespaces work as you would expect:
+
+    namespace :system1 do
+      cluster :web do
+        # ...
+      end
+      
+      cluster :db do
+        # ...
+      end
+    end
+
+This block will create the following tasks:
+
+    cap system1:web
+    cap system1:db
+    
+As well as 
+
+    cap system1:all
+    
+Which will load all of the clusters defined in `system1`.
+
+It is also possible to define a default group of users for a namespace:
+
+    namespace :system1 do
+      default_users 'bob', 'joe', :groups => ['some_group']
+      default_users 'rupert'
+      cluster :web do
+        # ...
+      end
+  
+      cluster :db do
+        # ...
+      end
+    end
+
+Which would mean that running:
+
+    cap system1:web install_users
+
+... would add Bob, Joe and Rupert to the web cluster, with the appropriate groups.
+
+#### Inheriting default users
+
+By default, namespaces do _not_ inherit default users from the namespace above. If you want this inheritance, it's easy:
+
+    namespace :nested_namespace do
+      inherit_default_users
+    end
+
+If you want those users to have an additional group within this namespace only, use the following:
+
+    namespace :nested_namespace do
+      inherit_default_users :additional_groups => 'additional_group'
+    end
+    
+You can also pass an array of additional groups:
+
+    namespace :nested_namespace do
+      inherit_default_users :additional_groups => ['additional_group_1', 'additional_group_2']
+    end
+    
+#### Inheriting specific default users
+
+These groups of default users can also be named, so you can atomically specify inheritance:
+
+    namespace :system1 do
+      default_users 'bob', 'joe', :groups => ['some_group']
+      default_users 'rupert'
+      cluster :web do
+        # ...
+      end
+
+      cluster :db do
+        # ...
+      end
+    end
+
+Clusters can also inherit these named groups:
+
+    namespace :system1 do
+      default_users :admins, 'bob', 'joe'
+      cluster :web do
+        user :admins
+      end
+    end
+    
+These can be mixed in with normal user names:
+
+    namespace :system1 do
+      default_users :admins, 'bob', 'joe'
+      cluster :web do
+        user :admins, 'sam'
+      end
+    end
+
+## Features we guess we're probably going to need
+
+* Ability to output business-friendly documentation of how the clusters are set up (and what user access exists)
+* A way to remove user accounts that don't belong
+
+## 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) 2010 Sam Phillips. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "capistrano-provisioning"
+    gem.summary = %Q{Capistrano provisioning}
+    gem.description = %Q{Capistrano provisioning}
+    gem.email = "sam@samdanavia.com"
+    gem.homepage = "http://github.com/samdanavia/capistrano-provisioning"
+    gem.authors = ["Sam Phillips"]
+    gem.add_dependency "capistrano", ">= 2.5.18"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "capistrano-provisioning #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/capistrano-provisioning.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{capistrano-provisioning}
+  s.version = "0.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sam Phillips"]
+  s.date = %q{2010-06-16}
+  s.description = %q{Capistrano provisioning}
+  s.email = %q{sam@samdanavia.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.mdown"
+  ]
+  s.files = [
+    ".document",
+     "LICENSE",
+     "README.mdown",
+     "Rakefile",
+     "VERSION",
+     "capistrano-provisioning.gemspec",
+     "lib/capistrano-provisioning.rb",
+     "lib/capistrano-provisioning/cluster.rb",
+     "lib/capistrano-provisioning/namespaces.rb",
+     "lib/capistrano-provisioning/recipes.rb",
+     "lib/capistrano-provisioning/user.rb",
+     "pkg/capistrano-provisioning-0.0.0.gem",
+     "pkg/capistrano-provisioning-0.0.1.gem",
+     "pkg/capistrano-provisioning-0.0.3.gem",
+     "spec/cluster_spec.rb",
+     "spec/namespaces_spec.rb",
+     "spec/recipes_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/user_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/samdanavia/capistrano-provisioning}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Capistrano provisioning}
+  s.test_files = [
+    "spec/cluster_spec.rb",
+     "spec/namespaces_spec.rb",
+     "spec/recipes_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/user_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<capistrano>, [">= 2.5.18"])
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<capistrano>, [">= 2.5.18"])
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<capistrano>, [">= 2.5.18"])
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/lib/capistrano-provisioning/cluster.rb

@@ -0,0 +1,79 @@
+module CapistranoProvisioning
+  class Cluster
+    attr_accessor :name, :servers, :bootstrap, :config
+
+    def initialize(name, opts = {})
+      self.name = name    
+      self.servers = opts[:servers]
+      self.bootstrap = opts[:bootstrap]
+      self.config = opts[:config]
+            
+      @users = []
+      
+      add_cluster_cap_task
+    end
+    
+    def install_users
+      ensure_users      
+
+      self.servers.each do |server|
+        self.users.each do |user|
+          user.install(:server => server)
+        end
+      end
+    end
+    
+    def preview_users
+      ensure_users
+
+      self.servers.each do |server|
+        puts "#{server}: "
+        self.users.each do |user|
+          groups = user.groups.empty? ? '' : "(#{user.groups.join(', ')})"
+          puts "\t#{user.name} #{groups}"
+        end
+      end
+    end
+    
+    def ensure_users
+      if @users.empty? and config.respond_to?(:default_users)
+        @users = config.default_users
+      end
+      
+      abort "No users found" unless @users
+    end
+        
+    def add_users(users, opts = {})
+      @users += users.collect do |user|
+        if user.is_a? CapistranoProvisioning::User
+          user.config = self.config
+          user
+        else
+          opts.merge!(:name => user, :config => self.config)
+          CapistranoProvisioning::User.new(opts)         # This dependency should be injected, really.
+        end
+      end
+    end
+    
+    def unique_name
+      self.config.send(:unique_name) + ":" + self.name.to_s
+    end
+    
+    def users
+      ensure_users
+      @users
+    end
+
+    protected
+    
+    def add_cluster_cap_task
+      cluster = self
+      
+      self.config.task(name.to_sym, :desc => "Set the current cluster to '#{name}'") do
+        logger.info "Setting servers to #{cluster.servers.join(', ')}"
+        current_cluster = fetch(:clusters, [])
+        set(:clusters, current_cluster.push(cluster))
+      end
+    end
+  end
+end

data/lib/capistrano-provisioning/namespaces.rb

@@ -0,0 +1,152 @@
+module CapistranoProvisioning
+  module NamespaceExtension
+
+    attr_accessor :clusters
+    def cluster(name, *servers, &block)
+      # A note on initialising. At the moment I can't figure out how to initialize stuff from this module, 
+      # hence the untidy defaulting here.
+      self.clusters ||= {}
+      self.create_namespace_all_task
+          
+      cluster = CapistranoProvisioning::Cluster.new(name, :config => self)
+
+      self.clusters[cluster.unique_name] = cluster
+      self.clusters[cluster.unique_name].servers = servers
+
+      return unless block_given?
+
+      @current_cluster = cluster
+      yield block
+      @current_cluster = nil
+    end
+
+    def servers(*servers)
+      @current_cluster.servers = servers
+    end
+    alias :server :servers
+
+    def default_users(*args)
+      return @users || [] if args.empty?
+
+      name, users, options = parse_name_collection_and_options_args(args)
+      new_users = users.collect do |user|
+        CapistranoProvisioning::User.new(options.merge!(:name => user, :config => self))            
+      end
+      
+      if name
+        @user_groups ||= {}
+        @user_groups[name] = new_users
+      end
+
+      @users ||= []      
+      @users += new_users
+    end
+    alias :default_user :default_users
+    
+    def default_user_group(group)
+      @user_groups[group]
+    end
+
+    def inherit_default_users(*args)
+      groups, options = parse_collection_and_options_args(args)
+      
+      options[:additional_groups] = options[:additional_groups].to_a
+      parent_users = clone_parent_users(groups)
+        
+      if options[:additional_groups]
+        parent_users.collect! do |user|
+          user.groups += options[:additional_groups]
+          user
+        end
+      end
+
+      @users ||= []
+      @users += parent_users
+    end
+    alias :inherit_default_user :inherit_default_users
+
+    def users(*args)
+      users, options = parse_collection_and_options_args(args)
+
+      users_to_add = users.collect do |user|
+        if user.is_a? Symbol
+          group_users = @current_cluster.config.default_user_group(user).flatten
+          abort "Can't find user group for #{user} (in #{self.name})" unless group_users
+          group_users
+        else
+          user
+        end
+      end
+      
+      users_to_add.flatten!    
+      @current_cluster.add_users(users_to_add, options)
+    end
+    alias :user :users
+
+    def bootstrap(&block)
+      @current_cluster.bootstrap = block
+    end
+
+    def unique_name
+      if self.parent.respond_to?(:unique_name)
+        self.parent.unique_name + ":" + self.name.to_s
+      else
+        self.name.to_s
+      end
+    end
+
+    protected  
+    def create_namespace_all_task
+      return if self.tasks.keys.include?(:all)
+
+      task(:all, :desc => "Set the current clusters '#{name}'") do
+        clusters = self.clusters
+        clusters.merge!(self.offspring_clusters)
+
+        logger.info "Setting clusters to #{clusters.keys.collect(&:to_s).sort.join(', ')}"
+        set(:clusters, clusters.values)
+      end
+    end
+
+    def offspring_clusters
+      clusters = self.clusters
+      
+      self.namespaces.each do |name, namespace|
+        clusters.merge!(namespace.offspring_clusters)
+      end
+      
+      clusters
+    end
+    
+    def clone_parent_users(groups = [])
+      unless groups.empty?
+        groups.collect { |group| self.parent.default_user_group(group).collect(&:dup) }.flatten
+      else
+        self.parent.default_users.collect(&:dup)
+      end
+    end
+    
+    def parse_name_collection_and_options_args(args)
+      args = args.dup
+      
+      name = (args.first.is_a? Symbol) ? args.shift : nil
+      collection, options = parse_collection_and_options_args(args)
+      return name, collection, options
+    end
+
+    def parse_collection_and_options_args(args)
+      args = args.dup
+
+      if args.last.is_a? Hash
+        options = args.pop
+      else
+        options = {}
+      end
+
+      collection = args
+      return collection, options
+    end
+  end
+end
+
+Capistrano::Configuration::Namespaces::Namespace.send(:include, CapistranoProvisioning::NamespaceExtension)

data/lib/capistrano-provisioning/recipes.rb

@@ -0,0 +1,40 @@
+require 'capistrano-provisioning'
+
+Capistrano::Configuration.instance(:must_exist).load do
+  on :before, "cluster_ensure", :only => ["run_bootstrap", "install_users", "preview_users"]
+  desc "[Internal] Ensures that a cluster has been specified"
+  task :cluster_ensure do
+    @clusters = fetch(:clusters, false)
+    unless @clusters
+      abort("No cluster specified - please use one of '#{self.clusters.keys.join(', ')}'")
+    end
+  end
+  
+  # Will set  up a 'cluster' role, that will be set by the current provision.
+  set :servers, []
+  role(:cluster) {
+    fetch(:clusters).collect(&:servers).flatten
+  }
+
+  desc "Runs the bootstrap comamnds on the cluster"
+  task :run_bootstrap do
+    @clusters.each do |cluster|
+      abort "No bootstrap block given for '#{cluster.name}' cluster" unless cluster.bootstrap
+      cluster.bootstrap.call
+    end
+  end
+  
+  desc "Installs the specified users on the cluster"
+  task :install_users do
+    @clusters.each do |cluster|
+      cluster.install_users
+    end
+  end
+  
+  task :preview_users do
+    puts "The following users will be added: "
+    @clusters.each do |cluster|
+      cluster.preview_users
+    end
+  end
+end

data/lib/capistrano-provisioning/user.rb

@@ -0,0 +1,114 @@
+module CapistranoProvisioning
+  class User
+    attr_accessor :name, :config
+    attr_writer :groups, :key
+
+    def initialize(opts = {})
+      self.name = opts[:name]
+      self.config = opts[:config]
+      self.groups = opts[:groups].to_a || []
+    end
+        
+    def install(opts = {})    
+      abort "Aborting - Cannot install user #{self.name} as no server specified" unless opts[:server]
+      abort "Aborting - Could not find key for #{self.name} at #{local_key_file_path}" unless key
+
+      logger.debug "installing #{self.name} on #{opts[:server]}"    
+
+      self.create_account_on_server(opts[:server]) unless self.account_exists?(opts[:server])
+      self.create_ssh_config_directory(opts[:server])
+      self.update_authorized_keys(opts[:server])
+      self.add_account_to_groups(opts[:server])
+    end
+    
+    def groups
+      @groups.uniq
+    end
+    
+    protected
+    def account_exists?(server)
+      begin
+        if capture("id #{self.name}", :hosts => server)
+          true
+        else
+          false
+        end
+      rescue
+        # Must figure out a better way to capture that the command has failed
+        false
+      end
+    end
+    
+    def key
+      File.read(local_key_file_path) if File.exists?(local_key_file_path) 
+    end
+
+    def create_account_on_server(server)
+      run "#{sudo} /usr/sbin/useradd -m #{name}", :pty => true, :hosts => server
+    end
+    
+    def add_account_to_groups(server)
+      self.groups.each do |group|
+        run "#{sudo} /usr/sbin/usermod -a -G#{group} #{self.name}", :pty => true, :hosts => server
+      end
+    end
+    
+    def create_ssh_config_directory(server)
+      # Actual dirt
+      commands = <<-COMMANDS
+        sudo su root -c 'if [ ! -d #{ssh_config_directory_path} ]; then
+          sudo mkdir #{ssh_config_directory_path};
+        fi';
+        #{sudo} chown #{name} #{ssh_config_directory_path} &&
+        #{sudo} chmod 700 #{ssh_config_directory_path}
+      COMMANDS
+      
+      run commands, :pty => true, :hosts => server
+    end
+    
+    def update_authorized_keys(server)
+      commands = <<-COMMANDS
+        #{sudo} touch #{authorized_keys_file_path} &&
+        echo '#{key}' | sudo tee #{authorized_keys_file_path}
+      COMMANDS
+      run commands, :pty => true, :hosts => server
+    end
+    
+    def authorized_keys_file_path
+      "/home/#{self.name}/.ssh/authorized_keys"
+    end
+
+    def home_directory_path
+      "/home/#{self.name}/"
+    end
+
+    def ssh_config_directory_path
+      "/home/#{self.name}/.ssh/"
+    end
+    
+    def local_key_file_path
+      "config/keys/#{self.name}.pub"
+    end
+
+    
+    protected
+    # This isn't the best way to get to the run/logger stuff in this class -
+    # need to figure out a better way to do this, or a way to not need to.
+
+    def sudo(*parameters, &block)
+      self.config.sudo(*parameters, &block)
+    end
+
+    def logger
+      self.config.logger
+    end
+    
+    def run(cmd, options={}, &block)
+      self.config.run(cmd, options, &block)
+    end
+
+    def capture(command, options={})
+      self.config.capture(command, options)
+    end
+  end
+end

data/lib/capistrano-provisioning.rb

@@ -0,0 +1,3 @@
+require 'capistrano-provisioning/cluster'
+require 'capistrano-provisioning/user'
+require 'capistrano-provisioning/namespaces'

data/spec/cluster_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe CapistranoProvisioning::Cluster do
+  let(:config)          { Capistrano::Configuration.new }
+  let(:user)            { CapistranoProvisioning::User.new }
+  let(:namespace)       { Capistrano::Configuration::Namespaces::Namespace.new(:test_namespace, config) }
+  let(:cluster)         { CapistranoProvisioning::Cluster.new(cluster_name, :servers => [], :config => config) }
+  let(:cluster_name)    { '16nHElbcaf' }
+
+  it "should add a capistrano task" do
+    config_mock = mock(Capistrano::Configuration)  
+    config_mock.should_receive(:task).with(cluster_name.to_sym, anything)
+    CapistranoProvisioning::Cluster.new(cluster_name, :servers => [], :config => config_mock)
+  end
+  
+  it "should return an empty of array of users when it has none" do
+    cluster.users.should == []  
+  end
+
+  it "should add users from their names" do
+    # For some reason `expect {}.to change` didn't work here - reverting to old style for now
+    cluster.add_users ['test1', 'test2']
+    cluster.users.length.should == 2    
+  end
+  
+  it "should add users from objects" do
+    cluster.add_users [user]
+    cluster.users.length.should == 1
+  end
+  
+  it "should have a unique name" do
+    cluster = CapistranoProvisioning::Cluster.new(cluster_name, :servers => [], :config => namespace)
+    cluster.unique_name.should == "test_namespace:#{cluster_name}"
+  end
+
+  it "should take a bootstrap block" do
+    block = Proc.new {}
+    cluster.bootstrap = block
+    cluster.bootstrap.should == block
+  end
+  
+  context "and users" do
+    it "should use the namespace's default users if no users are specified" do
+      namespace.default_users 'sam', 'david'
+      cluster = CapistranoProvisioning::Cluster.new(cluster_name, :config => namespace)    
+
+      cluster.users.collect(&:name).should include('sam', 'david')
+    end
+
+    it "should not add users to the namespace" do
+      cluster = CapistranoProvisioning::Cluster.new(cluster_name, :config => namespace)    
+      cluster.add_users ['bob', 'juan']
+      
+      namespace.default_users.should == []
+    end
+    
+    it "should use the clusters's users if users are specified" do
+      namespace.default_users 'sam', 'david'
+      cluster = CapistranoProvisioning::Cluster.new(cluster_name, :config => namespace)    
+
+      cluster.add_users ['bob', 'juan']
+
+      user_names = cluster.users.collect(&:name)    
+      user_names.should include('bob', 'juan')
+      user_names.should_not include('sam', 'david')
+    end
+  
+    it "should install users" do
+      test_user, test_user_2 = user.dup, user.dup
+      
+      test_user.stub!(:key => 'test key')
+      test_user.should_receive(:install)
+      
+      test_user_2.stub!(:key => 'test key 2')
+      test_user_2.should_receive(:install)
+      
+      cluster.servers = 'host1.example.com'
+      cluster.add_users [test_user, test_user_2]
+      cluster.install_users
+    end
+  end
+end

data/spec/namespaces_spec.rb

@@ -0,0 +1,227 @@
+require 'spec_helper'
+
+describe Capistrano::Configuration do
+  let(:config)      { Capistrano::Configuration.new }
+  let(:namespace)   { Capistrano::Configuration::Namespaces::Namespace.new(:test_namespace, config) }
+  
+  context "default users" do
+    it "should take a list of default users" do
+      namespace.default_users 'sam', 'chris'
+      namespace.default_users.length.should == 2
+    end
+  
+    it "should take a name for the list of users" do
+      namespace.default_users :admin, 'sam', 'chris'
+      namespace.default_users.length.should == 2
+    end
+  
+    it "should return an empty array if there are no default users" do
+      namespace.default_users.length.should == 0
+    end
+  end
+
+  describe "default user inheritance" do
+    it "should inherit the users" do
+      namespace.default_users 'chris', 'sam'
+      namespace.namespace :nested do
+        inherit_default_users
+      end
+    
+      namespace.namespaces[:nested].default_users.length.should == 2
+    end
+    
+    it "should inherit a named group of users" do
+      namespace.default_users :admin, 'chris', 'sam'
+      namespace.namespace :nested do
+        inherit_default_users :admin
+      end
+    
+      namespace.namespaces[:nested].default_users.length.should == 2
+    end
+    
+    it "should inherit multiple named groups of users" do
+      namespace.default_users :admin, 'chris', 'sam'
+      namespace.default_users :developers, 'david', 'rob'
+      
+      namespace.namespace :nested do
+        inherit_default_users :admin, :developers
+      end
+      
+      namespace.namespaces[:nested].default_users.length.should == 4
+    end
+    
+    it "should inherit the users' groups" do
+      namespace.default_users 'sam', 'chris', :groups => 'test_group'
+      namespace.namespace :nested do
+        inherit_default_users
+      end
+
+      namespace.namespaces[:nested].default_users.each do |user|
+        user.groups.should include('test_group')
+      end
+    end
+
+    describe "additional groups" do
+      
+      it "should add one additional groups from a string" do
+        namespace.default_users 'sam', 'chris', :groups => 'test_group'
+        namespace.namespace :nested do
+          inherit_default_users :additional_groups => 'test_group_2'
+        end
+        
+        namespace.namespaces[:nested].default_users.each do |user|
+          user.groups.should include('test_group')
+          user.groups.should include('test_group_2')
+        end        
+      end
+
+      it "should add any additional groups from an array" do
+        namespace.default_users 'sam', 'chris', :groups => 'test_group'
+        namespace.namespace :nested do
+          inherit_default_users :additional_groups => ['test_group_2']
+        end
+      
+        namespace.namespaces[:nested].default_users.each do |user|
+          user.groups.should include('test_group')
+          user.groups.should include('test_group_2')
+        end
+      end
+
+      it "should not add additional groups to the original users" do
+        config.namespace :test_namespace do
+          default_users 'sam', 'chris', :groups => 'test_group'
+          namespace :nested do
+            inherit_default_users :additional_groups => 'test_group_2'
+          end
+        end
+
+        config.namespaces[:test_namespace].default_users.each do |user|
+          user.groups.should_not include('test_group_2')
+        end
+      end
+    end
+  end
+  
+  it "should create a cluster" do
+    namespace.cluster :test_cluster
+    namespace.clusters["test_namespace:test_cluster"].should be_a CapistranoProvisioning::Cluster
+  end
+  
+  it "cluster should take a list of servers inline" do
+    namespace.cluster :test_cluster, 'server_1', 'server_2'
+    namespace.clusters["test_namespace:test_cluster"].servers.length.should == 2
+  end
+
+  context "within a cluster" do
+    it "should take a list of users" do
+      config.namespace :test_namespace do
+        cluster :test_cluster do
+          users 'sam', 'chris'
+        end
+      end
+      
+      users = config.namespaces[:test_namespace].clusters["test_namespace:test_cluster"].users
+      user_names = users.collect(&:name)
+      user_names.should include('sam','chris')
+    end
+    
+    it "should inherit named users" do
+      config.namespace :test_namespace do
+        default_users :chaps, 'joe', 'bob'
+        cluster :test_cluster do
+          users :chaps
+        end
+      end
+      
+      users = config.namespaces[:test_namespace].clusters["test_namespace:test_cluster"].users
+      users.each do |user|
+        user.should be_a CapistranoProvisioning::User
+      end
+
+      user_names = users.collect(&:name)
+      user_names.should include('joe', 'bob')    
+      user_names.should_not include(:chaps)
+
+    end
+    
+    it "should raise an error if passed named users that do not exist" do
+      expect {
+        config.namespace :test_namespace do
+          default_users :chaps, 'joe', 'bob'
+          cluster :test_cluster do
+            users :non_existent_group
+          end
+        end
+      }.to raise_error
+    end
+    
+    it "should inherit named users mixed in with user names" do
+      config.namespace :test_namespace do
+        default_users :chaps, 'joe', 'bob'
+        cluster :test_cluster do
+          users :chaps, 'sam'
+        end
+      end
+      
+      user_names = config.namespaces[:test_namespace].clusters["test_namespace:test_cluster"].users.collect(&:name)
+      user_names.should include('joe', 'bob', 'sam')
+      user_names.should_not include(:chaps)
+    end
+  end
+
+  describe "unique name" do
+    it "should give a unique name on the top-tier namespace" do
+      namespace.send(:unique_name).should == 'test_namespace'
+    end
+    
+    it "should give a unique name on a second-tier namespace" do
+      namespace.namespace :foo do; end
+      namespace.namespaces[:foo].send(:unique_name).should == "test_namespace:foo"
+    end
+    
+    it "should give a unique name on a third-tier namespace" do
+      namespace.namespace :foo do
+        namespace :bar do; end
+      end
+      namespace.namespaces[:foo].namespaces[:bar].send(:unique_name).should == "test_namespace:foo:bar"
+    end
+  end
+  
+  # Shouldn't necessarily be testing these protected methods, 
+  # however it is complex and worthy of a spec, I feel.
+  context "argument parsing" do
+    it "should handle a named collection" do
+      args = [:test, 'sam', 'bob']
+      name, collection, options = namespace.send(:parse_name_collection_and_options_args, args)
+
+      name.should == :test
+      collection.should == ['sam', 'bob']
+      options.should be_empty
+    end
+    
+    it "should handle a named collection with options" do
+      args = [:test, 'sam', 'bob', { :option => true } ]
+      name, collection, options = namespace.send(:parse_name_collection_and_options_args, args)
+
+      name.should == args.first
+      collection.should == args.slice(1,2)
+      options.should == args.last
+    end
+    
+    it "should handle a collection with no options" do
+      args = ['sam', 'bob']
+      users, options = namespace.send(:parse_collection_and_options_args, args)
+
+      users.should == args
+      options.should be_empty      
+    end
+    
+    it "should handle a collection with options" do
+      args = ['sam', 'bob', { :option => true } ]
+      users, options = namespace.send(:parse_collection_and_options_args, args)
+
+      users.should == args.slice(0,2)
+      options.should == args.last
+    end
+  end
+end

data/spec/recipes_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+# TODO: Not sure how to test this yet
+
+describe "Recipes" do  
+  context "namespace" do
+    it "should create an :all task which loads all servers in that namespace"    
+  end
+
+  context "cluster definition" do
+    it "should create a task to set the servers"
+    
+    it "should create a task to bootstrap the servers"
+    
+    it "should create a task to install users on the servers"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--format specdoc

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+# This might not be a good idea... http://gist.github.com/54177
+require 'rubygems'
+
+require 'spec'
+require 'spec/autorun'
+
+require 'capistrano'
+require 'capistrano-provisioning'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/user_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe CapistranoProvisioning::User do
+  let(:username)      { 'z6MeKbLOXPqi5P' }
+  let(:server)        { 'test1.example.com' }
+  let(:config_mock)   { mock(Capistrano::Configuration) }
+  let(:user)          { CapistranoProvisioning::User.new(:name => username, :server => server, :config => config_mock) }
+
+  describe "install" do
+    it "should require a server" do
+      expect { user.install }.to raise_error(SystemExit)
+    end
+
+    it "should error if the user's ssh key cannot be loaded" do
+      expect { user.install(:server => server) }.to raise_error(SystemExit)
+    end  
+  end
+  
+  it "should create an account on the server" do      
+    config_mock.should_receive(:run).with(/#{username}/, anything()).once
+    config_mock.should_receive(:sudo).with(no_args()).once
+    
+    user.send(:create_account_on_server, server)
+  end
+  
+  describe "and groups" do
+    it "should return an empty array if there are no groups" do
+      user.groups.should == []
+    end
+    
+    it "should de-duplify groups" do
+      user.groups = ['test_group', 'test_group2', 'test_group']
+      user.groups.should == ['test_group','test_group2']
+    end
+    
+    it "should add a user to one group" do
+      user = CapistranoProvisioning::User.new(:name => username, :server => server, :config => config_mock, :groups => 'test_group')
+      user.groups.should include("test_group")
+    end
+    
+    it "should add a user to an array of groups" do
+      user = CapistranoProvisioning::User.new(:name => username, :server => server, :config => config_mock, :groups => ['test_group', 'test_group_2'])
+      user.groups.should include("test_group")
+      user.groups.should include("test_group_2")
+    end
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: capistrano-provisioning
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Sam Phillips
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-16 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 5
+        - 18
+        version: 2.5.18
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id002
+description: Capistrano provisioning
+email: sam@samdanavia.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.mdown
+files: 
+- .document
+- LICENSE
+- README.mdown
+- Rakefile
+- VERSION
+- capistrano-provisioning.gemspec
+- lib/capistrano-provisioning.rb
+- lib/capistrano-provisioning/cluster.rb
+- lib/capistrano-provisioning/namespaces.rb
+- lib/capistrano-provisioning/recipes.rb
+- lib/capistrano-provisioning/user.rb
+- pkg/capistrano-provisioning-0.0.0.gem
+- pkg/capistrano-provisioning-0.0.1.gem
+- pkg/capistrano-provisioning-0.0.3.gem
+- spec/cluster_spec.rb
+- spec/namespaces_spec.rb
+- spec/recipes_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/user_spec.rb
+has_rdoc: true
+homepage: http://github.com/samdanavia/capistrano-provisioning
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Capistrano provisioning
+test_files: 
+- spec/cluster_spec.rb
+- spec/namespaces_spec.rb
+- spec/recipes_spec.rb
+- spec/spec_helper.rb
+- spec/user_spec.rb