fog 1.0.0 → 1.5.0

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

@@ -0,0 +1,99 @@
+require 'fog/core/collection'
+require 'fog/aws/models/compute/subnet'
+
+module Fog
+  module Compute
+    class AWS
+
+      class Subnets < Fog::Collection
+
+        attribute :filters
+
+        model Fog::Compute::AWS::Subnet
+
+        # Creates a new subnet
+        #
+        # AWS.subnets.new
+        #
+        # ==== Returns
+        #
+        # Returns the details of the new Subnet
+        #
+        #>> AWS.subnets.new
+        # <Fog::AWS::Compute::Subnet
+        # subnet_id=subnet-someId,
+        # state=[pending|available],
+        # vpc_id=vpc-someId
+        # cidr_block=someIpRange
+        # available_ip_address_count=someInt
+        # tagset=nil
+        # >
+        #
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        # Returns an array of all Subnets that have been created
+        #
+        # AWS.subnets.all
+        #
+        # ==== Returns
+        #
+        # Returns an array of all VPCs
+        #
+        #>> AWS.subnets.all
+        # <Fog::AWS::Compute::Subnet
+        # filters={}
+        # [
+        # subnet_id=subnet-someId,
+        # state=[pending|available],
+        # vpc_id=vpc-someId
+        # cidr_block=someIpRange
+        # available_ip_address_count=someInt
+        # tagset=nil
+        # ]
+        # >
+        #
+
+        def all(filters = filters)
+          unless filters.is_a?(Hash)
+            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('subnet-id' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'subnet-id' => [*filters]}
+          end
+          self.filters = filters
+          data = connection.describe_subnets(filters).body
+          load(data['subnetSet'])
+        end
+
+        # Used to retrieve a Subnet
+        # subnet-id is required to get the associated VPC information.
+        #
+        # You can run the following command to get the details:
+        # AWS.subnets.get("subnet-12345678")
+        #
+        # ==== Returns
+        #
+        #>> AWS.subnets.get("subnet-12345678")
+        # <Fog::AWS::Compute::Subnet
+        # subnet_id=subnet-someId,
+        # state=[pending|available],
+        # vpc_id=vpc-someId
+        # cidr_block=someIpRange
+        # available_ip_address_count=someInt
+        # tagset=nil
+        # >
+        #
+
+        def get(subnet_id)
+          if subnet_id
+            self.class.new(:connection => connection).all('subnet-id' => subnet_id).first
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -44,6 +44,19 @@ module Fog
           data = connection.create_volume(availability_zone, size, snapshot_id).body
           new_attributes = data.reject {|key,value| key == 'requestId'}
           merge_attributes(new_attributes)
+
+          if tags = self.tags
+            # expect eventual consistency
+            Fog.wait_for { self.reload rescue nil }
+            for key, value in (self.tags = tags)
+              connection.tags.create(
+                :key          => key,
+                :resource_id  => self.identity,
+                :value        => value
+              )
+            end
+          end
+
           if @server
             self.server = @server
           end

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

@@ -31,7 +31,7 @@ module Fog
         #  tags=nil
         #>
         #
-        # The volume can be retreived by running AWS.volumes.get("vol-1e2028b9").  See get method below.
+        # The volume can be retrieved by running AWS.volumes.get("vol-1e2028b9").  See get method below.
         #
 
         def initialize(attributes)
@@ -59,12 +59,12 @@ module Fog
         #  tags=nil
         #>
         #
-        # The volume can be retreived by running AWS.volumes.get("vol-1e2028b9").  See get method below.
+        # The volume can be retrieved by running AWS.volumes.get("vol-1e2028b9").  See get method below.
         #
 
         def all(filters = filters)
           unless filters.is_a?(Hash)
-            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('volume-id' => []) instead [light_black](#{caller.first})[/]")
+            Fog::Logger.deprecation("all with #{filters.class} param is deprecated, use all('volume-id' => []) instead [light_black](#{caller.first})[/]")
             filters = {'volume-id' => [*filters]}
           end
           self.filters = filters
@@ -76,7 +76,7 @@ module Fog
           self
         end
 
-        # Used to retreive a volume
+        # Used to retrieve a volume
         # volume_id is required to get the associated volume information.
         #
         # You can run the following command to get the details:

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

@@ -0,0 +1,63 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class AWS
+
+      class VPC < Fog::Model
+
+        identity :id,                :aliases => 'vpcId'
+
+        attribute :state
+        attribute :cidr_block,       :aliases => 'cidrBlock'
+        attribute :dhcp_options_id,  :aliases => 'dhcpOptionsId'
+        attribute :tags,             :aliases => 'tagSet'
+        attribute :tenancy,          :aliases => 'instanceTenancy'
+
+        def initialize(attributes={})
+          self.dhcp_options_id ||= "default"
+          self.tenancy ||= "default"
+          super
+        end
+
+        # Removes an existing vpc
+        #
+        # vpc.destroy
+        #
+        # ==== Returns
+        #
+        # True or false depending on the result
+        #
+
+        def destroy
+          requires :id
+
+          connection.delete_vpc(id)
+          true
+        end
+
+        # Create a vpc
+        #
+        # >> g = AWS.vpcs.new(:cidr_block => "10.1.2.0/24")
+        # >> g.save
+        #
+        # == Returns:
+        #
+        # True or an exception depending on the result. Keep in mind that this *creates* a new vpc.
+        # As such, it yields an InvalidGroup.Duplicate exception if you attempt to save an existing vpc.
+        #
+
+        def save
+          requires :cidr_block
+
+          data = connection.create_vpc(cidr_block).body['vpcSet'].first
+          new_attributes = data.reject {|key,value| key == 'requestId'}
+          merge_attributes(new_attributes)
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+require 'fog/core/collection'
+require 'fog/aws/models/compute/vpc'
+
+module Fog
+  module Compute
+    class AWS
+
+      class Vpcs < Fog::Collection
+
+        attribute :filters
+
+        model Fog::Compute::AWS::VPC
+
+        # Creates a new VPC
+        #
+        # AWS.vpcs.new
+        #
+        # ==== Returns
+        #
+        # Returns the details of the new VPC
+        #
+        #>> AWS.vpcs.new
+        # <Fog::AWS::VPC::VPC
+        # id=nil,
+        # state=nil,
+        # cidr_block=nil,
+        # dhcp_options_id=nil
+        # tags=nil
+        # tenancy=nil
+        # >
+        #
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        # Returns an array of all VPCs that have been created
+        #
+        # AWS.vpcs.all
+        #
+        # ==== Returns
+        #
+        # Returns an array of all VPCs
+        #
+        #>> AWS.vpcs.all
+        # <Fog::AWS::VPC::VPCs
+        # filters={}
+        # [
+        # <Fog::AWS::VPC::VPC
+        # id="vpc-12345678",
+        # TODO
+        # >
+        # ]
+        # >
+        #
+
+        def all(filters = filters)
+          unless filters.is_a?(Hash)
+            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('vpc-id' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'vpc-id' => [*filters]}
+          end
+          self.filters = filters
+          data = connection.describe_vpcs(filters).body
+          load(data['vpcSet'])
+        end
+
+        # Used to retrieve a VPC
+        # vpc_id is required to get the associated VPC information.
+        #
+        # You can run the following command to get the details:
+        # AWS.vpcs.get("vpc-12345678")
+        #
+        # ==== Returns
+        #
+        #>> AWS.vpcs.get("vpc-12345678")
+        # <Fog::AWS::Compute::VPC
+        # id="vpc-12345678",
+        # TODO
+        # >
+        #
+
+        def get(vpc_id)
+          if vpc_id
+            self.class.new(:connection => connection).all('vpc-id' => vpc_id).first
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/dns/record.rb

@@ -9,14 +9,18 @@ module Fog
         deprecate :ip, :value
         deprecate :ip=, :value=
 
-        identity :id,           :aliases => ['Id']
+        identity :name,           :aliases => ['Name']
 
-        attribute :value,       :aliases => ['ResourceRecords']
-        attribute :name,        :aliases => ['Name']
-        attribute :ttl,         :aliases => ['TTL']
-        attribute :type,        :aliases => ['Type']
-        attribute :status,      :aliases => ['Status']
-        attribute :created_at,  :aliases => ['SubmittedAt']
+        attribute :value,         :aliases => ['ResourceRecords']
+        attribute :ttl,           :aliases => ['TTL']
+        attribute :type,          :aliases => ['Type']
+        attribute :status,        :aliases => ['Status']
+        attribute :created_at,    :aliases => ['SubmittedAt']
+        attribute :alias_target,  :aliases => ['AliasTarget']
+        attribute :change_id,     :aliases => ['Id']
+        attribute :region,        :aliases => ['Region']
+        attribute :weight,        :aliases => ['Weight']
+        attribute :set_identifier,:aliases => ['SetIdentifier']
 
         def initialize(attributes={})
           self.ttl ||= 3600
@@ -24,14 +28,7 @@ module Fog
         end
 
         def destroy
-          requires :name, :ttl, :type, :value, :zone
-          options = {
-            :action           => 'DELETE',
-            :name             => name,
-            :resource_records => [*value],
-            :ttl              => ttl,
-            :type             => type
-          }
+          options = attributes_to_options('DELETE')
           connection.change_resource_record_sets(zone.id, [options])
           true
         end
@@ -41,25 +38,67 @@ module Fog
         end
 
         def save
-          requires :name, :ttl, :type, :value, :zone
-          options = {
-            :action           => 'CREATE',
-            :name             => name,
-            :resource_records => [*value],
-            :ttl              => ttl,
-            :type             => type
-          }
+          options = attributes_to_options('CREATE')
           data = connection.change_resource_record_sets(zone.id, [options]).body
           merge_attributes(data)
           true
         end
 
+        def modify(new_attributes)
+          options = []
+
+          # Delete the current attributes
+          options << attributes_to_options('DELETE')
+
+          # Create the new attributes
+          merge_attributes(new_attributes)
+          options << attributes_to_options('CREATE')
+
+          data = connection.change_resource_record_sets(zone.id, options).body
+          merge_attributes(data)
+          true
+        end
+
+        # Returns true if record is insync.  May only be called for newly created or modified records that
+        # have a change_id and status set.
+        def ready?
+          requires :change_id, :status
+          status == 'INSYNC'
+        end
+
+        def reload
+          # If we have a change_id (newly created or modified), then reload performs a get_change to update status.
+          if change_id
+            data = connection.get_change(change_id).body
+            merge_attributes(data)
+            self
+          else
+            super
+          end
+        end
+
         private
 
         def zone=(new_zone)
           @zone = new_zone
         end
 
+        def attributes_to_options(action)
+          requires :name, :ttl, :type, :zone
+          requires_one :value, :alias_target
+          {
+              :action           => action,
+              :name             => name,
+              :resource_records => [*value],
+              :alias_target     => symbolize_keys(alias_target),
+              :ttl              => ttl,
+              :type             => type,
+              :weight           => weight,
+              :set_identifier   => set_identifier,
+              :region           => region
+          }
+        end
+
       end
 
     end

data/lib/fog/aws/models/dns/records.rb

@@ -7,12 +7,14 @@ module Fog
 
       class Records < Fog::Collection
 
-        attribute :is_truncated,      :aliases => ['IsTruncated']
-        attribute :max_items,         :aliases => ['MaxItems']
+        attribute :is_truncated,            :aliases => ['IsTruncated']
+        attribute :max_items,               :aliases => ['MaxItems']
         attribute :name
-        attribute :next_record_name,  :aliases => ['NextRecordName']
-        attribute :next_record_type,  :aliases => ['NextRecordType']
+        attribute :next_record_name,        :aliases => ['NextRecordName']
+        attribute :next_record_type,        :aliases => ['NextRecordType']
+        attribute :next_record_identifier,  :aliases => ['NextRecordIdentifier']
         attribute :type
+        attribute :identifier
 
         attribute :zone
 
@@ -20,20 +22,95 @@ module Fog
 
         def all(options = {})
           requires :zone
-          options['MaxItems'] ||= max_items
-          options['Name']     ||= name
-          options['Type']     ||= type
+          options[:max_items]  ||= max_items
+          options[:name]       ||= zone.domain
+          options[:type]       ||= type
+          options[:identifier] ||= identifier
+          options.delete_if {|key, value| value.nil?}
+
           data = connection.list_resource_record_sets(zone.id, options).body
-          merge_attributes(data.reject {|key, value| !['IsTruncated', 'MaxItems', 'NextRecordName', 'NextRecordType'].include?(key)})
+          # NextRecordIdentifier is completely absent instead of nil, so set to nil, or iteration breaks.
+          data['NextRecordIdentifier'] = nil unless data.has_key?('NextRecordIdentifier')
+
+          merge_attributes(data.reject {|key, value| !['IsTruncated', 'MaxItems', 'NextRecordName', 'NextRecordType', 'NextRecordIdentifier'].include?(key)})
           # leave out the default, read only records
           data = data['ResourceRecordSets'].reject {|record| ['NS', 'SOA'].include?(record['Type'])}
           load(data)
         end
 
-        def get(record_id)
-          data = connection.get_change(record_id).body
-          new(data)
-        rescue Excon::Errors::Forbidden
+        #
+        # Load all zone records into the collection.
+        #
+        def all!
+          data = []
+
+          merge_attributes({'NextRecordName' => nil,
+                            'NextRecordType' => nil,
+                            'NextRecordIdentifier' => nil,
+                            'IsTruncated' => nil})
+
+          begin
+            options = {
+                :name => next_record_name,
+                :type => next_record_type,
+                :identifier => next_record_identifier
+            }
+            options.delete_if {|key, value| value.nil?}
+
+            batch = connection.list_resource_record_sets(zone.id, options).body
+            # NextRecordIdentifier is completely absent instead of nil, so set to nil, or iteration breaks.
+            batch['NextRecordIdentifier'] = nil unless batch.has_key?('NextRecordIdentifier')
+
+            merge_attributes(batch.reject {|key, value| !['IsTruncated', 'MaxItems', 'NextRecordName', 'NextRecordType', 'NextRecordIdentifier'].include?(key)})
+
+            data.concat(batch['ResourceRecordSets'])
+          end while is_truncated
+
+          load(data)
+        end
+
+        #
+        # AWS Route 53 records are uniquely identified by a compound key of name, type, and identifier.
+        # #get allows one to retrieve a record using one or more of those key components.
+        #
+        # ==== Parameters
+        # * record_name - The name of the record to retrieve.
+        # * record_type - The type of record to retrieve, if nil, then the first matching record is returned.
+        # * record_identifier - The record set identifier to retrieve, if nil, then the first matching record is returned.
+        #
+        def get(record_name, record_type = nil, record_identifier = nil)
+          requires :zone
+          # Append a trailing period to the record_name if absent.
+          record_name = record_name + "." unless record_name.end_with?(".")
+          record_type = record_type.upcase unless record_type.nil?
+
+          options = {
+              :max_items => 1,
+              :name => record_name,
+              :type => record_type,
+              :identifier => record_identifier
+          }
+          options.delete_if {|key, value| value.nil?}
+
+          data = connection.list_resource_record_sets(zone.id, options).body
+          # Get first record
+          data = data['ResourceRecordSets'].shift
+
+          if data
+            record = new(data)
+            # make sure everything matches
+            if record.name == record_name
+              if (!record_type.nil? && record.type != record_type) ||
+                  (!record_identifier.nil? && record.set_identifier != record_identifier)
+                nil
+              else
+                record
+              end
+            end
+          else
+            nil
+          end
+        rescue Excon::Errors::NotFound
           nil
         end
 

data/lib/fog/aws/models/dns/zones.rb

@@ -22,7 +22,7 @@ module Fog
         def get(zone_id)
           data = connection.get_hosted_zone(zone_id).body
           new(data)
-        rescue Excon::Errors::Forbidden
+        rescue Excon::Errors::NotFound
           nil
         end
 

data/lib/fog/aws/models/elb/listener.rb

@@ -4,20 +4,21 @@ module Fog
     class ELB
       class Listener < Fog::Model
 
-        attribute :policy_names,  :aliases => 'PolicyNames'
-        attribute :instance_port, :aliases => 'InstancePort'
-        attribute :lb_port,       :aliases => 'LoadBalancerPort'
-        attribute :protocol,      :aliases => 'Protocol'
-        attribute :ssl_id,        :aliases => 'SSLCertificateId'
+        attribute :policy_names,      :aliases => 'PolicyNames'
+        attribute :instance_port,     :aliases => 'InstancePort'
+        attribute :instance_protocol, :aliases => 'InstanceProtocol'
+        attribute :lb_port,           :aliases => 'LoadBalancerPort'
+        attribute :protocol,          :aliases => 'Protocol'
+        attribute :ssl_id,            :aliases => 'SSLCertificateId'
 
         def initialize(attributes={})
           # set defaults, which may be overridden in super
-          merge_attributes(:policy_names => [], :instance_port => 80, :lb_port => 80, :protocol => 'HTTP')
+          merge_attributes(:policy_names => [], :instance_port => 80, :instance_protocol => 'HTTP', :lb_port => 80, :protocol => 'HTTP')
           super
         end
 
         def save
-          requires :load_balancer, :instance_port, :lb_port, :protocol
+          requires :load_balancer, :instance_port, :lb_port, :protocol, :instance_protocol
           connection.create_load_balancer_listeners(load_balancer.id, [to_params])
           reload
         end
@@ -44,6 +45,7 @@ module Fog
         def to_params
           {
             'InstancePort'     => instance_port,
+            'InstanceProtocol' => instance_protocol,
             'LoadBalancerPort' => lb_port,
             'Protocol'         => protocol,
             'SSLCertificateId' => ssl_id

data/lib/fog/aws/models/elb/load_balancer.rb

@@ -12,9 +12,19 @@ module Fog
         attribute :health_check,          :aliases => 'HealthCheck'
         attribute :instances,             :aliases => 'Instances'
         attribute :source_group,          :aliases => 'SourceSecurityGroup'
+        attribute :hosted_zone_name,      :aliases => 'CanonicalHostedZoneName'
+        attribute :hosted_zone_name_id,   :aliases => 'CanonicalHostedZoneNameID'
+        attribute :subnet_ids,            :aliases => 'Subnets'
+        attribute :security_groups,       :aliases => 'SecurityGroups'
+        attribute :scheme,                :aliases => 'Scheme'
+        attribute :vpc_id,                :aliases => 'VPCId'
 
         def initialize(attributes={})
-          attributes[:availability_zones] ||= attributes['AvailabilityZones'] || %w(us-east-1a us-east-1b us-east-1c us-east-1d)
+          if attributes[:subnet_ids] ||= attributes['Subnets']
+            attributes[:availability_zones] ||= attributes['AvailabilityZones'] 
+          else
+            attributes[:availability_zones] ||= attributes['AvailabilityZones']  || %w(us-east-1a us-east-1b us-east-1c us-east-1d)
+          end
           unless attributes['ListenerDescriptions']
             new_listener = Fog::AWS::ELB::Listener.new
             attributes['ListenerDescriptions'] = [{
@@ -51,6 +61,24 @@ module Fog
           data = connection.disable_availability_zones_for_load_balancer(zones, id).body['DisableAvailabilityZonesForLoadBalancerResult']
           merge_attributes(data)
         end
+        
+        def attach_subnets(subnet_ids)
+          requires :id
+          data = connection.attach_load_balancer_to_subnets(subnet_ids, id).body['AttachLoadBalancerToSubnetsResult']
+          merge_attributes(data)
+        end
+
+        def detach_subnets(subnet_ids)
+          requires :id
+          data = connection.detach_load_balancer_from_subnets(subnet_ids, id).body['DetachLoadBalancerFromSubnetsResult']
+          merge_attributes(data)
+        end
+        
+        def apply_security_groups(security_groups)
+          requires :id
+          data = connection.apply_security_groups_to_load_balancer(security_groups, id).body['ApplySecurityGroupsToLoadBalancerResult']
+          merge_attributes(data)
+        end
 
         def instance_health
           requires :id
@@ -94,6 +122,12 @@ module Fog
           reload
         end
 
+        def set_listener_ssl_certificate(port, ssl_certificate_id)
+          requires :id
+          connection.set_load_balancer_listener_ssl_certificate(id, port, ssl_certificate_id)
+          reload
+        end
+
         def unset_listener_policy(port)
           set_listener_policy(port, [])
         end
@@ -106,9 +140,15 @@ module Fog
         def save
           requires :id
           requires :listeners
-          requires :availability_zones
-
-          connection.create_load_balancer(availability_zones, id, listeners.map{|l| l.to_params})
+          # with the VPC release, the ELB can have either availability zones or subnets
+          # if both are specified, the availability zones have preference
+          #requires :availability_zones
+          if (availability_zones || subnet_ids)
+            connection.create_load_balancer(availability_zones, id, listeners.map{|l| l.to_params}) if availability_zones
+            connection.create_load_balancer(nil, id, listeners.map{|l| l.to_params}, {:subnet_ids => subnet_ids, :security_groups => security_groups, :scheme => scheme}) if subnet_ids && !availability_zones
+          else
+            throw Fog::Errors::Error.new("No availability zones or subnet ids specified")
+          end
 
           # reload instead of merge attributes b/c some attrs (like HealthCheck)
           # may be set, but only the DNS name is returned in the create_load_balance