conan 0.3.5 → 0.4.1

data/lib/conan/capistrano.rb

@@ -1,5 +1,7 @@
 require "bundler/capistrano"
 require "conan/deployment"
+require "conan/cloud/aws/provision"
+require "conan/cloud/aws/autoscale"
 
 Capistrano::Configuration.instance(:must_exist).load do
   Conan::Deployment.define_tasks(self)

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

@@ -0,0 +1,106 @@
+require 'fileutils'
+require 'fog'
+require 'json'
+
+require_relative "./utils"
+
+module AWS
+  class Autoscale
+    include Utils
+
+    attr_accessor :autoscale_config, :stage, :application
+
+    def initialize(stage = 'production', autoscale_config = {}, application = nil)
+      @autoscale_config = autoscale_config
+      @stage = stage
+      @application = application
+    end
+
+    def create_ami_from_server(server_name, region, image_description = nil)
+      image_name = "#{server_name}-image-#{Time.now.strftime('%Y%m%d%H%M')}" if image_name.nil?
+      image_description = "Image of #{server_name} created at #{DateTime.now} by conan"
+      server_to_image = find_server_by_name(server_name, region)
+
+      raise "Server #{server_name} in #{region} does not exist" if server_to_image.nil?
+
+      compute = Fog::Compute.new(:provider => :aws, :region => region)
+      puts "Creating image #{image_name} from server #{server_name}"
+      ami_request = compute.create_image(server_to_image.id, image_name, image_description)
+      image_id = ami_request.body["imageId"]
+
+      pending = true
+      image = nil
+
+      puts "Waiting for #{image_id} to become available"
+      while pending 
+        sleep 10
+        image = compute.images.get(image_id)
+        pending = image.state == "pending"
+      end
+
+      raise "Image creation failed" if image.state == 'failed'
+      image_id
+
+    end
+
+    def create_launch_config(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 = { :instance_monitoring => true,
+                         :instance_type => "m1.small",
+                         :key_name => default_key_name
+                       }
+
+      params = default_params.merge(new_conf)
+
+      if new_conf[:security_groups] and new_conf[:security_groups].size > 0
+        params[:security_groups] = new_conf[:security_groups].collect { |g| "#{stage}-#{g}" }
+      else
+        params[:security_groups] = ["#{stage}-default"]
+      end
+
+      if params[:server_to_image].nil?
+        params[:image_id] = default_image_id(region, params[:flavor_id], params[:root_device_type]) if params[:image_id].nil?
+      else
+        params[:image_id] = create_ami_from_server(params[:server_to_image], region)      end
+
+      autoscale = Fog::AWS::AutoScaling.new(:region => region)
+
+      #need to create new launchconfiugrations with unique names
+      #because you can't modify them and you can't delete them if they are attached
+      #to an autoscale group
+      params[:id] = "#{ec2_name_tag(name)}-#{Time.now.strftime('%Y%m%d%H%M')}"
+
+      puts "Creating Autoscale Launch Configuration #{params[:id]}"
+      lc = autoscale.configurations.create(params)
+
+      params[:autoscale_groups].each do |group_name|
+        asg = autoscale.groups.get(group_name)
+        "Setting Autoscale Group #{group_name} to use Launch Configration #{params[:id]}"
+        asg.connection.update_auto_scaling_group(asg.id, {"LaunchConfigurationName" => params[:id]})
+      end unless params[:autoscale_groups].nil?
+
+    end
+
+    def configure_autoscale
+    end
+
+    def update_autoscale
+      autoscale_config.each do |type, resources|
+         case type
+         when "launch-config"
+           resources.each do |name, conf|
+             create_launch_config(name, conf)
+           end
+         end
+      end
+    end
+
+  end
+end
+
+

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

@@ -2,72 +2,72 @@
   "ubuntu 10.04": {
     "ap-northeast-1": {
       "64-bit": {
-        "ebs": "ami-36e65037",
-        "instance-store": "ami-baf94fbb"
+        "ebs": "ami-942f9995",
+        "instance-store": "ami-902f9991"
       },
       "32-bit": {
-        "ebs": "ami-1ae6501b",
-        "instance-store": "ami-46f94f47"
+        "ebs": "ami-922f9993",
+        "instance-store": "ami-842f9985"
       }
     },
     "ap-southeast-1": {
       "64-bit": {
-        "ebs": "ami-c0c98c92",
-        "instance-store": "ami-3cc98c6e"
+        "ebs": "ami-7089cd22",
+        "instance-store": "ami-4e89cd1c"
       },
       "32-bit": {
-        "ebs": "ami-d8c98c8a",
-        "instance-store": "ami-76c98c24"
+        "ebs": "ami-7289cd20",
+        "instance-store": "ami-4489cd16"
       }
     },
     "eu-west-1": {
       "64-bit": {
-        "ebs": "ami-81dde2f5",
-        "instance-store": "ami-3fdde24b"
+        "ebs": "ami-fb665f8f",
+        "instance-store": "ami-1b665f6f"
       },
       "32-bit": {
-        "ebs": "ami-95dde2e1",
-        "instance-store": "ami-fddee189"
+        "ebs": "ami-f3665f87",
+        "instance-store": "ami-39665f4d"
       }
     },
     "sa-east-1": {
       "64-bit": {
-        "ebs": "ami-645f8079",
-        "instance-store": "ami-7a5f8067"
+        "ebs": "ami-7874ab65",
+        "instance-store": "ami-7c74ab61"
       },
       "32-bit": {
-        "ebs": "ami-6a5f8077",
-        "instance-store": "ami-4a5f8057"
+        "ebs": "ami-7e74ab63",
+        "instance-store": "ami-4674ab5b"
       }
     },
     "us-east-1": {
       "64-bit": {
-        "ebs": "ami-55dc0b3c",
-        "instance-store": "ami-35de095c"
+        "ebs": "ami-349b495d",
+        "instance-store": "ami-5c9b4935"
       },
       "32-bit": {
-        "ebs": "ami-71dc0b18",
-        "instance-store": "ami-4fd00726"
+        "ebs": "ami-3e9b4957",
+        "instance-store": "ami-809a48e9"
       }
     },
     "us-west-1": {
       "64-bit": {
-        "ebs": "ami-a191cfe4",
-        "instance-store": "ami-3991cf7c"
+        "ebs": "ami-7fb0e93a",
+        "instance-store": "ami-6bb0e92e"
       },
       "32-bit": {
-        "ebs": "ami-9991cfdc",
-        "instance-store": "ami-b390cef6"
+        "ebs": "ami-7db0e938",
+        "instance-store": "ami-63b0e926"
       }
     },
     "us-west-2": {
       "64-bit": {
-        "ebs": "ami-8eb33ebe",
-        "instance-store": "ami-94b33ea4"
+        "ebs": "ami-ec0b86dc",
+        "instance-store": "ami-e60b86d6"
       },
       "32-bit": {
-        "ebs": "ami-8cb33ebc",
-        "instance-store": "ami-bcb33e8c"
+        "ebs": "ami-ea0b86da",
+        "instance-store": "ami-e00b86d0"
       }
     }
   }

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

@@ -2,52 +2,60 @@ require "fileutils"
 require "fog"
 require "json"
 
+require_relative "./utils"
+require_relative "./security_group"
+
 module AWS
+
   class Provision
+  include Utils
+
+    attr_accessor :aws_config, :stage, :application
 
-    def initialize(aws_config = {}, stage = 'production')
+    def initialize(stage = 'production', aws_config = {}, application = nil)
       @aws_config = aws_config
       @stage = stage
+      @application = application
     end
 
-    def describe_env_to_json(file_path)
-      servers_json = {}
+    def describe_env(filter_role = nil)
+      server_config = {}
       servers = []
-      ["us-east-1", "us-west-1", "eu-west-1", "ap-southeast-1", "ap-northeast-1"].each do |region|
+      all_regions.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] = {}
+      stages.each do | st|
+        server_config[st] = {}
         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
+          if server.tags["stage"] == st
+            config = {}
+            config["roles"] = server.tags["roles"].split(", ") unless server.tags["roles"].nil?
+            config["alias"] = server.tags["name"]
+            if filter_role.nil? || config["roles"].include?(filter_role) 
+              server_config[st][server.dns_name] = config
+            end
           end 
         end
       end
+      server_config
 
-      File.open(file_path, "w") do |io|
-        io << JSON.pretty_generate(servers_json)
-      end
     end
     
-    def build_env()
+    def build_env
 
       #we need to check the existance of ~/.fog
 
       #first key_pairs
-      key_pairs = @aws_config["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"]
+      security_groups = aws_config["security"]
 
       if security_groups.nil? or security_groups.size == 0
         create_default_security_groups()
@@ -59,9 +67,13 @@ module AWS
         security_groups["rds"].each do |name, conf|
           create_rds_security_group(name, conf)
         end unless security_groups["rds"].nil?
+
+        security_groups["elasticache"].each do |name, conf|
+          create_elasticache_security_group(name, conf)
+        end unless security_groups["elasticache"].nil?
       end
 
-      @aws_config.each do |type, resources|
+      aws_config.each do |type, resources|
          case type
          when "ec2"
            resources.each do |name, conf|
@@ -79,6 +91,10 @@ module AWS
            resources.each do |name,conf|
              create_elb(name, conf)
            end
+         when "elasticache"
+           resources.each do |name,conf|
+             create_elasticache_cluster(name,conf)
+           end
          end
       end
     end
@@ -116,15 +132,22 @@ module AWS
 
       compute = Fog::Compute.new(:provider => :aws, :region => region)
 
-      sg_name = "#{@stage}-#{name}"
+      sg_name = ec2_name_tag(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?
+        sg = compute.security_groups.create(:name => sg_name, :description => "#{name} Security Group for #{stage}")
+        new_conf[:ingress].each do |ingress|
+          ingress = ingress.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo} 
+          port = ingress.delete(:port)
+          if ingress[:group_name]
+            ingress[:group_name] = ec2_name_tag(ingress[:group_name]) 
+            sg.authorize_ip_permission(Range.new(port.to_i,port.to_i),ingress)
+          else
+            sg.authorize_port_range(Range.new(port.to_i,port.to_i),ingress)
+          end
+        end unless new_conf[:ingress].nil?
       else
         puts "EC2 Security Group #{sg_name} already exists. Skipping"
       end
@@ -137,15 +160,15 @@ module AWS
         region = new_conf[:region] || "us-east-1"
         rds = Fog::AWS::RDS.new(:region => region)
 
-        rdssg_name = "#{@stage}-db-#{name}"
+        rdssg_name = rds_name_tag(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}")
+          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}")
+            rdssg.authorize_ec2_security_group("#{stage}-#{ec2_group}")
           end
         else
           puts "RDS Security Group #{rdssg_name} already exists. Skipping"
@@ -154,18 +177,51 @@ module AWS
       end
     end
 
+    def create_elasticache_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"
+        elasticache = Fog::AWS::Elasticache.new(:region => region)
+
+        cache_sg_name = elasticache_name_tag(name)
+
+        sg_exists = false
+        body = elasticache.describe_cache_security_groups.body
+        sg_exists = body['CacheSecurityGroups'].any? do |group|
+          group['CacheSecurityGroupName'] == cache_sg_name
+        end
+
+        unless sg_exists
+          puts "Creating Elasticache Security Group #{cache_sg_name}"
+          body = elasticache.create_cache_security_group(cache_sg_name, "#{cache_sg_name} ElastiCache Security Group for #{stage}").body
+          new_conf[:ec2_security_groups].each do |ec2_group|
+            compute = Fog::Compute.new(:provider => :aws, :region => region)
+            sg_name = ec2_name_tag(ec2_group)
+            sg = compute.security_groups.get(sg_name)
+            body = elasticache.authorize_cache_security_group_ingress(
+              cache_sg_name, sg.name, sg.owner_id).body
+          end
+        else
+          puts "Elasticache Security Group #{cache_sg_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)
 
+      new_conf['LocationConstraint'] = new_conf.delete(:location_constraint) if new_conf[:location_constraint]
+
       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)
+        storage.put_bucket(name, new_conf)
 
         acl = new_conf[:acl] || 'public-read'
 
@@ -181,7 +237,7 @@ module AWS
 
       zones = new_conf[:availability_zones] || all_availability_zones(region)
 
-      elb_name = "#{@stage}-#{name}"
+      elb_name = ec2_name_tag(name)
 
       lb = elb.load_balancers.get(elb_name)
       if lb.nil?
@@ -193,9 +249,9 @@ module AWS
       
         compute = Fog::Compute.new(:provider => :aws, :region => region)
 
-        inst_servers = new_conf[:servers].map { |s| "#{@stage}-#{s}" } unless new_conf[:servers].nil?
+        inst_servers = new_conf[:servers].map { |s| ec2_name_tag(s) } unless new_conf[:servers].nil?
 
-        compute.servers.all.each do |server|
+        list_stage_servers(region).each do |server|
           #the mocking seems wrong
           unless Fog.mocking?
             name = server.tags["name"]
@@ -213,7 +269,6 @@ module AWS
       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), 
@@ -228,32 +283,31 @@ module AWS
 
       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' }
+      server = find_server_by_name(name, region)
 
-      unless server_exists
+      #need to bork if no name in config file
+      ec2_name = ec2_name_tag(name)
+
+      unless server
         puts "Creating EC2 Server named #{ec2_name}"
         tags[:name] = ec2_name
-        tags[:stage] = @stage
+        tags[:Name] = ec2_name
+        tags[:stage] = stage
 
         if new_conf[:roles] 
-          new_conf[:roles] << @stage unless new_conf[:roles].include? @stage 
+          new_conf[:roles] << stage unless new_conf[:roles].include? stage 
           tags[:roles] = new_conf[:roles].join(', ')
         else
-          tags[:roles] = "app, db, #{@stage}"
+          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}" }
+          params[:groups] = new_conf[:groups].collect { |g| "#{stage}-#{g}" }
         else
-          params[:groups] = ["#{@stage}-default"]
+          params[:groups] = ["#{stage}-default"]
         end
 
         server = compute.servers.create(params)
@@ -281,12 +335,14 @@ module AWS
                          }
         params = default_params.merge(new_conf)
 
-        params[:id] = "#{@stage}-#{name}"
+        params[:id] = ec2_name_tag(name)
+
+        params.delete(:availability_zone) if params[:multi_az]
 
         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}" }
+          params[:security_group_names] = new_conf[:db_security_groups].collect { |g| rds_name_tag(g) }
         else
-          params[:db_security_groups] = ["#{@stage}-db-default"]
+          params[:security_group_names] = [rds_name_tag('default')]
         end
 
         server = rds.servers.get(params[:id])
@@ -295,49 +351,50 @@ module AWS
           puts "Creating RDS Server #{params[:id]}"
           server = rds.servers.create(params)
         else
-          puts "RDS Server #{params[:id]} aready exists. Skipping"
+          puts "RDS Server #{params[:id]} already exists. Skipping"
         end
       else
         puts "Fog is mocking. Can't test with RDS Servers. Skipping"
       end
     end
 
-    private
+    def create_elasticache_cluster(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"
 
-    def default_availability_zone(region)
-      #using availability zone b by default as a is often unavailable in us-east-1
-      "#{region}b"
-    end
+        elasticache = Fog::AWS::Elasticache.new(:region => region)
 
-    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
+        default_params = { :node_type => "cache.m1.large", 
+                           :num_nodes => 1,
+                           :port => 11211, 
+                           :preferred_availability_zone => default_availability_zone(region) 
+                         }
 
-    def default_image_id(region, flavor_id, root_device_type)
-      arch = ["m1.small", "t1.micro", "c1.medium"].include?(flavor_id) ? "32-bit" : "64-bit"
+        params = default_params.merge(new_conf)
 
-      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]
+        if new_conf[:security_groups] and new_conf[:security_groups].size > 0
+          params[:security_group_names] = new_conf[:security_groups].collect { |g| elasticache_name_tag(g)  }
+        else
+          params[:security_group_names] = [elasticache_name_tag('default')]
+        end
+
+        cluster_name = ec2_name_tag(name) 
 
-      raise "Default AMI not found for #{region} #{flavor_id} #{root_device_type}" if default_ami.nil?
-      default_ami
+        cl = elasticache.clusters.get(cluster_name)
 
+        unless cl
+          puts "Creating ElastiCache cluster #{cluster_name}"
+          params[:id] = cluster_name
+          cl = elasticache.clusters.new(params)
+          cl.save
+        else
+          puts "Elasticache cluster #{cluster_name} already exists. Skipping"
+        end
+
+      end
     end
+
   end
 end
 

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

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'fog/aws/models/compute/security_group'
+
+module Fog
+  module Compute
+    class AWS
+      class SecurityGroup
+        def authorize_ip_permission(port_range, options = {})
+          requires :name
+
+          permission = {
+            'FromPort'    => port_range.min,
+            'ToPort'      => port_range.max,
+            'IpProtocol'  => options[:ip_protocol] || 'tcp'
+          }
+
+          if options[:group_name]
+            grp_permitted = {'GroupName' => options[:group_name]}
+            grp_permitted['UserId'] = options[:user_id] if options[:user_id]
+            permission['Groups'] = [grp_permitted]
+          else 
+            ip_permitted = {'CidrIp' => "0.0.0.0/0"}
+            if options[:cidr_ip]
+              ip_permitted = {'CidrIp' => options[:cidr_ip]}
+            end 
+            permission['IpRanges'] = [ip_permitted]
+          end
+
+          connection.authorize_security_group_ingress(
+            name,
+            'IpPermissions' => [permission]
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require "fileutils"
+require "fog"
+require "json"
+
+module AWS
+  module Utils
+
+    def ec2_name_tag(server_name)
+      "#{stage}-#{server_name}"
+    end
+
+    def rds_name_tag(server_name)
+      "#{stage}-db-#{server_name}"
+    end
+
+    def elasticache_name_tag(server_name)
+      "#{stage}-elasticache-#{server_name}"
+    end
+
+    def find_server_by_name(name, region = nil)
+      regions_to_search = region.nil? ? all_regions : [region]
+      found_servers = []
+      regions_to_search.each do |r|
+        compute = Fog::Compute.new(:provider => :aws, :region => r)
+        servers = compute.servers.all
+        found_servers = found_servers + servers.select { |server| server.tags["name"] == ec2_name_tag(name) and server.state == 'running' }
+      end
+      found_servers.empty? ? nil : found_servers[0]
+    end
+    
+    def list_stage_servers(region = nil)
+      regions_to_search = region.nil? ? all_regions : [region]
+      found_servers = []
+      regions_to_search.each do |r|
+        compute = Fog::Compute.new(:provider => :aws, :region => r)
+        servers = compute.servers.all
+        found_servers = found_servers + servers.select { |server| server.tags["stage"] == stage and server.state == 'running' }
+      end
+      found_servers
+    end
+
+    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_regions
+      ['us-east-1', 'us-west-1', 'eu-west-1', 'ap-northeast-1', 'ap-southeast-1']
+    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

@@ -1,16 +1,45 @@
 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
+    AWS::Provision.new(stage, aws_config, application).build_env
   end
 
   task :write_config do
-     AWS::Provision.new.describe_env_to_json("config/servers.json")
+     server_config = AWS::Provision.new.describe_env
+     File.open("config/servers.json", "w") do |io|
+       io << JSON.pretty_generate(server_config)
+     end
   end
+
+  desc "Allows ssh to instance by name. cap ssh <NAME>"
+  task :ssh do
+    server = variables[:logger].instance_variable_get("@options")[:actions][2]
+    instance = AWS::Provision.new(stage).find_server_by_name(server)
+    unless instance.nil?
+      port = ssh_options[:port] || 22
+      command = "ssh -p #{port} ubuntu@#{instance.dns_name}"
+      puts "Running `#{command}`"
+      exec(command)
+    else
+      puts "Server #{server} not found"
+    end
+  end
+  
+  desc "create autoscale setup from config/autoscale.json"
+  task :create_autoscale do
+    autoscale_config = JSON.parse(File.read("config/autoscale.json"))[stage] || {}
+    AWS::Autoscale.new(stage, autoscale_config, application).configure_autoscale
+  end
+
+  desc "update autoscale from config/autoscale.json after a deployment"
+  task :update_autoscale do
+    autoscale_config = JSON.parse(File.read("config/autoscale.json"))[stage] || {}
+    AWS::Autoscale.new(stage, autoscale_config, application).update_autoscale
+  end
+
 end
 

data/lib/conan/deployment.rb

@@ -31,12 +31,11 @@ module Conan
 
       def add_role(*roles)
         roles = Hash.new{ |h,k| h[k] = [] }
-
         server_config.each do |s, c|
           c["roles"].each do |r|
             roles[r.to_sym] << s
           end
-        end
+        end unless server_config.nil?
 
         roles.each do |r, ss|
           next unless roles.include?(r)

data/lib/conan/deployment/chef.rb

@@ -18,7 +18,6 @@ namespace :chef do
       cache[host] ||= `ssh #{host} ifconfig`[/inet addr:(10\.\d+\.\d+\.\d+)/, 1]
       aliases[config["alias"]] = cache[host]
     end
-
     FileUtils.mkdir_p File.dirname(cache_path)
     File.open(cache_path, "w") do |io|
       io << JSON.dump(cache)

data/lib/conan/deployment/deploy.rb

@@ -1,5 +1,14 @@
 require "json"
-set :server_config, JSON.parse(File.read("config/servers.json"))[stage] || {}
+
+if File.exists?("config/servers.json")
+  set :server_config, JSON.parse(File.read("config/servers.json"))[stage] || {}
+else
+  if File.exists?("config/aws.json")
+    set :server_config, AWS::Provision.new.describe_env(application)[stage]
+  else
+    set :server_config, {}
+  end
+end
 
 add_role :app, :db
 

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

@@ -0,0 +1,15 @@
+{
+  "staging": {
+    "launch-config": {
+      "lcname": {
+        "server_to_image": "app1",
+        "image_id": "ORTHIS",
+        "flavor_id": "c1.xlarge",
+        "instance_monitoring": true
+        "key_name": "keyname",
+        "autoscale_groups": [""],
+        "security_groups": ["default"]
+      }
+    }
+  }
+}

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

@@ -99,12 +99,45 @@
           "region": "us-east-1",
           "ec2_security_groups": ["default"]
         }
-      } 
+      },
+      "elasticache": {
+        "default": {
+          "region": "us-east-1",
+          "ec2_security_groups": ["default"]
+        }
+      }
     }, 
     "s3": { 
       "test": { 
           "region": "us-east-1"
       }
-   } 
+   },
+    "elasticache": {
+      "cachename": {
+        "node_type": "cache.m1.large",
+        "num_nodes": 2,
+        "port": 11211,
+        "preferred_availablility_zone": "us-east-1b",
+        "security_groups": ["default"]
+      }
+    },
+   "cloud_watch": {
+     "metric_alarms": {
+       "alarmname": {
+         "region": "us-east-1",
+         "description": "CPU over 70%",
+         "comparison": "GreaterThanOrEqualToThreshold",
+         "evaluation_period": 1,
+         "metric_name": "CPUUtilization",
+         "namespace": "AWS/EC2",
+         "period": 60,
+         "statistic": "Average",
+         "threshold": 70,
+         "unit": "Percent",
+         "dimensions": {
+           "ec2": ["app-1"]
+         }
+     }
+   }
   }
 }

data/lib/conan/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: conan
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.4.1
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-15 00:00:00.000000000Z
+date: 2012-02-27 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &70097716738400 !ruby/object:Gem::Requirement
+  requirement: &70281889180960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 1.6.1
   type: :runtime
   prerelease: false
-  version_requirements: *70097716738400
+  version_requirements: *70281889180960
 - !ruby/object:Gem::Dependency
   name: capistrano
-  requirement: &70097716737480 !ruby/object:Gem::Requirement
+  requirement: &70281889178900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70097716737480
+  version_requirements: *70281889178900
 - !ruby/object:Gem::Dependency
   name: fog
-  requirement: &70097716735820 !ruby/object:Gem::Requirement
+  requirement: &70281889177220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,7 +44,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70097716735820
+  version_requirements: *70281889177220
 description: Set up a project to enable the provision of infrastructure through AWS
   and the configuration of servers using Chef via Capistrano.
 email:
@@ -56,8 +56,11 @@ extra_rdoc_files: []
 files:
 - bin/conan
 - lib/conan/capistrano.rb
+- lib/conan/cloud/aws/autoscale.rb
 - lib/conan/cloud/aws/default_amis.json
 - lib/conan/cloud/aws/provision.rb
+- lib/conan/cloud/aws/security_group.rb
+- lib/conan/cloud/aws/utils.rb
 - lib/conan/cloud/tasks.rb
 - lib/conan/common.rb
 - lib/conan/deployment/assets.rb
@@ -70,6 +73,7 @@ files:
 - lib/conan/smart_hash_merge.rb
 - lib/conan/template/Capfile
 - lib/conan/template/CONAN_TODO
+- lib/conan/template/config/autoscale.json
 - lib/conan/template/config/aws.json
 - lib/conan/template/config/deploy.rb
 - lib/conan/template/config/servers.json