rubber 2.3.1 → 2.4.0

data/lib/rubber/cloud/digital_ocean.rb

@@ -0,0 +1,96 @@
+require 'rubber/cloud/fog'
+
+module Rubber
+  module Cloud
+
+    class DigitalOcean < Fog
+
+      def initialize(env, capistrano)
+        compute_credentials = {
+          :provider => 'DigitalOcean',
+          :digitalocean_api_key => env.api_key,
+          :digitalocean_client_id => env.client_key
+        }
+
+        if env.cloud_providers && env.cloud_providers.aws
+          storage_credentials = {
+            :provider => 'AWS',
+            :aws_access_key_id => env.cloud_providers.aws.access_key,
+            :aws_secret_access_key => env.cloud_providers.aws.secret_access_key
+          }
+
+          env['storage_credentials'] = storage_credentials
+        end
+
+        env['compute_credentials'] = compute_credentials
+        super(env, capistrano)
+      end
+
+      def create_instance(instance_alias, image_name, image_type, security_groups, availability_zone, region)
+        do_region = compute_provider.regions.find { |r| r.name == region }
+        if do_region.nil?
+          raise "Invalid region for DigitalOcean: #{region}"
+        end
+
+        image = compute_provider.images.find { |i| i.name == image_name }
+        if image.nil?
+          raise "Invalid image name for DigitalOcean: #{image_name}"
+        end
+
+        flavor = compute_provider.flavors.find { |f| f.name == image_type }
+        if flavor.nil?
+          raise "Invalid image type for DigitalOcean: #{image_type}"
+        end
+
+        # Check if the SSH key has been added to DigitalOcean yet.
+        # TODO (nirvdrum 03/23/13): DigitalOcean has an API for getting a single SSH key, but it hasn't been added to fog yet.  We should add it.
+        ssh_key = compute_provider.list_ssh_keys.body['ssh_keys'].find { |key| key['name'] == env.key_name }
+        if ssh_key.nil?
+          if env.key_file
+            ssh_key = compute_provider.create_ssh_key(env.key_name, File.read("#{env.key_file}.pub"))
+          else
+            raise 'Missing key_file for DigitalOcean'
+          end
+        end
+
+        response = compute_provider.servers.create(:name => "#{Rubber.env}-#{instance_alias}",
+                                                   :image_id => image.id,
+                                                   :flavor_id => flavor.id,
+                                                   :region_id => do_region.id,
+                                                   :ssh_key_ids => [ssh_key['id']])
+
+        response.id
+      end
+
+      def describe_instances(instance_id=nil)
+        instances = []
+        opts = {}
+
+        if instance_id
+          response = [compute_provider.servers.get(instance_id)]
+        else
+          response = compute_provider.servers.all(opts)
+        end
+
+        response.each do |item|
+          instance = {}
+          instance[:id] = item.id
+          instance[:state] = item.state
+          instance[:type] = item.flavor_id
+          instance[:external_ip] = item.ip_address
+          instance[:internal_ip] = item.ip_address
+          instance[:region_id] = item.region_id
+          instance[:provider] = 'digital_ocean'
+          instance[:platform] = 'linux'
+          instances << instance
+        end
+
+        return instances
+      end
+
+      def active_state
+        'active'
+      end
+    end
+  end
+end

data/lib/rubber/cloud/fog.rb

@@ -10,9 +10,12 @@ module Rubber
 
       def initialize(env, capistrano)
         super(env, capistrano)
-        credentials = Rubber::Util.symbolize_keys(env.credentials)
-        @compute_provider = ::Fog::Compute.new(credentials)
-        @storage_provider = ::Fog::Storage.new(credentials)
+
+        compute_credentials = Rubber::Util.symbolize_keys(env.compute_credentials)
+        storage_credentials = Rubber::Util.symbolize_keys(env.storage_credentials) if env.storage_credentials
+
+        @compute_provider = ::Fog::Compute.new(compute_credentials)
+        @storage_provider = storage_credentials ? ::Fog::Storage.new(storage_credentials) : nil
       end
       
       def storage(bucket)
@@ -23,71 +26,16 @@ module Rubber
         raise NotImplementedError, "No table store available for generic fog adapter"
       end
 
-      def create_instance(ami, ami_type, security_groups, availability_zone)
+      def create_instance(instance_alias, ami, ami_type, security_groups, availability_zone, region)
         response = @compute_provider.servers.create(:image_id => ami,
                                                     :flavor_id => ami_type,
                                                     :groups => security_groups,
                                                     :availability_zone => availability_zone,
                                                     :key_name => env.key_name)
-        instance_id = response.id
-        return instance_id
-      end
-
-      def create_spot_instance_request(spot_price, ami, ami_type, security_groups, availability_zone)
-        response = @compute_provider.spot_requests.create(:price => spot_price,
-                                                          :image_id => ami,
-                                                          :flavor_id => ami_type,
-                                                          :groups => security_groups,
-                                                          :availability_zone => availability_zone,
-                                                          :key_name => env.key_name)
-        request_id = response.id
-        return request_id
-      end
-
-      def describe_instances(instance_id=nil)
-        instances = []
-        opts = {}
-        opts["instance-id"] = instance_id if instance_id
-
-        response = @compute_provider.servers.all(opts)
-        response.each do |item|
-          instance = {}
-          instance[:id] = item.id
-          instance[:type] = item.flavor_id
-          instance[:external_host] = item.dns_name
-          instance[:external_ip] = item.public_ip_address
-          instance[:internal_host] = item.private_dns_name
-          instance[:internal_ip] = item.private_ip_address
-          instance[:state] = item.state
-          instance[:zone] = item.availability_zone
-          instance[:platform] = item.platform || 'linux'
-          instance[:root_device_type] = item.root_device_type
-          instances << instance
-        end
-
-        return instances
-      end
 
-      def describe_spot_instance_requests(request_id=nil)
-        requests = []
-        opts = {}
-        opts["spot-instance-request-id"] = request_id if request_id
-        response = @compute_provider.spot_requests.all(opts)
-        response.each do |item|
-          request = {}
-          request[:id] = item.id
-          request[:spot_price] = item.price
-          request[:state] = item.state
-          request[:created_at] = item.created_at
-          request[:type] = item.flavor_id
-          request[:image_id] = item.image_id
-          request[:instance_id] = item.instance_id
-          requests << request
-        end
-        return requests
+        response.id
       end
 
-
       def destroy_instance(instance_id)
         response = @compute_provider.servers.get(instance_id).destroy()
       end
@@ -109,96 +57,6 @@ module Rubber
         response = @compute_provider.servers.get(instance_id).start()
       end
 
-      def describe_availability_zones
-        zones = []
-        response = @compute_provider.describe_availability_zones()
-        items = response.body["availabilityZoneInfo"] 
-        items.each do |item|
-          zone = {}
-          zone[:name] = item["zoneName"]
-          zone[:state] =item["zoneState"]
-          zones << zone
-        end
-        return zones
-      end
-
-      def create_security_group(group_name, group_description)
-        @compute_provider.security_groups.create(:name => group_name, :description => group_description)
-      end
-
-      def describe_security_groups(group_name=nil)
-        groups = []
-
-        opts = {}
-        opts["group-name"] = group_name if group_name
-        response = @compute_provider.security_groups.all(opts)
-
-        response.each do |item|
-          group = {}
-          group[:name] = item.name
-          group[:description] = item.description
-
-          item.ip_permissions.each do |ip_item|
-            group[:permissions] ||= []
-            rule = {}
-
-            rule[:protocol] = ip_item["ipProtocol"]
-            rule[:from_port] = ip_item["fromPort"]
-            rule[:to_port] = ip_item["toPort"]
-
-            ip_item["groups"].each do |rule_group|
-              rule[:source_groups] ||= []
-              source_group = {}
-              source_group[:account] = rule_group["userId"]
-              source_group[:name] = rule_group["groupName"]
-              rule[:source_groups] << source_group
-            end if ip_item["groups"]
-
-            ip_item["ipRanges"].each do |ip_range|
-              rule[:source_ips] ||= []
-              rule[:source_ips] << ip_range["cidrIp"]
-            end if ip_item["ipRanges"]
-
-            group[:permissions] << rule
-          end
-
-          groups << group
-          
-        end
-
-        return groups
-      end
-
-      def add_security_group_rule(group_name, protocol, from_port, to_port, source)
-        group = @compute_provider.security_groups.get(group_name)
-        opts = {:ip_protocol => protocol || 'tcp'}
-        
-        if source.instance_of? Hash
-          opts[:group] = {source[:account] => source[:name]}
-        else
-          opts[:cidr_ip] = source
-        end
-        
-        group.authorize_port_range(from_port.to_i..to_port.to_i, opts)
-      end
-
-      def remove_security_group_rule(group_name, protocol, from_port, to_port, source)
-        group = @compute_provider.security_groups.get(group_name)
-        opts = {:ip_protocol => protocol || 'tcp'}
-        
-        if source.instance_of? Hash
-          opts[:group] = {source[:account] => source[:name]}
-        else
-          opts[:cidr_ip] = source
-        end
-        
-        group.revoke_port_range(from_port.to_i..to_port.to_i, opts)
-      end
-
-      def destroy_security_group(group_name)
-        @compute_provider.security_groups.get(group_name).destroy
-      end
-
       def create_static_ip
         address = @compute_provider.addresses.create()
         return address.public_ip
@@ -236,45 +94,6 @@ module Rubber
         return address.destroy
       end
 
-      def create_volume(size, zone)
-        volume = @compute_provider.volumes.create(:size => size.to_s, :availability_zone => zone)
-        return volume.id
-      end
-
-      def attach_volume(volume_id, instance_id, device)
-        volume = @compute_provider.volumes.get(volume_id)
-        server = @compute_provider.servers.get(instance_id)
-        volume.device = device
-        volume.server = server
-      end
-
-      def detach_volume(volume_id, force=true)
-        volume = @compute_provider.volumes.get(volume_id)
-        force ? volume.force_detach : (volume.server = nil)
-      end
-
-      def describe_volumes(volume_id=nil)
-        volumes = []
-        opts = {}
-        opts[:'volume-id'] = volume_id if volume_id
-        response = @compute_provider.volumes.all(opts)
-        response.each do |item|
-          volume = {}
-          volume[:id] = item.id
-          volume[:status] = item.state
-          if item.server_id
-            volume[:attachment_instance_id] = item.server_id
-            volume[:attachment_status] = item.attached_at ? "attached" : "waiting"
-          end
-          volumes << volume
-        end
-        return volumes
-      end
-
-      def destroy_volume(volume_id)
-        @compute_provider.volumes.get(volume_id).destroy
-      end
-
       def create_image(image_name)
         raise NotImplementedError, "create_image not implemented in generic fog adapter"
       end
@@ -301,17 +120,6 @@ module Rubber
       def describe_load_balancers(name=nil)
         raise NotImplementedError, "describe_load_balancers not implemented in generic fog adapter"
       end
-
-      # resource_id is any Amazon resource ID (e.g., instance ID or volume ID)
-      # tags is a hash of tag_name => tag_value pairs
-      def create_tags(resource_id, tags)
-        # Tags need to be created individually in fog
-        tags.each do |k, v|
-          @compute_provider.tags.create(:resource_id => resource_id,
-                                        :key => k.to_s, :value => v.to_s)
-        end
-      end
-      
     end
 
   end

data/lib/rubber/cloud/generic.rb

@@ -0,0 +1,68 @@
+require 'fog'
+
+module Rubber
+  module Cloud
+    class Generic < Base
+      MUTEX = Mutex.new
+
+      attr_reader :storage_provider
+
+      def initialize(env, capistrano)
+        # TODO (nirvdrum 05/23/13): This is here until the storage provider stuff is cleaned up.  That's why this class inherits from Base rather than Fog.
+        if env.cloud_providers && env.cloud_providers.aws
+          storage_credentials = {
+            :provider => 'AWS',
+            :aws_access_key_id => env.cloud_providers.aws.access_key,
+            :aws_secret_access_key => env.cloud_providers.aws.secret_access_key
+          }
+
+          env['storage_credentials'] = storage_credentials
+          @storage_provider = ::Fog::Storage.new(Rubber::Util.symbolize_keys(env.storage_credentials))
+        end
+
+        super(env, capistrano)
+      end
+
+      def active_state
+        'active'
+      end
+
+      def create_instance(instance_alias, image_name, image_type, security_groups, availability_zone, region)
+        instance = {}
+        instance[:id] = instance_alias
+        instance[:state] = active_state
+        instance[:external_ip] = capistrano.rubber.get_env('EXTERNAL_IP', "External IP address for host '#{instance_alias}'", true)
+        instance[:internal_ip] = capistrano.rubber.get_env('INTERNAL_IP', "Internal IP address for host '#{instance_alias}'", true, instance[:external_ip])
+        instance[:provider] = 'generic'
+        instance[:platform] = 'linux'
+
+        Generic.add_instance(instance)
+
+        instance_alias
+      end
+
+      def describe_instances(instance_id=nil)
+        # Since there's no API to query for instance details, the best we can do is use what we have in memory from
+        # the :create_instance operation or ask the user for the details again.
+        unless Generic.instances
+          create_instance(instance_id, nil, nil, nil, nil)
+        end
+
+        Generic.instances
+      end
+
+      def self.add_instance(instance)
+        MUTEX.synchronize do
+          @instances ||= []
+          @instances << instance
+        end
+      end
+
+      def self.instances
+        MUTEX.synchronize do
+          @instances
+        end
+      end
+    end
+  end
+end

data/lib/rubber/instance.rb

@@ -201,7 +201,7 @@ module Rubber
       attr_accessor :internal_host, :internal_ip
       attr_accessor :static_ip, :volumes, :partitions, :root_device_type
       attr_accessor :spot_instance_request_id
-      attr_accessor :platform
+      attr_accessor :provider, :platform
 
       def initialize(name, domain, roles, instance_id, image_type, image_id, security_group_list=[])
         @name = name
@@ -246,6 +246,11 @@ module Rubber
         roles.collect {|r| r.name}
       end
 
+      def provider
+        # Deal with old instance configurations that don't have a provider value persisted.
+        @provider || 'aws'
+      end
+
       def platform
         # Deal with old instance configurations that don't have a platform value persisted.
         @platform || 'linux'

data/lib/rubber/recipes/rubber/deploy.rb

@@ -24,28 +24,30 @@ namespace :rubber do
   task :post_stop do
   end
 
-  # Don't want to do rubber:config for update_code as that tree isn't official
-  # until it is 'committed' by the symlink task (and doing so causes it to run
-  # for bootstrap_db which should only config the db config file).  However,
-  # deploy:migrations doesn't call update, so we need an additional trigger for
-  # it
-  after "deploy:update", "rubber:config"
+  after "deploy:update_code", "rubber:config"
   after "deploy:rollback_code", "rubber:config"
-  before "deploy:migrate", "rubber:config"
 
   desc <<-DESC
     Configures the deployed rails application by running the rubber configuration process
   DESC
   task :config do
-    opts = {}
-    opts[:no_post] = true if ENV['NO_POST']
-    opts[:force] = true if ENV['FORCE']
-    opts[:file] = ENV['FILE'] if ENV['FILE']
+    # Don't want to do rubber:config during bootstrap_db where it's triggered by
+    # deploy:update_code, because the user could be requiring the rails env inside
+    # some of their config templates (which fails because rails can't connect to
+    # the db)
+    if fetch(:rubber_updating_code_for_bootstrap_db, false)
+      logger.info "Updating code for bootstrap, skipping rubber:config"
+    else
+      opts = {}
+      opts[:no_post] = true if ENV['NO_POST']
+      opts[:force] = true if ENV['FORCE']
+      opts[:file] = ENV['FILE'] if ENV['FILE']
 
-    # when running deploy:migrations, we need to run config against release_path
-    opts[:deploy_path] = current_release if fetch(:migrate_target, :current).to_sym == :latest
+      # when running deploy:migrations, we need to run config against release_path
+      opts[:deploy_path] = current_release if fetch(:migrate_target, :current).to_sym == :latest
 
-    run_config(opts)
+      run_config(opts)
+    end
   end
 
   # because we start server as appserver user, but migrate as root, server needs to be able to write logs, etc.