fog-aws 0.11.0 → 3.18.0

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Subnet < Fog::Model
         identity  :subnet_id,                   :aliases => 'subnetId'
         attribute :state
@@ -10,12 +10,17 @@ module Fog
         attribute :availability_zone,           :aliases => 'availabilityZone'
         attribute :tag_set,                     :aliases => 'tagSet'
         attribute :map_public_ip_on_launch,     :aliases => 'mapPublicIpOnLaunch'
+        attribute :default_for_az,              :aliases => 'defaultForAz'
 
         def ready?
           requires :state
           state == 'available'
         end
 
+        def network_interfaces
+          service.network_interfaces.all('subnet-id' => [self.identity])
+        end
+
         # Removes an existing subnet
         #
         # subnet.destroy

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

@@ -1,12 +1,12 @@
 require 'fog/aws/models/compute/subnet'
 
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Subnets < Fog::Collection
         attribute :filters
 
-        model Fog::Compute::AWS::Subnet
+        model Fog::AWS::Compute::Subnet
 
         # Creates a new subnet
         #

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Tag < Fog::Model
         identity  :key
 

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

@@ -1,12 +1,12 @@
 require 'fog/aws/models/compute/tag'
 
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Tags < Fog::Collection
         attribute :filters
 
-        model Fog::Compute::AWS::Tag
+        model Fog::AWS::Compute::Tag
 
         def initialize(attributes)
           self.filters ||= {}

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Volume < Fog::Model
         identity  :id,                    :aliases => 'volumeId'
 
@@ -21,7 +21,7 @@ module Fog
 
         def initialize(attributes = {})
           # assign server first to prevent race condition with persisted?
-          self.server = attributes.delete(:server)
+          @server = attributes.delete(:server)
           super
         end
 
@@ -36,30 +36,43 @@ module Fog
           state == 'available'
         end
 
+        def modification_in_progress?
+          modifications.any? { |m| m['modificationState'] != 'completed' }
+        end
+
+        def modifications
+          requires :identity
+          service.describe_volumes_modifications('volume-id' => self.identity).body['volumeModificationSet']
+        end
+
         def save
-          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
-          requires :availability_zone
-          requires_one :size, :snapshot_id
+          if identity
+            update_params = {
+              'Size'       => self.size,
+              'Iops'       => self.iops,
+              'VolumeType' => self.type
+            }
+
+            service.modify_volume(self.identity, update_params)
+            true
+          else
+            requires :availability_zone
+            requires_one :size, :snapshot_id
 
-          if type == 'io1'
-            requires :iops
-          end
+            requires :iops if type == 'io1'
 
-          data = service.create_volume(availability_zone, size, create_params).body
-          merge_attributes(data)
+            data = service.create_volume(availability_zone, size, create_params).body
+            merge_attributes(data)
 
-          if tags = self.tags
-            # expect eventual consistency
-            Fog.wait_for { self.reload rescue nil }
-            service.create_tags(
-              self.identity,
-              tags
-            )
-          end
+            if tags = self.tags
+              # expect eventual consistency
+              Fog.wait_for { service.volumes.get(identity) }
+              service.create_tags(identity, tags)
+            end
 
-          if @server
-            self.server = @server
+            attach(@server, device) if @server && device
           end
+
           true
         end
 
@@ -68,14 +81,6 @@ module Fog
           service.servers.get(server_id)
         end
 
-        def server=(new_server)
-          if new_server
-            attach(new_server)
-          else
-            detach
-          end
-        end
-
         def snapshots
           requires :id
           service.snapshots(:volume => self)
@@ -90,22 +95,15 @@ module Fog
           detach(true)
         end
 
-        private
-
-        def attachmentSet=(new_attachment_set)
-          merge_attributes(new_attachment_set.first || {})
-        end
-
-        def attach(new_server)
+        def attach(new_server, new_device)
           if !persisted?
             @server = new_server
             self.availability_zone = new_server.availability_zone
           elsif new_server
-            requires :device
             wait_for { ready? }
             @server = nil
             self.server_id = new_server.id
-            service.attach_volume(server_id, id, device)
+            service.attach_volume(server_id, id, new_device)
             reload
           end
         end
@@ -119,6 +117,16 @@ module Fog
           end
         end
 
+        def server=(_)
+          raise NoMethodError, 'use Fog::AWS::Compute::Volume#attach(server, device)'
+        end
+
+        private
+
+        def attachmentSet=(new_attachment_set)
+          merge_attributes(new_attachment_set.first || {})
+        end
+
         def create_params
           {
             'Encrypted'  => encrypted,

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

@@ -1,13 +1,13 @@
 require 'fog/aws/models/compute/volume'
 
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Volumes < Fog::Collection
         attribute :filters
         attribute :server
 
-        model Fog::Compute::AWS::Volume
+        model Fog::AWS::Compute::Volume
 
         # Used to create a volume.  There are 3 arguments and availability_zone and size are required.  You can generate a new key_pair as follows:
         # AWS.volumes.create(:availability_zone => 'us-east-1a', :size => 10)

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class VPC < Fog::Model
         identity :id,                :aliases => 'vpcId'
 
@@ -9,10 +9,27 @@ module Fog
         attribute :dhcp_options_id,  :aliases => 'dhcpOptionsId'
         attribute :tags,             :aliases => 'tagSet'
         attribute :tenancy,          :aliases => 'instanceTenancy'
+        attribute :is_default,       :aliases => 'isDefault'
+
+        attribute :cidr_block_association_set, :aliases => 'cidrBlockAssociationSet'
+
+        attribute :ipv6_cidr_block_association_set, :aliases => 'ipv6CidrBlockAssociationSet'
+        attribute :amazon_provided_ipv6_cidr_block, :aliases => 'amazonProvidedIpv6CidrBlock'
+
+        # Backward compatibility. Please use ipv6_cidr_block_association_set
+        alias_method :ipv_6_cidr_block_association_set,  :ipv6_cidr_block_association_set
+        alias_method :ipv_6_cidr_block_association_set=, :ipv6_cidr_block_association_set=
+        alias_method :amazon_provided_ipv_6_cidr_block,  :amazon_provided_ipv6_cidr_block
+        alias_method :amazon_provided_ipv_6_cidr_block=, :amazon_provided_ipv6_cidr_block=
+
+        def subnets
+          service.subnets(:filters => {'vpcId' => self.identity}).all
+        end
 
         def initialize(attributes={})
           self.dhcp_options_id ||= "default"
           self.tenancy ||= "default"
+          self.amazon_provided_ipv_6_cidr_block ||=false
           super
         end
 
@@ -21,6 +38,11 @@ module Fog
           state == 'available'
         end
 
+        def is_default?
+          requires :is_default
+          is_default
+        end
+
         # Removes an existing vpc
         #
         # vpc.destroy
@@ -37,6 +59,40 @@ module Fog
           true
         end
 
+        def classic_link_enabled?
+          requires :identity
+          service.describe_vpc_classic_link(:vpc_ids => [self.identity]).body['vpcSet'].first['classicLinkEnabled']
+        rescue
+          nil
+        end
+
+        def enable_classic_link
+          requires :identity
+          service.enable_vpc_classic_link(self.identity).body['return']
+        end
+
+        def disable_classic_link
+          requires :identity
+          service.disable_vpc_classic_link(self.identity).body['return']
+        end
+
+        def classic_link_dns_enabled?
+          requires :identity
+          service.describe_vpc_classic_link_dns_support(:vpc_ids => [self.identity]).body['vpcs'].first['classicLinkDnsSupported']
+        rescue
+          nil
+        end
+
+        def enable_classic_link_dns
+          requires :identity
+          service.enable_vpc_classic_link_dns_support(self.identity).body['return']
+        end
+
+        def disable_classic_link_dns
+          requires :identity
+          service.disable_vpc_classic_link_dns_support(self.identity).body['return']
+        end
+
         # Create a vpc
         #
         # >> g = AWS.vpcs.new(:cidr_block => "10.1.2.0/24")
@@ -51,7 +107,12 @@ module Fog
         def save
           requires :cidr_block
 
-          data = service.create_vpc(cidr_block).body['vpcSet'].first
+          options = {
+            'AmazonProvidedIpv6CidrBlock' => amazon_provided_ipv_6_cidr_block,
+            'InstanceTenancy' => tenancy
+          }
+
+          data = service.create_vpc(cidr_block, options).body['vpcSet'].first
           new_attributes = data.reject {|key,value| key == 'requestId'}
           new_attributes = data.reject {|key,value| key == 'requestId' || key == 'tagSet' }
           merge_attributes(new_attributes)

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

@@ -1,12 +1,12 @@
 require 'fog/aws/models/compute/vpc'
 
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Vpcs < Fog::Collection
         attribute :filters
 
-        model Fog::Compute::AWS::VPC
+        model Fog::AWS::Compute::VPC
 
         # Creates a new VPC
         #

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

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Record < Fog::Model
         extend Fog::Deprecation
         deprecate :ip, :value

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

@@ -1,8 +1,8 @@
 require 'fog/aws/models/dns/record'
 
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Records < Fog::Collection
         attribute :is_truncated,            :aliases => ['IsTruncated']
         attribute :max_items,               :aliases => ['MaxItems']
@@ -15,7 +15,7 @@ module Fog
 
         attribute :zone
 
-        model Fog::DNS::AWS::Record
+        model Fog::AWS::DNS::Record
 
         def all(options = {})
           requires :zone
@@ -99,7 +99,7 @@ module Fog
               record
             end
           end.compact.first
-        rescue Fog::DNS::AWS::NotFound
+        rescue Fog::AWS::DNS::NotFound
           nil
         end
 

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

@@ -1,8 +1,8 @@
 # require 'fog/aws/models/dns/records'
 
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Zone < Fog::Model
         identity :id,                 :aliases => 'Id'
 
@@ -20,7 +20,7 @@ module Fog
 
         def records
           @records ||= begin
-            Fog::DNS::AWS::Records.new(
+            Fog::AWS::DNS::Records.new(
               :zone       => self,
               :service => service
             )

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

@@ -1,13 +1,13 @@
 require 'fog/aws/models/dns/zone'
 
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Zones < Fog::Collection
         attribute :marker,    :aliases => 'Marker'
         attribute :max_items, :aliases => 'MaxItems'
 
-        model Fog::DNS::AWS::Zone
+        model Fog::AWS::DNS::Zone
 
         def all(options = {})
           options[:marker]   ||= marker unless marker.nil?
@@ -19,7 +19,7 @@ module Fog
         def get(zone_id)
           data = service.get_hosted_zone(zone_id).body
           new(data)
-        rescue Fog::DNS::AWS::NotFound
+        rescue Fog::AWS::DNS::NotFound
           nil
         end
       end

data/lib/fog/aws/models/efs/file_system.rb

@@ -0,0 +1,46 @@
+module Fog
+  module AWS
+    class EFS
+      class FileSystem < Fog::Model
+        identity :id, :aliases => 'FileSystemId'
+
+        attribute :owner_id,                :aliases => 'OwnerId'
+        attribute :creation_token,          :aliases => 'CreationToken'
+        attribute :performance_mode,        :aliases => 'PerformanceMode'
+        attribute :encrypted,               :aliases => 'Encrypted'
+        attribute :kms_key_id,              :aliases => 'KmsKeyId'
+        attribute :creation_time,           :aliases => 'CreationTime'
+        attribute :state,                   :aliases => 'LifeCycleState'
+        attribute :name,                    :aliases => 'Name'
+        attribute :number_of_mount_targets, :aliases => 'NumberOfMountTargets'
+        attribute :size_in_bytes,           :aliases => 'SizeInBytes'
+
+        def ready?
+          state == 'available'
+        end
+
+        def mount_targets
+          requires :identity
+          service.mount_targets(:file_system_id => self.identity).all
+        end
+
+        def destroy
+          requires :identity
+
+          service.delete_file_system(self.identity)
+
+          true
+        end
+
+        def save
+          params = {}
+          params.merge!(:performance_mode => self.performance_mode) if self.performance_mode
+          params.merge!(:encrypted        => self.encrypted)        if self.encrypted
+          params.merge!(:kms_key_id       => self.kms_key_id)       if self.kms_key_id
+
+          merge_attributes(service.create_file_system(self.creation_token || Fog::Mock.random_hex(32), params).body)
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/models/efs/file_systems.rb

@@ -0,0 +1,23 @@
+require 'fog/aws/models/efs/file_system'
+
+module Fog
+  module AWS
+    class EFS
+      class FileSystems < Fog::Collection
+        model Fog::AWS::EFS::FileSystem
+
+        def all
+          data = service.describe_file_systems.body["FileSystems"]
+          load(data)
+        end
+
+        def get(identity)
+          data = service.describe_file_systems(:id => identity).body["FileSystems"].first
+          new(data)
+        rescue Fog::AWS::EFS::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/models/efs/mount_target.rb

@@ -0,0 +1,59 @@
+module Fog
+  module AWS
+    class EFS
+      class MountTarget < Fog::Model
+        identity :id, :aliases => "MountTargetId"
+
+        attribute :file_system_id,       :aliases => "FileSystemId"
+        attribute :ip_address,           :aliases => "IpAddress"
+        attribute :state,                :aliases => "LifeCycleState"
+        attribute :network_interface_id, :aliases => "NetworkInterfaceId"
+        attribute :owner_id,             :aliases => "OwnerId"
+        attribute :subnet_id,            :aliases => "SubnetId"
+
+        def ready?
+          state == 'available'
+        end
+
+        def destroy
+          requires :identity
+          service.delete_mount_target(self.identity)
+          true
+        end
+
+        def file_system
+          requires :file_system_id
+          service.file_systems.get(self.file_system_id)
+        end
+
+        def security_groups
+          if persisted?
+            requires :identity
+            service.describe_mount_target_security_groups(self.identity).body["SecurityGroups"]
+          else
+            @security_groups || []
+          end
+        end
+
+        def security_groups=(security_groups)
+          if persisted?
+            requires :identity
+            service.modify_mount_target_security_groups(self.identity, security_groups)
+          else
+            @security_groups = security_groups
+          end
+          security_groups
+        end
+
+        def save
+          requires :file_system_id, :subnet_id
+          params = {}
+          params.merge!('IpAddress' => self.ip_address) if self.ip_address
+          params.merge!('SecurityGroups' => @security_groups) if @security_groups
+
+          merge_attributes(service.create_mount_target(self.file_system_id, self.subnet_id, params).body)
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/models/efs/mount_targets.rb

@@ -0,0 +1,25 @@
+require 'fog/aws/models/efs/mount_target'
+
+module Fog
+  module AWS
+    class EFS
+      class MountTargets < Fog::Collection
+        attribute :file_system_id
+
+        model Fog::AWS::EFS::MountTarget
+
+        def all
+          data = service.describe_mount_targets(:file_system_id => self.file_system_id).body["MountTargets"]
+          load(data)
+        end
+
+        def get(identity)
+          data = service.describe_mount_targets(:id => identity).body["MountTargets"].first
+          new(data)
+        rescue Fog::AWS::EFS::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -12,7 +12,7 @@ module Fog
         end
 
         def get(instance_port)
-          all.find{|e| e.instance_port == instance_port}
+          all.find { |e| e.instance_port == instance_port }
         end
       end
     end

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

@@ -12,17 +12,16 @@ module Fog
         end
 
         def get(lb_port)
-          all.find{|listener| listener.lb_port == lb_port}
+          all.find { |listener| listener.lb_port == lb_port }
         end
 
         private
+
         # Munge an array of ListenerDescription hashes like:
         # {'Listener' => listener, 'PolicyNames' => []}
         # to an array of listeners with a PolicyNames key
         def munged_data
-          data.map {|description|
-            description['Listener'].merge('PolicyNames' => description['PolicyNames'])
-          }
+          data.map { |description| description['Listener'].merge('PolicyNames' => description['PolicyNames']) }
         end
       end
     end

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

@@ -223,16 +223,24 @@ module Fog
         end
 
         def reload
-          super
           @instance_health = nil
           @policy_descriptions = nil
-          self
+          super
         end
 
         def destroy
           requires :id
           service.delete_load_balancer(id)
         end
+
+        protected
+
+        def all_associations_and_attributes
+          super.merge(
+            'ListenerDescriptions' => attributes['ListenerDescriptions'],
+            'BackendServerDescriptions' => attributes['BackendServerDescriptions'],
+          )
+        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module Fog
         model Fog::AWS::ELB::LoadBalancer
 
         # Creates a new load balancer
-        def initialize(attributes={})
+        def initialize(attributes = {})
           super
         end
 
@@ -14,7 +14,7 @@ module Fog
           result = []
           marker = nil
           finished = false
-          while !finished
+          until finished
             data = service.describe_load_balancers('Marker' => marker).body
             result.concat(data['DescribeLoadBalancersResult']['LoadBalancerDescriptions'])
             marker = data['DescribeLoadBalancersResult']['NextMarker']
@@ -24,10 +24,9 @@ module Fog
         end
 
         def get(identity)
-          if identity
-            data = service.describe_load_balancers('LoadBalancerNames' => identity).body['DescribeLoadBalancersResult']['LoadBalancerDescriptions'].first
-            new(data)
-          end
+          return unless identity
+          data = service.describe_load_balancers('LoadBalancerNames' => identity).body['DescribeLoadBalancersResult']['LoadBalancerDescriptions'].first
+          new(data)
         rescue Fog::AWS::ELB::NotFound
           nil
         end