fog 1.22.1 → 1.23.0

data/Rakefile

@@ -51,11 +51,11 @@ task :default => :test
 task :travis  => ['test', 'test:travis']
 
 Rake::TestTask.new do |t|
-  t.pattern = File.join("**", "spec", "**", "*_spec.rb")
+  t.pattern = File.join("spec", "**", "*_spec.rb")
 end
 
 namespace :test do
-  mock = 'true' || ENV['FOG_MOCK']
+  mock = ENV['FOG_MOCK'] || 'true'
   task :travis do
       sh("export FOG_MOCK=#{mock} && bundle exec shindont")
   end

data/fog.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'fog'
-  s.version           = '1.22.1'
-  s.date              = '2014-05-29'
+  s.version           = '1.23.0'
+  s.date              = '2014-07-17'
   s.rubyforge_project = 'fog'
 
   ## Make sure your summary is short. The description may be as long
@@ -41,7 +41,7 @@ Gem::Specification.new do |s|
 
   ## List your runtime dependencies here. Runtime dependencies are those
   ## that are needed for an end user to actually USE your code.
-  s.add_dependency("fog-core", "~> 1.22")
+  s.add_dependency("fog-core", "~> 1.23")
   s.add_dependency("fog-json")
 
   s.add_dependency('nokogiri', '~> 1.5', '>= 1.5.11')
@@ -49,6 +49,7 @@ Gem::Specification.new do |s|
 
   # Modular providers
   s.add_dependency("fog-brightbox")
+  s.add_dependency("fog-softlayer")
 
   ## List your development dependencies here. Development dependencies are
   ## those that are only needed during development
@@ -61,6 +62,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('shindo', '~> 0.3.4')
   s.add_development_dependency('fission')
   s.add_development_dependency('pry')
+  s.add_development_dependency('opennebula', '>=4.4.0')
   s.add_development_dependency('google-api-client', '~> 0.6', '>= 0.6.2')
   s.add_development_dependency('rubocop') if RUBY_VERSION > "1.9"
 
@@ -68,6 +70,6 @@ Gem::Specification.new do |s|
     s.add_development_dependency('ruby-libvirt','~> 0.5.0')
   end
 
-  s.files = `git ls-files`.split("\n") - `git ls-files -- providers/`.split("\n")
+  s.files = `git ls-files`.split("\n")
   s.test_files = `git ls-files -- {spec,tests}/*`.split("\n")
 end

data/gemfiles/Gemfile-edge

@@ -1,8 +1,5 @@
 source "https://rubygems.org"
 
-# Embedded provider gems
-gem "fog-brightbox", :path => "../providers/brightbox"
-
 # Shared components
 gem "fog-core", :github => "fog/fog-core"
 gem "fog-json", :github => "fog/fog-json"

data/gemfiles/Gemfile-ruby-1.8.7

@@ -2,6 +2,7 @@ source "https://rubygems.org"
 
 gem 'nokogiri', '~>1.5.11'
 gem 'mime-types', '~>1.16'
+gem 'rest-client', '~> 1.6.7'
 
 group :development, :test do
   # This is here because gemspec doesn't support require: false

data/lib/fog.rb

@@ -50,6 +50,7 @@ require 'fog/openstack'
 require 'fog/ovirt'
 require 'fog/sakuracloud'
 require 'fog/serverlove'
+require 'fog/softlayer'
 require 'fog/storm_on_demand'
 require 'fog/terremark'
 require 'fog/vcloud'
@@ -61,3 +62,4 @@ require 'fog/xenserver'
 require 'fog/zerigo'
 require 'fog/cloudsigma'
 require 'fog/openvz'
+require 'fog/opennebula'

data/lib/fog/aws/beanstalk.rb

@@ -124,7 +124,6 @@ module Fog
                 :expects    => 200,
                 :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
                 :idempotent => idempotent,
-                :host       => @host,
                 :method     => 'POST',
                 :parser     => parser
             })

data/lib/fog/aws/compute.rb

@@ -133,6 +133,7 @@ module Fog
       request :modify_instance_attribute
       request :modify_network_interface_attribute
       request :modify_snapshot_attribute
+      request :modify_subnet_attribute
       request :modify_volume_attribute
       request :modify_vpc_attribute
       request :purchase_reserved_instances_offering
@@ -166,6 +167,16 @@ module Fog
       end
 
       class Mock
+        MOCKED_TAG_TYPES = {
+          'ami' => 'image',
+          'i' => 'instance',
+          'snap' => 'snapshot',
+          'vol' => 'volume',
+          'igw' => 'internet_gateway',
+          'acl' => 'network_acl',
+          'vpc' => 'vpc'
+        }
+
         include Fog::AWS::CredentialFetcher::ConnectionMethods
         include Fog::AWS::RegionMethods
 
@@ -330,6 +341,39 @@ module Fog
           self.data[:account_attributes].find { |h| h["attributeName"] == "supported-platforms" }["values"] = values
         end
 
+        def tagged_resources(resources)
+          Array(resources).map do |resource_id|
+            if match = resource_id.match(/^(\w+)-[a-z0-9]{8}/i)
+              id = match.captures.first
+            else
+              raise(Fog::Service::NotFound.new("Unknown resource id #{resource_id}"))
+            end
+
+            if MOCKED_TAG_TYPES.has_key? id
+              type = MOCKED_TAG_TYPES[id]
+            else
+              raise(Fog::Service::NotFound.new("Mocking tags of resource #{resource_id} has not been implemented"))
+            end
+
+            case type
+              when 'image'
+                unless visible_images.has_key? resource_id
+                 raise(Fog::Service::NotFound.new("Cannot tag #{resource_id}, the image does not exist"))
+                end
+              when 'vpc'
+                if self.data[:vpcs].select {|v| v['vpcId'] == resource_id }.empty?
+                  raise(Fog::Service::NotFound.new("Cannot tag #{resource_id}, the vpc does not exist"))
+                end
+              else
+                unless self.data[:"#{type}s"][resource_id]
+                 raise(Fog::Service::NotFound.new("Cannot tag #{resource_id}, the #{type} does not exist"))
+                end
+            end
+            { 'resourceId' => resource_id, 'resourceType' => type }
+          end
+        end
+
+
         def apply_tag_filters(resources, filters, resource_id_key)
           tag_set_fetcher = lambda {|resource| self.data[:tag_sets][resource[resource_id_key]] }
 
@@ -351,7 +395,7 @@ module Fog
             tag_filters[key.gsub('tag:', '')] = filters.delete(key) if /^tag:/ =~ key
           end
           for tag_key, tag_value in tag_filters
-            resources = resources.select{|r| tag_value.include?(tag_set_fetcher[r][tag_key])}
+            resources = resources.select{|r| tag_value == tag_set_fetcher[r][tag_key]}
           end
 
           resources
@@ -397,7 +441,7 @@ module Fog
           @region                 = options[:region] ||= 'us-east-1'
           @instrumentor           = options[:instrumentor]
           @instrumentor_name      = options[:instrumentor_name] || 'fog.aws.compute'
-          @version                = options[:version]     ||  '2014-05-01'
+          @version                = options[:version]     ||  '2014-06-15'
 
           validate_aws_region @region
 

data/lib/fog/aws/dns.rb

@@ -96,7 +96,7 @@ module Fog
           @persistent = options.fetch(:persistent, true)
           @port       = options[:port]        || 443
           @scheme     = options[:scheme]      || 'https'
-          @version    = options[:version]     || '2012-02-29'
+          @version    = options[:version]     || '2013-04-01'
 
           @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
         end

data/lib/fog/aws/elb.rb

@@ -91,7 +91,8 @@ module Fog
         end
 
         def setup_credentials(options)
-          @aws_access_key_id = options[:aws_access_key_id]
+          @aws_access_key_id     = options[:aws_access_key_id]
+          @aws_secret_access_key = options[:aws_secret_access_key]
         end
 
         def data

data/lib/fog/aws/models/compute/flavors.rb

@@ -15,6 +15,36 @@ module Fog
           :ebs_optimized_available => false,
           :instance_store_volumes  => 0
         },
+        {
+          :id                      => 't2.micro',
+          :name                    => 'Micro Instance',
+          :bits                    => 64,
+          :cores                   => 1,
+          :disk                    => 0,
+          :ram                     => 1024,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 0
+        },
+        {
+          :id                      => 't2.small',
+          :name                    => 'Micro Instance',
+          :bits                    => 64,
+          :cores                   => 1,
+          :disk                    => 0,
+          :ram                     => 2048,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 0
+        },
+        {
+          :id                      => 't2.medium',
+          :name                    => 'Micro Instance',
+          :bits                    => 64,
+          :cores                   => 2,
+          :disk                    => 0,
+          :ram                     => 4096,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 0
+        },
         {
           :id                      => 'm1.small',
           :name                    => 'Small Instance',
@@ -304,6 +334,56 @@ module Fog
           :ram                     => 249856,
           :ebs_optimized_available => false,
           :instance_store_volumes  => 8
+        },
+        {
+          :id                      => "r3.large",
+          :name                    => "R3 Large",
+          :bits                    => 64,
+          :cores                   => 2,
+          :ram                     => 15360,
+          :disk                    => 32,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 1
+        },
+        {
+          :id                      => "r3.xlarge",
+          :name                    => "R3 Extra Large",
+          :bits                    => 64,
+          :cores                   => 4,
+          :ram                     => 31232,
+          :disk                    => 80,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 1
+        },
+        {
+          :id                      => "r3.2xlarge",
+          :name                    => "R3 Double Extra Large",
+          :bits                    => 64,
+          :cores                   => 8,
+          :ram                     => 62464,
+          :disk                    => 160,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 1
+        },
+        {
+          :id                      => "r3.4xlarge",
+          :name                    => "R3 Quadruple Extra Large",
+          :bits                    => 64,
+          :cores                   => 16,
+          :ram                     => 124928,
+          :disk                    => 320,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 1
+        },
+        {
+          :id                      => "r3.8xlarge",
+          :name                    => "R3 Eight Extra Large",
+          :bits                    => 64,
+          :cores                   => 32,
+          :ram                     => 249856,
+          :disk                    => 640,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
         }
       ]
 

data/lib/fog/aws/models/compute/image.rb

@@ -23,6 +23,7 @@ module Fog
         attribute :root_device_name,      :aliases => 'rootDeviceName'
         attribute :tags,                  :aliases => 'tagSet'
         attribute :name
+        attribute :virtualization_type,   :aliases => 'virtualizationType'
 
         def deregister(delete_snapshot = false)
           service.deregister_image(id)

data/lib/fog/aws/models/compute/network_acl.rb

@@ -160,7 +160,18 @@ module Fog
         def save
           requires :vpc_id
           data = service.create_network_acl(vpc_id).body['networkAcl']
-          merge_attributes(data)
+          new_attributes = data.reject { |key,value| key == 'tagSet' }
+          merge_attributes(new_attributes)
+
+          if tags = self.tags
+            # expect eventual consistency
+            Fog.wait_for { self.reload rescue nil }
+            service.create_tags(
+              self.identity,
+              tags
+            )
+          end
+
           true
         end
       end

data/lib/fog/aws/models/compute/network_interface.rb

@@ -18,6 +18,7 @@ module Fog
         attribute :status,                      :aliases => 'status'
         attribute :mac_address,                 :aliases => 'macAddress'
         attribute :private_ip_address,          :aliases => 'privateIpAddress'
+        attribute :private_ip_addresses,        :aliases => 'privateIpAddresses'
         attribute :private_dns_name,            :aliases => 'privateDnsName'
         attribute :source_dest_check,           :aliases => 'sourceDestCheck'
         attribute :group_set,                   :aliases => 'groupSet'

data/lib/fog/aws/models/compute/server.rb

@@ -139,7 +139,7 @@ module Fog
           true
         end
 
-        def save
+        def run_instance_options
           raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
           requires :image_id
 
@@ -195,19 +195,12 @@ module Fog
           else
             options.delete('SubnetId')
           end
+          options
+        end
 
-          data = service.run_instances(image_id, 1, 1, options)
-          merge_attributes(data.body['instancesSet'].first)
-
-          if tags = self.tags
-            # expect eventual consistency
-            Fog.wait_for { self.reload rescue nil }
-            service.create_tags(
-              self.identity,
-              tags
-            )
-          end
-
+        def save
+          servers = service.servers.save_many(self, 1, 1)
+          merge_attributes(servers.first.attributes)
           true
         end
 

data/lib/fog/aws/models/compute/servers.rb

@@ -70,41 +70,39 @@ module Fog
           )
         end
 
-        def bootstrap(new_attributes = {})
-          server = service.servers.new(new_attributes)
-
-          unless new_attributes[:key_name]
-            # first or create fog_#{credential} keypair
-            name = Fog.respond_to?(:credential) && Fog.credential || :default
-            unless server.key_pair = service.key_pairs.get("fog_#{name}")
-              server.key_pair = service.key_pairs.create(
-                :name => "fog_#{name}",
-                :public_key => server.public_key
-              )
-            end
-          end
+        # Create between m and n servers with the server options specified in
+        # new_attributes.  Equivalent to this loop, but happens in 1 request:
+        #
+        #    1.upto(n).map { create(new_attributes) }
+        #
+        # See the AWS RunInstances API.
+        def create_many(min_servers = 1, max_servers = nil, new_attributes = {})
+          max_servers ||= min_servers
+          template = new(new_attributes)
+          save_many(template, min_servers, max_servers)
+        end
 
-          security_group = service.security_groups.get(server.groups.first)
-          if security_group.nil?
-            raise Fog::Compute::AWS::Error, "The security group" \
-              " #{server.groups.first} doesn't exist."
-          end
+        # Bootstrap between m and n servers with the server options specified in
+        # new_attributes.  Equivalent to this loop, but happens in 1 AWS request
+        # and the machines' spinup will happen in parallel:
+        #
+        #   1.upto(n).map { bootstrap(new_attributes) }
+        #
+        # See the AWS RunInstances API.
+        def bootstrap_many(min_servers = 1, max_servers = nil, new_attributes = {})
+          template = service.servers.new(new_attributes)
+          _setup_bootstrap(template)
 
-          # make sure port 22 is open in the first security group
-          authorized = security_group.ip_permissions.find do |ip_permission|
-            ip_permission['ipRanges'].first && ip_permission['ipRanges'].first['cidrIp'] == '0.0.0.0/0' &&
-            ip_permission['fromPort'] == 22 &&
-            ip_permission['ipProtocol'] == 'tcp' &&
-            ip_permission['toPort'] == 22
-          end
-          unless authorized
-            security_group.authorize_port_range(22..22)
+          servers = save_many(template, min_servers, max_servers)
+          servers.each do |server|
+            server.wait_for { ready? }
+            server.setup(:key_data => [server.private_key])
           end
+          servers
+        end
 
-          server.save
-          server.wait_for { ready? }
-          server.setup(:key_data => [server.private_key])
-          server
+        def bootstrap(new_attributes = {})
+          bootstrap_many(1, 1, new_attributes).first
         end
 
         # Used to retrieve a server
@@ -154,6 +152,59 @@ module Fog
         rescue Fog::Errors::NotFound
           nil
         end
+
+        # From a template, create between m-n servers (see the AWS RunInstances API)
+        def save_many(template, min_servers = 1, max_servers = nil)
+          max_servers ||= min_servers
+          data = service.run_instances(template.image_id, min_servers, max_servers, template.run_instance_options)
+          # For some reason, AWS sometimes returns empty results alongside the real ones.  Thus the select
+          data.body['instancesSet'].select { |instance_set| instance_set['instanceId'] }.map do |instance_set|
+            server = template.dup
+            server.merge_attributes(instance_set)
+            # expect eventual consistency
+            if (tags = server.tags) && tags.size > 0
+              Fog.wait_for { server.reload rescue nil }
+              service.create_tags(
+                server.identity,
+                tags
+              )
+            end
+            server
+          end
+        end
+
+        private
+
+        def _setup_bootstrap(server, new_attributes = {})
+          unless new_attributes[:key_name]
+            # first or create fog_#{credential} keypair
+            name = Fog.respond_to?(:credential) && Fog.credential || :default
+            unless server.key_pair = service.key_pairs.get("fog_#{name}")
+              server.key_pair = service.key_pairs.create(
+                :name => "fog_#{name}",
+                :public_key => server.public_key
+              )
+            end
+          end
+
+          security_group = service.security_groups.get(server.groups.first)
+          if security_group.nil?
+            raise Fog::Compute::AWS::Error, "The security group" \
+              " #{server.groups.first} doesn't exist."
+          end
+
+          # make sure port 22 is open in the first security group
+          authorized = security_group.ip_permissions.find do |ip_permission|
+            ip_permission['ipRanges'].first && ip_permission['ipRanges'].first['cidrIp'] == '0.0.0.0/0' &&
+            ip_permission['fromPort'] == 22 &&
+            ip_permission['ipProtocol'] == 'tcp' &&
+            ip_permission['toPort'] == 22
+          end
+
+          unless authorized
+            security_group.authorize_port_range(22..22)
+          end
+        end
       end
     end
   end