conan 0.2.1 → 0.3.5

data/README.md

@@ -104,6 +104,7 @@ In this scenario, the configuration for the staging server will be produced by m
 * `db.json`
 * `staging.json`
 
+
 Furthermore, this server will have the `app` and `db` roles in Capistrano, with
 the usual meanings: the application will be deployed on this server, and the
 database migrations will be run.

data/lib/conan/cloud/aws/default_amis.json

@@ -0,0 +1,74 @@
+{
+  "ubuntu 10.04": {
+    "ap-northeast-1": {
+      "64-bit": {
+        "ebs": "ami-36e65037",
+        "instance-store": "ami-baf94fbb"
+      },
+      "32-bit": {
+        "ebs": "ami-1ae6501b",
+        "instance-store": "ami-46f94f47"
+      }
+    },
+    "ap-southeast-1": {
+      "64-bit": {
+        "ebs": "ami-c0c98c92",
+        "instance-store": "ami-3cc98c6e"
+      },
+      "32-bit": {
+        "ebs": "ami-d8c98c8a",
+        "instance-store": "ami-76c98c24"
+      }
+    },
+    "eu-west-1": {
+      "64-bit": {
+        "ebs": "ami-81dde2f5",
+        "instance-store": "ami-3fdde24b"
+      },
+      "32-bit": {
+        "ebs": "ami-95dde2e1",
+        "instance-store": "ami-fddee189"
+      }
+    },
+    "sa-east-1": {
+      "64-bit": {
+        "ebs": "ami-645f8079",
+        "instance-store": "ami-7a5f8067"
+      },
+      "32-bit": {
+        "ebs": "ami-6a5f8077",
+        "instance-store": "ami-4a5f8057"
+      }
+    },
+    "us-east-1": {
+      "64-bit": {
+        "ebs": "ami-55dc0b3c",
+        "instance-store": "ami-35de095c"
+      },
+      "32-bit": {
+        "ebs": "ami-71dc0b18",
+        "instance-store": "ami-4fd00726"
+      }
+    },
+    "us-west-1": {
+      "64-bit": {
+        "ebs": "ami-a191cfe4",
+        "instance-store": "ami-3991cf7c"
+      },
+      "32-bit": {
+        "ebs": "ami-9991cfdc",
+        "instance-store": "ami-b390cef6"
+      }
+    },
+    "us-west-2": {
+      "64-bit": {
+        "ebs": "ami-8eb33ebe",
+        "instance-store": "ami-94b33ea4"
+      },
+      "32-bit": {
+        "ebs": "ami-8cb33ebc",
+        "instance-store": "ami-bcb33e8c"
+      }
+    }
+  }
+}

data/lib/conan/cloud/aws/provision.rb

@@ -0,0 +1,343 @@
+require "fileutils"
+require "fog"
+require "json"
+
+module AWS
+  class Provision
+
+    def initialize(aws_config = {}, stage = 'production')
+      @aws_config = aws_config
+      @stage = stage
+    end
+
+    def describe_env_to_json(file_path)
+      servers_json = {}
+      servers = []
+      ["us-east-1", "us-west-1", "eu-west-1", "ap-southeast-1", "ap-northeast-1"].each do |region|
+        compute = Fog::Compute.new(:provider => :aws, :region => region)
+        compute.servers.all.each { |s| servers << s if s.state == 'running' }
+      end
+      stages = servers.map {|s| s.tags["stage"] }.uniq
+
+      stages.each do | stage|
+        servers_json[stage] = {}
+        servers.each do |server|
+          if server.tags["stage"] == stage
+            server_json = {}
+            server_json[:roles] = server.tags["roles"].split(", ") unless server.tags["roles"].nil?
+            server_json[:alias] = server.tags["name"]
+            servers_json[stage][server.dns_name] = server_json
+          end 
+        end
+      end
+
+      File.open(file_path, "w") do |io|
+        io << JSON.pretty_generate(servers_json)
+      end
+    end
+    
+    def build_env()
+
+      #we need to check the existance of ~/.fog
+
+      #first key_pairs
+      key_pairs = @aws_config["key_pairs"]
+
+      key_pairs.each do |name, conf|
+        create_key_pair(name, conf)
+      end unless key_pairs.nil?
+
+      security_groups = @aws_config["security"]
+
+      if security_groups.nil? or security_groups.size == 0
+        create_default_security_groups()
+      else
+        security_groups["ec2"].each do |name, conf|
+          create_ec2_security_group(name, conf)
+        end unless security_groups["ec2"].nil?
+
+        security_groups["rds"].each do |name, conf|
+          create_rds_security_group(name, conf)
+        end unless security_groups["rds"].nil?
+      end
+
+      @aws_config.each do |type, resources|
+         case type
+         when "ec2"
+           resources.each do |name, conf|
+             create_ec2_server(name, conf)
+           end
+         when "rds"
+           resources.each do |name, conf|
+             create_rds_server(name, conf)
+           end
+         when "s3"
+           resources.each do |name, conf|
+             create_s3_bucket(name, conf)
+           end
+         when "elb"
+           resources.each do |name,conf|
+             create_elb(name, conf)
+           end
+         end
+      end
+    end
+
+    def create_key_pair(name, config = {})
+      new_conf = config.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo} 
+      region = new_conf[:region] || "us-east-1"
+      compute = Fog::Compute.new(:provider => :aws, :region => region)
+
+      kp = compute.key_pairs.get(name)
+      if kp.nil?
+        #no key pair create and write it out
+        puts "Creating key-pair #{name}"
+        kp = compute.key_pairs.create(:name => name)
+
+        puts "Writing key into your .ssh directory and adding it to ssh agent"
+        File.open("#{ENV['HOME']}/.ssh/#{kp.name}.pem", "w") do |io|
+          io << kp.private_key 
+        end
+        system("chmod 600 #{ENV['HOME']}/.ssh/#{kp.name}.pem")
+        system("ssh-add #{ENV['HOME']}/.ssh/#{kp.name}.pem")
+      else
+        puts "Key-pair #{name} already exists. Skipping"
+      end
+    end
+
+    def create_default_security_groups()
+      create_ec2_security_group('default', {:ports => ["22", "80"]})
+      create_rds_security_group('default', {:ec2_security_groups => ["default"]})
+    end
+
+    def create_ec2_security_group(name, config = {})
+      new_conf = config.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo} 
+      region = new_conf[:region] || "us-east-1"
+
+      compute = Fog::Compute.new(:provider => :aws, :region => region)
+
+      sg_name = "#{@stage}-#{name}"
+
+      sg = compute.security_groups.get(sg_name)
+      if sg.nil?
+        puts "Creating EC2 Secruity Group #{sg_name}"
+        sg = compute.security_groups.create(:name => sg_name, :description => "#{name} Security Group for #{@stage}")
+        new_conf[:ports].each do |port|
+          sg.authorize_port_range(Range.new(port.to_i,port.to_i))
+        end unless new_conf[:ports].nil?
+      else
+        puts "EC2 Security Group #{sg_name} already exists. Skipping"
+      end
+
+    end
+
+    def create_rds_security_group(name, config = {})
+      unless Fog.mocking?
+        new_conf = config.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+        region = new_conf[:region] || "us-east-1"
+        rds = Fog::AWS::RDS.new(:region => region)
+
+        rdssg_name = "#{@stage}-db-#{name}"
+
+        rdssg = rds.security_groups.get(rdssg_name)
+
+        if rdssg.nil?
+          puts "Creating RDS Security Group #{rdssg_name}"
+          rdssg = rds.security_groups.create(:id => rdssg_name, :description => "#{name} DB Security Group For #{@stage}")
+          new_conf[:ec2_security_groups].each do |ec2_group|
+            rdssg.authorize_ec2_security_group("#{@stage}-#{ec2_group}")
+          end
+        else
+          puts "RDS Security Group #{rdssg_name} already exists. Skipping"
+        end
+
+      end
+    end
+
+    def create_s3_bucket(name, config = {})
+      new_conf = config.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+      region = new_conf[:region] || "us-east-1"
+
+      storage = Fog::Storage.new(:provider => :aws, :region => region)
+
+      begin
+        bucket = storage.get_bucket(name)
+        puts "S3 Bucket #{name} already exists. Skipping"
+      rescue Excon::Errors::NotFound
+        puts "Creating S3 Bucket #{name}"
+        storage.put_bucket(name)
+
+        acl = new_conf[:acl] || 'public-read'
+
+        storage.put_bucket_acl(name, acl)
+      end
+    end
+
+    def create_elb(name, config = {})
+      new_conf = config.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+      region = new_conf[:region] || "us-east-1"
+
+      elb = Fog::AWS::ELB.new(:region => region)
+
+      zones = new_conf[:availability_zones] || all_availability_zones(region)
+
+      elb_name = "#{@stage}-#{name}"
+
+      lb = elb.load_balancers.get(elb_name)
+      if lb.nil?
+        puts "Creating Elastic Load Balancer #{elb_name}"
+      
+        lb = elb.load_balancers.create(:id => elb_name, :availability_zones => zones)
+      
+        #need to do listeners but for now stick with the default
+      
+        compute = Fog::Compute.new(:provider => :aws, :region => region)
+
+        inst_servers = new_conf[:servers].map { |s| "#{@stage}-#{s}" } unless new_conf[:servers].nil?
+
+        compute.servers.all.each do |server|
+          #the mocking seems wrong
+          unless Fog.mocking?
+            name = server.tags["name"]
+            lb.register_instances(server.id) if (inst_servers.nil? or inst_servers.include?(name))
+          end
+        end
+      else
+        puts "Elastic Load Balancer #{elb_name} already exists. Skipping"
+      end
+
+    end
+
+    def create_ec2_server(name, config = {})
+      new_conf = config.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+      region = new_conf[:region] || "us-east-1"
+
+      compute = Fog::Compute.new(:provider => :aws, :region => region)
+
+      default_key_name = compute.key_pairs.all.first.name
+
+      default_params = { :availability_zone => default_availability_zone(region), 
+                         :flavor_id => "m1.small", 
+                         :monitoring => true,
+                         :key_name => default_key_name, 
+                         :root_device_type => "instance-store" 
+                       }
+
+      params = default_params.merge(new_conf)
+      params[:image_id] = default_image_id(region, params[:flavor_id], params[:root_device_type]) if params[:image_id].nil?
+
+      tags  = {}
+
+      #need to bork if no name in config file
+      ec2_name = "#{@stage}-#{name}"
+
+      #need to parse all servers to see if this one exists
+      servers = compute.servers.all
+      server_exists = false
+      servers.each { |server| server_exists = true if server.tags["name"] == ec2_name and server.state == 'running' }
+
+      unless server_exists
+        puts "Creating EC2 Server named #{ec2_name}"
+        tags[:name] = ec2_name
+        tags[:stage] = @stage
+
+        if new_conf[:roles] 
+          new_conf[:roles] << @stage unless new_conf[:roles].include? @stage 
+          tags[:roles] = new_conf[:roles].join(', ')
+        else
+          tags[:roles] = "app, db, #{@stage}"
+        end
+
+        params[:tags] = tags
+
+        if new_conf[:groups] and new_conf[:groups].size > 0
+          params[:groups] = new_conf[:groups].collect { |g| "#{@stage}-#{g}" }
+        else
+          params[:groups] = ["#{@stage}-default"]
+        end
+
+        server = compute.servers.create(params)
+        server.wait_for { ready? } 
+      else
+        puts "EC2 Server named #{ec2_name} already exists. Skipping"
+      end
+
+    end
+
+    def create_rds_server(name, config = {})
+      unless Fog.mocking?
+        new_conf = config.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+        region = new_conf[:region] || "us-east-1"
+        rds = Fog::AWS::RDS.new(:region => region)
+        default_params = { :allocated_storage => 20, 
+                           :engine => 'mysql',
+                           :master_username => 'root', 
+                           :password => 'password',
+                           :backup_retention_period => 8, 
+                           :multi_az => false,
+                           :db_name =>"production", 
+                           :availability_zone => default_availability_zone(region), 
+                           :flavor_id => 'db.m1.small'
+                         }
+        params = default_params.merge(new_conf)
+
+        params[:id] = "#{@stage}-#{name}"
+
+        if new_conf[:db_security_groups] and new_conf[:db_security_groups].size > 0
+          params[:db_security_groups] = new_conf[:db_security_groups].collect { |g| "#{@stage}-db-#{g}" }
+        else
+          params[:db_security_groups] = ["#{@stage}-db-default"]
+        end
+
+        server = rds.servers.get(params[:id])
+
+        if server.nil?
+          puts "Creating RDS Server #{params[:id]}"
+          server = rds.servers.create(params)
+        else
+          puts "RDS Server #{params[:id]} aready exists. Skipping"
+        end
+      else
+        puts "Fog is mocking. Can't test with RDS Servers. Skipping"
+      end
+    end
+
+    private
+
+    def default_availability_zone(region)
+      #using availability zone b by default as a is often unavailable in us-east-1
+      "#{region}b"
+    end
+
+    def all_availability_zones(region)
+      case region
+      when "us-east-1"
+        #not using availability zone us-east-1a as it often fails
+        ["us-east-1b", "us-east-1c"]
+      when "us-west-1"
+        ["us-west-1a", "us-west-1b", "us-west-1c"]
+      when "eu-west-1"
+        ["eu-west-1a", "eu-west-1b"]
+      when "ap-northeast-1"
+        ["ap-northeast-1a", "ap-northeast-1a"]
+      when "ap-southeast-1"
+        ["ap-southeast-1a", "ap-southeast-1b"]
+      end
+    end
+
+    def default_image_id(region, flavor_id, root_device_type)
+      arch = ["m1.small", "t1.micro", "c1.medium"].include?(flavor_id) ? "32-bit" : "64-bit"
+
+      defaults = JSON.parse(File.read(File.expand_path(File.join(File.dirname(__FILE__), 'default_amis.json'))))
+      
+      region_defaults = defaults["ubuntu 10.04"][region]
+      raise "Invalid Region" if region_defaults.nil?
+      default_ami = region_defaults[arch][root_device_type]
+
+      raise "Default AMI not found for #{region} #{flavor_id} #{root_device_type}" if default_ami.nil?
+      default_ami
+
+    end
+  end
+end
+

data/lib/conan/cloud/tasks.rb

@@ -0,0 +1,16 @@
+require "fileutils"
+require "json"
+require File.expand_path(File.join(File.dirname(__FILE__), 'aws/provision'))
+
+namespace :aws do
+
+  task :provision do
+    aws_config = JSON.parse(File.read("config/aws.json"))[stage] || {}
+    AWS::Provision.new(aws_config, stage).build_env
+  end
+
+  task :write_config do
+     AWS::Provision.new.describe_env_to_json("config/servers.json")
+  end
+end
+

data/lib/conan/common.rb

@@ -0,0 +1,5 @@
+def _cset(name, *args, &block)
+    unless exists?(name)
+      set(name, *args, &block)
+    end
+end

data/lib/conan/deployment.rb

@@ -1,6 +1,12 @@
 module Conan
   class Deployment
     module Helpers
+      def _cset(name, *args, &block)
+        unless exists?(name)
+          set(name, *args, &block)
+        end
+      end
+
       def with_user(new_user, &blk)
         old_user = user
         return if old_user == new_user
@@ -43,13 +49,27 @@ module Conan
 
     class <<self
       def define_tasks(context)
-        load_script(context, "deploy")
-        load_script(context, "chef")
-        load_script(context, "git")
+        load_script(context, "deployment/deploy")
+        load_script(context, "deployment/chef")
+
+        load_script(context, "deployment/git") 
+
+        load_script(context, "cloud/tasks")
+
+        #need to change to only compile for rails 3.1
+        begin
+          rails_v = `bundle exec rails -v`.chomp.split(' ').last
+          if Gem::Version.new(rails_v) > Gem::Version.new('3.1.0')
+            load_script(context, "deployment/assets")
+          end
+        rescue
+          #not a rails or 3.1 app or bundle failed
+        end
+
       end
 
       def load_script(context, fragment)
-        path = File.expand_path("../deployment/#{fragment}.rb", __FILE__)
+        path = File.expand_path("../#{fragment}.rb", __FILE__)
         code = File.read(path)
         context.instance_eval(code, path)
       end

data/lib/conan/deployment/assets.rb

@@ -0,0 +1,61 @@
+def _cset(name, *args, &block)
+  unless exists?(name)
+    set(name, *args, &block)
+  end
+end
+
+_cset :asset_env, "RAILS_GROUPS=assets"
+_cset :assets_prefix, "assets"
+
+before 'deploy:finalize_update', 'deploy:assets:symlink'
+after 'deploy:update_code', 'deploy:assets:precompile'
+
+namespace :deploy do
+  namespace :assets do
+    desc <<-DESC
+      [internal] This task will set up a symlink to the shared directory \
+      for the assets directory. Assets are shared across deploys to avoid \
+      mid-deploy mismatches between old application html asking for assets \
+      and getting a 404 file not found error. The assets cache is shared \
+      for efficiency. If you cutomize the assets path prefix, override the \
+      :assets_prefix variable to match.
+    DESC
+    task :symlink, :roles => :app, :except => { :no_release => true } do
+      run <<-CMD
+        rm -rf #{latest_release}/public/#{assets_prefix} &&
+        mkdir -p #{latest_release}/public &&
+        mkdir -p #{shared_path}/assets &&
+        ln -s #{shared_path}/assets #{latest_release}/public/#{assets_prefix}
+      CMD
+    end
+
+    desc <<-DESC
+      Run the asset precompilation rake task. You can specify the full path \
+      to the rake executable by setting the rake variable. You can also \
+      specify additional environment variables to pass to rake via the \
+      asset_env variable. The defaults are:
+
+        set :rake,      "rake"
+        set :rails_env, "production"
+        set :asset_env, "RAILS_GROUPS=assets"
+    DESC
+    task :precompile, :roles => :app, :except => { :no_release => true } do
+      run "cd #{latest_release} && #{rake} RAILS_ENV=#{rails_env} #{asset_env} assets:precompile"
+    end
+
+    desc <<-DESC
+      Run the asset clean rake task. Use with caution, this will delete \
+      all of your compiled assets. You can specify the full path \
+      to the rake executable by setting the rake variable. You can also \
+      specify additional environment variables to pass to rake via the \
+      asset_env variable. The defaults are:
+
+        set :rake,      "rake"
+        set :rails_env, "production"
+        set :asset_env, "RAILS_GROUPS=assets"
+    DESC
+    task :clean, :roles => :app, :except => { :no_release => true } do
+      run "cd #{latest_release} && #{rake} RAILS_ENV=#{rails_env} #{asset_env} assets:clean"
+    end
+  end
+end

data/lib/conan/deployment/git.rb

@@ -1,5 +1,5 @@
 namespace :git do
-  before "deploy:update_code", "git:tag_attempted_deploy"
+  before "deploy:update_code", "git:tag_attempted_deploy" unless deploy_via == :copy
   task :tag_attempted_deploy do
     git_tag branch, "#{stage}.last-deploy"
   end
@@ -7,5 +7,5 @@ namespace :git do
   task :tag_successful_deploy do
     git_tag branch, "#{stage}.last-successful-deploy"
   end
-  after "deploy:smoke_test", "git:tag_successful_deploy"
+  after "deploy:smoke_test", "git:tag_successful_deploy" unless deploy_via == :copy
 end

data/lib/conan/initializer.rb

@@ -1,4 +1,6 @@
 require "fileutils"
+require "rubygems"
+require "bundler/setup"
 
 module Conan
   class Initializer
@@ -11,7 +13,7 @@ module Conan
 
     def initialize(where, settings)
       @destination = File.expand_path(where)
-      @settings = settings
+      @settings = Conan::Settings.new(settings)
     end
 
     def run
@@ -32,7 +34,8 @@ module Conan
 
     def add_git_submodule
       return unless File.directory?(".git")
-      sh "git submodule add git://github.com/madebymany/cookbooks.git deploy/chef/recipes/cookbooks >/dev/null 2>&1"
+      return if File.directory?("deploy/chef/recipes/cookbooks")
+      sh "git submodule add #{@settings["COOKBOOK_REPOSITORY"]} deploy/chef/recipes/cookbooks #{@settings["COOKBOOK_BRANCH"]} >/dev/null 2>&1"
     end
 
     def copy_template

data/lib/conan/settings.rb

@@ -2,8 +2,8 @@ require "conan/version"
 
 module Conan
   class Settings
-    def initialize
-      @settings = defaults
+    def initialize(settings = {})
+      @settings = defaults.merge(settings)
     end
 
     def []=(k, v)
@@ -19,7 +19,7 @@ module Conan
       {
         "APPLICATION"         => application_from_git_remote,
         "COOKBOOK_REPOSITORY" => "git://github.com/madebymany/cookbooks.git",
-        "COOKBOOK_BRANCH"     => "minimal",
+        "COOKBOOK_BRANCH"     => "master",
         "VERSION"             => Conan::VERSION,
       }
     end

data/lib/conan/template/CONAN_TODO

@@ -1,6 +1,24 @@
 Conan the Deployer has set up your project.
 
-Next, set up your deployment:
+Optional: if you are use AWS you can provision instances from a json file
+
+* Add or edit ~/.fog to include your AWS access and secret key: It should look something like:
+:default:
+  :aws_access_key_id: AithisismykeyYxDr 
+  :aws_secret_access_key: PeT/thisismysecretaccesskey9HyE
+
+* Edit config/aws.json to describe your AWS environments
+
+Now you can use capistrano to provision your environment
+
+* cap staging aws:provision
+
+Then you can write out the config/servers.json which will be used in the next steps
+
+* cap staging aws:write_config
+(this will actually write out all environments so you may need to re-run it if you provision a new environment)
+
+Next, set up your deployment or if you are not using AWS start her:
 
 * Edit config/servers.json to specify your stages, servers, and roles
 

data/lib/conan/template/config/aws.json

@@ -0,0 +1,110 @@
+{
+  "staging": {
+    "key_pairs": { 
+     "keypair-name": {
+       "region": "us-east-1"
+     }
+    },
+    "ec2": { 
+       "app1": {
+        "region": "us-east-1",
+        "monitoring": false,
+        "roles": ["app", "db", "staging"],
+        "flavor_id": "m1.small",
+        "availability_zone": "us-east-1b",
+        "groups": ["default"]
+       }
+    },
+    "rds": { 
+      "db1": {
+        "region": "us-east-1",
+        "flavor_id": "db.m1.small",
+        "backup_retention_period": "1",
+        "multi_az": false,
+        "availability_zone": "us-east-1b",
+        "db_security_groups": ["default"],
+        "db_name": "app_production",
+        "master_username": "root",
+        "password": "TODO"
+      }
+    }, 
+    "security": { 
+       "ec2": { 
+         "default": {
+           "region": "us-east-1",
+           "ports": ["22", "80"]
+         }
+        },
+      "rds": { 
+        "default": {
+          "region": "us-east-1",
+          "ec2_security_groups": ["default"]
+        }
+      } 
+    }, 
+    "s3": { 
+      "bucket-name": { 
+        "region": "us-east-1"
+      }
+   } 
+  },
+  "production": {
+    "ec2": { 
+       "app1": {
+        "region": "us-east-1",
+        "monitoring": true,
+        "roles": ["app", "db", "production"],
+        "flavor_id": "m1.small",
+        "availability_zone": "us-east-1b",
+        "groups": ["default"]
+       },
+       "app2": {
+        "region": "us-east-1",
+        "roles": ["app", "db", "production"],
+        "flavor_id": "m1.small",
+        "availability_zone": "us-east-1b",
+        "groups": ["default"]
+       }
+    },
+    "rds": { 
+      "db1": {
+        "region": "us-east-1",
+        "multi_az": true,
+        "flavor_id": "db.m1.small",
+        "allocated_storage": 100,
+        "availability_zone": "us-east-1b",
+        "db_security_groups": ["default"],
+        "backup_retention_period": "8",
+        "db_name": "app_production",
+        "master_username": "root",
+        "password": "TODO"
+      }
+    },
+    "elb": { 
+     "lb1": {
+        "region": "us-east-1",
+        "servers": ["app1", "app2"],
+        "https": "false"
+     }
+    },
+    "security": { 
+       "ec2": { 
+         "default": {
+           "region": "us-east-1",
+           "ports": ["22", "80"]
+         }
+        },
+      "rds": { 
+        "default": {
+          "region": "us-east-1",
+          "ec2_security_groups": ["default"]
+        }
+      } 
+    }, 
+    "s3": { 
+      "test": { 
+          "region": "us-east-1"
+      }
+   } 
+  }
+}

data/lib/conan/template/config/deploy.rb

@@ -42,6 +42,8 @@ set :user,          "rails"
 set :deploy_to,     "/mnt/#{application}"
 set :ruby_version,  "1.9.2"
 
+ssh_options[:forward_agent] = true
+
 # Let Conan take over
 require "conan/version"
 unless Conan::VERSION == "{{VERSION}}"

data/lib/conan/template/deploy/chef/dna/base.json

@@ -29,7 +29,7 @@
     "listen_ports": ["80"]
   },
   "passenger": {
-    "version": "2.2.14"
+    "version": "3.0.11"
   },
   "recipes": [
     "hosts"

data/lib/conan/version.rb

@@ -1,3 +1,3 @@
 module Conan
-  VERSION = "0.2.1"
+  VERSION = "0.3.5"
 end

metadata

@@ -1,49 +1,66 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: conan
-version: !ruby/object:Gem::Version 
-  hash: 21
+version: !ruby/object:Gem::Version
+  version: 0.3.5
   prerelease: 
-  segments: 
-  - 0
-  - 2
-  - 1
-  version: 0.2.1
 platform: ruby
-authors: 
+authors:
 - Paul Battley
+- Stuart Eccles
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-09-29 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-02-15 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: json
+  requirement: &70097716738400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70097716738400
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: &70097716737480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: *70097716737480
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: &70097716735820 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-description: Set up a project to enable the configuration of servers using Chef via Capistrano.
-email: 
-- pbattley@gmail.com
-executables: 
+  prerelease: false
+  version_requirements: *70097716735820
+description: Set up a project to enable the provision of infrastructure through AWS
+  and the configuration of servers using Chef via Capistrano.
+email:
+- stuart@madebymany.co.uk
+executables:
 - conan
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - bin/conan
 - lib/conan/capistrano.rb
+- lib/conan/cloud/aws/default_amis.json
+- lib/conan/cloud/aws/provision.rb
+- lib/conan/cloud/tasks.rb
+- lib/conan/common.rb
+- lib/conan/deployment/assets.rb
 - lib/conan/deployment/chef.rb
 - lib/conan/deployment/deploy.rb
 - lib/conan/deployment/git.rb
@@ -53,6 +70,7 @@ files:
 - lib/conan/smart_hash_merge.rb
 - lib/conan/template/Capfile
 - lib/conan/template/CONAN_TODO
+- lib/conan/template/config/aws.json
 - lib/conan/template/config/deploy.rb
 - lib/conan/template/config/servers.json
 - lib/conan/template/deploy/chef/dna/app.json
@@ -69,39 +87,28 @@ files:
 - lib/conan/template/deploy/chef/solo.rb
 - lib/conan/version.rb
 - README.md
-has_rdoc: true
 homepage: http://github.com/madebymany/conan
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.3
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Conan The Deployer
 test_files: []
-