fog-aws 0.0.5

data/lib/fog/aws/models/cloud_watch/metric_statistics.rb

@@ -0,0 +1,22 @@
+require 'fog/core/collection'
+require 'fog/aws/models/cloud_watch/metric_statistic'
+
+module Fog
+  module AWS
+    class CloudWatch
+      class MetricStatistics < Fog::Collection
+        model Fog::AWS::CloudWatch::MetricStatistic
+
+        def all(conditions)
+          metricName = conditions['MetricName']
+          namespace = conditions['Namespace']
+          dimensions = conditions['Dimensions']
+          get_metric_opts = {"StartTime" => (Time.now-3600).iso8601, "EndTime" => Time.now.iso8601, "Period" => 300}.merge(conditions)
+          data = service.get_metric_statistics(get_metric_opts).body['GetMetricStatisticsResult']['Datapoints']
+          data.map! { |datum| datum.merge('MetricName' => metricName, 'Namespace' => namespace, 'Dimensions' => dimensions) }
+          load(data) # data is an array of attribute hashes
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/models/cloud_watch/metrics.rb

@@ -0,0 +1,50 @@
+require 'fog/core/collection'
+require 'fog/aws/models/cloud_watch/metric'
+
+module Fog
+  module AWS
+    class CloudWatch
+      class Metrics < Fog::Collection
+        attribute :next_token, :aliases => 'NextToken'
+
+        model Fog::AWS::CloudWatch::Metric
+
+        def all(conditions={})
+          result = service.list_metrics(conditions).body['ListMetricsResult']
+          merge_attributes("NextToken" => result["NextToken"])
+          load(result['Metrics']) # an array of attribute hashes
+        end
+
+        alias_method :each_metric_this_page, :each
+        def each
+          if !block_given?
+            self
+          else
+            subset = dup.all
+            subset.each_metric_this_page {|m| yield m }
+
+            while next_token = subset.next_token
+              subset = subset.all("NextToken" => next_token)
+              subset.each_metric_this_page {|m| yield m }
+            end
+
+            self
+          end
+        end
+
+        def get(namespace, metric_name, dimensions=nil)
+          list_opts = {'Namespace' => namespace, 'MetricName' => metric_name}
+          if dimensions
+            dimensions_array = dimensions.map do |name, value|
+              {'Name' => name, 'Value' => value}
+            end
+            # list_opts.merge!('Dimensions' => dimensions_array)
+          end
+          if data = service.list_metrics(list_opts).body['ListMetricsResult']['Metrics'].first
+            new(data)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class AWS
+      class Address < Fog::Model
+        identity  :public_ip,                  :aliases => 'publicIp'
+
+        attribute :allocation_id,              :aliases => 'allocationId'
+        attribute :association_id,             :aliases => 'associationId'
+        attribute :server_id,                  :aliases => 'instanceId'
+        attribute :network_interface_id,       :aliases => 'networkInterfaceId'
+        attribute :network_interface_owner_id, :aliases => 'networkInterfaceOwnerId'
+        attribute :domain
+
+        def initialize(attributes = {})
+          # assign server first to prevent race condition with persisted?
+          self.server = attributes.delete(:server)
+          super
+        end
+
+        def destroy
+          requires :public_ip
+
+          service.release_address(allocation_id || public_ip)
+          true
+        end
+
+        def server=(new_server)
+          if new_server
+            associate(new_server)
+          else
+            disassociate
+          end
+        end
+
+        def server
+          service.servers.get(server_id)
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          data = service.allocate_address(domain).body
+          new_attributes = data.reject {|key,value| key == 'requestId'}
+          merge_attributes(new_attributes)
+          if @server
+            self.server = @server
+          end
+          true
+        end
+
+        private
+
+        def associate(new_server)
+          unless persisted?
+            @server = new_server
+          else
+            @server = nil
+            self.server_id = new_server.id
+            service.associate_address(server_id, public_ip, network_interface_id, allocation_id)
+          end
+        end
+
+        def disassociate
+          @server = nil
+          self.server_id = nil
+          if persisted?
+            service.disassociate_address(public_ip)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+require 'fog/core/collection'
+require 'fog/aws/models/compute/address'
+
+module Fog
+  module Compute
+    class AWS
+      class Addresses < Fog::Collection
+        attribute :filters
+        attribute :server
+
+        model Fog::Compute::AWS::Address
+
+        # Used to create an IP address
+        #
+        # ==== Returns
+        #
+        #>> AWS.addresses.create
+        #  <Fog::AWS::Compute::Address
+        #    public_ip="4.88.524.95",
+        #    server_id=nil
+        #  >
+        #
+        # The IP address can be retrieved by running AWS.addresses.get("test").  See get method below.
+        #
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        # AWS.addresses.all
+        #
+        # ==== Returns
+        #
+        # Returns an array of all IP addresses
+        #
+        #>> AWS.addresses.all
+        #  <Fog::AWS::Compute::Addresses
+        #    filters={},
+        #    server=nil
+        #    [
+        #      <Fog::AWS::Compute::Address
+        #        public_ip="76.7.46.54",
+        #        server_id=nil
+        #      >,
+        #      .......
+        #      <Fog::AWS::Compute::Address
+        #        public_ip="4.88.524.95",
+        #        server_id=nil
+        #      >
+        #    ]
+        #  >
+        #>>
+
+        def all(filters_arg = filters)
+          unless filters_arg.is_a?(Hash)
+            Fog::Logger.deprecation("all with #{filters_arg.class} param is deprecated, use all('public-ip' => []) instead [light_black](#{caller.first})[/]")
+            filters_arg = {'public-ip' => [*filters_arg]}
+          end
+          self.filters = filters_arg
+          data = service.describe_addresses(filters).body
+          load(
+            data['addressesSet'].map do |address|
+              address.reject {|key, value| value.nil? || value.empty? }
+            end
+          )
+          if server
+            self.replace(self.select {|address| address.server_id == server.id})
+          end
+          self
+        end
+
+        # Used to retrieve an IP address
+        #
+        # public_ip is required to get the associated IP information.
+        #
+        # You can run the following command to get the details:
+        # AWS.addresses.get("76.7.46.54")
+
+        def get(public_ip)
+          if public_ip
+            self.class.new(:service => service).all('public-ip' => public_ip).first
+          end
+        end
+
+        def new(attributes = {})
+          if server
+            super({ :server => server }.merge!(attributes))
+          else
+            super(attributes)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class AWS
+      class DhcpOption < Fog::Model
+        identity  :id,                          :aliases => 'dhcpOptionsId'
+        attribute :dhcp_configuration_set,      :aliases => 'dhcpConfigurationSet'
+        attribute :tag_set,                     :aliases => 'tagSet'
+
+        def initialize(attributes={})
+          super
+        end
+
+        # Associates an existing dhcp configration set with a VPC
+        #
+        # dhcp_option.attach(dopt-id, vpc-id)
+        #
+        # ==== Returns
+        #
+        # True or false depending on the result
+        #
+        def associate(vpc_id)
+          requires :id
+          service.associate_dhcp_options(id, vpc_id)
+          reload
+        end
+
+        # Removes an existing dhcp configuration set
+        #
+        # dhcp_option.destroy
+        #
+        # ==== Returns
+        #
+        # True or false depending on the result
+        #
+
+        def destroy
+          requires :id
+          service.delete_dhcp_options(id)
+          true
+        end
+
+        # Create a dhcp configuration set
+        #
+        #  >> g = AWS.dhcp_options.new()
+        #  >> g.save
+        #
+        # == Returns:
+        #
+        # requestId and a dhcpOptions object
+        #
+
+        def save
+          requires :dhcp_configuration_set
+          data = service.create_dhcp_options(dhcp_configuration_set).body['dhcpOptionsSet'].first
+          new_attributes = data.reject {|key,value| key == 'requestId'}
+          merge_attributes(new_attributes)
+          true
+
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'fog/core/collection'
+require 'fog/aws/models/compute/dhcp_option'
+
+module Fog
+  module Compute
+    class AWS
+      class DhcpOptions < Fog::Collection
+        attribute :filters
+
+        model Fog::Compute::AWS::DhcpOption
+
+        # Creates a new dhcp option
+        #
+        # AWS.dhcp_options.new
+        #
+        # ==== Returns
+        #
+        # Returns the details of the new DHCP options
+        #
+        #>> AWS.dhcp_options.new
+        #=>   <Fog::Compute::AWS::DhcpOption
+        #id=nil,
+        #dhcp_configuration_set=nil,
+        #tag_set=nil
+        #>
+        #
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        # Returns an array of all DhcpOptions that have been created
+        #
+        # AWS.dhcp_options.all
+        #
+        # ==== Returns
+        #
+        # Returns an array of all DhcpOptions
+        #
+        #>> AWS.dhcp_options.all
+        #<Fog::Compute::AWS::DhcpOptions
+        #filters={}
+        #[
+        #<Fog::Compute::AWS::DhcpOption
+        #id="dopt-some-id",
+        #dhcp_configuration_set={"vpcId"=>"vpc-some-id", "state"=>"available"},
+        #tag_set={}
+        #>
+        #]
+        #>
+        #
+
+        def all(filters_arg = filters)
+          unless filters_arg.is_a?(Hash)
+            Fog::Logger.warning("all with #{filters_arg.class} param is deprecated, use all('internet-gateway-id' => []) instead [light_black](#{caller.first})[/]")
+            filters_arg = {'dhcp-options-id' => [*filters_arg]}
+          end
+          filters = filters_arg
+          data = service.describe_dhcp_options(filters).body
+          load(data['dhcpOptionsSet'])
+        end
+
+        # Used to retrieve an DhcpOption
+        #
+        # You can run the following command to get the details:
+        # AWS.dhcp_options.get("dopt-12345678")
+        #
+        # ==== Returns
+        #
+        #>> AWS.dhcp_options.get("dopt-12345678")
+        #=>   <Fog::Compute::AWS::DhcpOption
+        #id="dopt-12345678",
+        #dhcp_configuration_set={"vpcId"=>"vpc-12345678", "state"=>"available"},
+        #tag_set={}
+        #>
+        #
+
+        def get(dhcp_options_id)
+          if dhcp_options_id
+            self.class.new(:service => service).all('dhcp-options-id' => dhcp_options_id).first
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class AWS
+      class Flavor < Fog::Model
+        identity :id
+
+        attribute :bits
+        attribute :cores
+        attribute :disk
+        attribute :name
+        attribute :ram
+        attribute :ebs_optimized_available
+        attribute :instance_store_volumes
+      end
+    end
+  end
+end

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

@@ -0,0 +1,606 @@
+require 'fog/core/collection'
+require 'fog/aws/models/compute/flavor'
+
+module Fog
+  module Compute
+    class AWS
+      FLAVORS = [
+        {
+          :id                      => 't1.micro',
+          :name                    => 'Micro Instance',
+          :bits                    => 0,
+          :cores                   => 2,
+          :disk                    => 0,
+          :ram                     => 613,
+          :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',
+          :bits                    => 32,
+          :cores                   => 1,
+          :disk                    => 160,
+          :ram                     => 1740.8,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 1
+        },
+        {
+          :id                      => 'm1.medium',
+          :name                    => 'Medium Instance',
+          :bits                    => 32,
+          :cores                   => 2,
+          :disk                    => 400,
+          :ram                     => 3750,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 1
+        },
+        {
+          :id                      => 'm1.large',
+          :name                    => 'Large Instance',
+          :bits                    => 64,
+          :cores                   => 4,
+          :disk                    => 850,
+          :ram                     => 7680,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'm1.xlarge',
+          :name                    => 'Extra Large Instance',
+          :bits                    => 64,
+          :cores                   => 8,
+          :disk                    => 1690,
+          :ram                     => 15360,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 4
+        },
+        {
+          :id                      =>  'c1.medium',
+          :bits                    => 32,
+          :cores                   => 5,
+          :disk                    => 350,
+          :name                    => 'High-CPU Medium',
+          :ram                     => 1740.8,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 1
+        },
+        {
+          :id                      => 'c1.xlarge',
+          :name                    => 'High-CPU Extra Large',
+          :bits                    => 64,
+          :cores                   => 20,
+          :disk                    => 1690,
+          :ram                     => 7168,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 4
+        },
+        {
+          :id                      => 'c3.large',
+          :name                    => 'C3 Large',
+          :bits                    => 64,
+          :cores                   => 7,
+          :disk                    => 32,
+          :ram                     => 3750,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'c3.xlarge',
+          :name                    => 'C3 Extra Large',
+          :bits                    => 64,
+          :cores                   => 14,
+          :disk                    => 80,
+          :ram                     => 7168,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'c3.2xlarge',
+          :name                    => 'C3 Double Extra Large',
+          :bits                    => 64,
+          :cores                   => 28,
+          :disk                    => 160,
+          :ram                     => 15360,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'c3.4xlarge',
+          :name                    => 'C3 Quadruple Extra Large',
+          :bits                    => 64,
+          :cores                   => 55,
+          :disk                    => 320,
+          :ram                     => 30720,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'c3.8xlarge',
+          :name                    => 'C3 Eight Extra Large',
+          :bits                    => 64,
+          :cores                   => 108,
+          :disk                    => 640,
+          :ram                     => 61440,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'g2.2xlarge',
+          :name                    => 'GPU Double Extra Large',
+          :bits                    => 64,
+          :cores                   => 26,
+          :disk                    => 60,
+          :ram                     => 15360,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 0
+        },
+        {
+          :id                      => 'hs1.8xlarge',
+          :name                    => 'High Storage Eight Extra Large',
+          :bits                    => 64,
+          :cores                   => 35,
+          :disk                    => 50331648,
+          :ram                     => 119808,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 24
+        },
+        {
+          :id                      => 'm2.xlarge',
+          :name                    => 'High-Memory Extra Large',
+          :bits                    => 64,
+          :cores                   => 6.5,
+          :disk                    => 420,
+          :ram                     => 17510.4,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 1
+        },
+        {
+          :id                      =>  'm2.2xlarge',
+          :name                    => 'High Memory Double Extra Large',
+          :bits                    => 64,
+          :cores                   => 13,
+          :disk                    => 850,
+          :ram                     => 35020.8,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 1
+        },
+        {
+          :id                      => 'm2.4xlarge',
+          :name                    => 'High Memory Quadruple Extra Large',
+          :bits                    => 64,
+          :cores                   => 26,
+          :disk                    => 1690,
+          :ram                     => 70041.6,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'cr1.8xlarge',
+          :name                    => 'High Memory Eight Extra Large',
+          :bits                    => 64,
+          :cores                   => 88,
+          :disk                    => 240,
+          :ram                     => 249856,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'm3.medium',
+          :name                    => 'M3 Medium',
+          :bits                    => 64,
+          :cores                   => 3,
+          :disk                    => 4,
+          :ram                     => 3840,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 0
+        },
+        {
+          :id                      => 'm3.large',
+          :name                    => 'M3 Large',
+          :bits                    => 64,
+          :cores                   => 6.5,
+          :disk                    => 32,
+          :ram                     => 7168,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 1
+        },
+        {
+          :id                      => 'm3.xlarge',
+          :name                    => 'M3 Extra Large',
+          :bits                    => 64,
+          :cores                   => 13,
+          :disk                    => 80,
+          :ram                     => 15360,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'm3.2xlarge',
+          :name                    => 'M3 Double Extra Large',
+          :bits                    => 64,
+          :cores                   => 26,
+          :disk                    => 160,
+          :ram                     => 30720,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => "hi1.4xlarge",
+          :name                    => "High I/O Quadruple Extra Large Instance",
+          :bits                    => 64,
+          :cores                   =>   35,
+          :disk                    => 2048,
+          :ram                     => 61952,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'cc1.4xlarge',
+          :name                    => 'Cluster Compute Quadruple Extra Large',
+          :bits                    => 64,
+          :cores                   => 33.5,
+          :disk                    => 1690,
+          :ram                     => 23552,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 0
+        },
+        {
+          :id                      => 'cc2.8xlarge',
+          :name                    => 'Cluster Compute Eight Extra Large',
+          :bits                    => 64,
+          :cores                   => 88,
+          :disk                    => 3370,
+          :ram                     => 61952,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 4
+        },
+        {
+          :id                      => 'cg1.4xlarge',
+          :name                    => 'Cluster GPU Quadruple Extra Large',
+          :bits                    => 64,
+          :cores                   => 33.5,
+          :disk                    => 1690,
+          :ram                     => 22528,
+          :ebs_optimized_available => false,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'i2.xlarge',
+          :name                    => 'I2 Extra Large',
+          :bits                    => 64,
+          :cores                   => 14,
+          :disk                    => 800,
+          :ram                     => 31232,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 1
+        },
+        {
+          :id                      => 'i2.2xlarge',
+          :name                    => 'I2 Double Extra Large',
+          :bits                    => 64,
+          :cores                   => 27,
+          :disk                    => 1600,
+          :ram                     => 62464,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 2
+        },
+        {
+          :id                      => 'i2.4xlarge',
+          :name                    => 'I2 Quadruple Extra Large',
+          :bits                    => 64,
+          :cores                   => 53,
+          :disk                    => 3200,
+          :ram                     => 124928,
+          :ebs_optimized_available => true,
+          :instance_store_volumes  => 4
+        },
+        {
+          :id                      => 'i2.8xlarge',
+          :name                    => 'I2 Eight Extra Large',
+          :bits                    => 64,
+          :cores                   => 104,
+          :disk                    => 6400,
+          :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
+        }
+      ]
+
+      class Flavors < Fog::Collection
+        model Fog::Compute::AWS::Flavor
+
+        # Returns an array of all flavors that have been created
+        #
+        # AWS.flavors.all
+        #
+        # ==== Returns
+        #
+        # Returns an array of all available instances and their general information
+        #
+        #>> AWS.flavors.all
+        #  <Fog::AWS::Compute::Flavors
+        #    [
+        #      <Fog::AWS::Compute::Flavor
+        #        id="t1.micro",
+        #        bits=0,
+        #        cores=2,
+        #        disk=0,
+        #        name="Micro Instance",
+        #        ram=613,
+        #        ebs_optimized_available=false,
+        #        instance_store_volumes=0
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
+        #        id="m1.small",
+        #        bits=32,
+        #        cores=1,
+        #        disk=160,
+        #        name="Small Instance",
+        #        ram=1740.8,
+        #        ebs_optimized_available=false,
+        #        instance_store_volumes=1
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
+        #        id="m1.medium",
+        #        bits=32,
+        #        cores=2,
+        #        disk=400,
+        #        name="Medium Instance",
+        #        ram=3750,
+        #        ebs_optimized_available=false,
+        #        instance_store_volumes=1
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
+        #        id="m1.large",
+        #        bits=64,
+        #        cores=4,
+        #        disk=850,
+        #        name="Large Instance",
+        #        ram=7680,
+        #        ebs_optimized_available=true
+        #        instance_store_volumes=2
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
+        #        id="m1.xlarge",
+        #        bits=64,
+        #        cores=8,
+        #        disk=1690,
+        #        name="Extra Large Instance",
+        #        ram=15360,
+        #        ebs_optimized_available=true,
+        #        instance_store_volumes=4
+        #
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
+        #        id="c1.medium",
+        #        bits=32,
+        #        cores=5,
+        #        disk=350,
+        #        name="High-CPU Medium",
+        #        ram=1740.8,
+        #        ebs_optimized_available=false,
+        #        instance_store_volumes=1
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
+        #        id="c1.xlarge",
+        #        bits=64,
+        #        cores=20,
+        #        disk=1690,
+        #        name="High-CPU Extra Large",
+        #        ram=7168,
+        #        ebs_optimized_available=true,
+        #        instance_store_volumes=4
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
+        #        id="m2.xlarge",
+        #        bits=64,
+        #        cores=6.5,
+        #        disk=420,
+        #        name="High-Memory Extra Large",
+        #        ram=17510.4,
+        #        ebs_optimized_available=false,
+        #        instance_store_volumes=1
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
+        #        id="m2.2xlarge",
+        #        bits=64,
+        #        cores=13,
+        #        disk=850,
+        #        name="High Memory Double Extra Large",
+        #        ram=35020.8,
+        #        ebs_optimized_available=true,
+        #        instance_store_volumes=1
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
+        #        id="m2.4xlarge",
+        #        bits=64,
+        #        cores=26,
+        #        disk=1690,
+        #        name="High Memory Quadruple Extra Large",
+        #        ram=70041.6,
+        #        ebs_optimized_available=true,
+        #        instance_store_volumes=2
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
+        #        id="cc1.4xlarge",
+        #        bits=64,
+        #        cores=33.5,
+        #        disk=1690,
+        #        name="Cluster Compute Quadruple Extra Large",
+        #        ram=23552,
+        #        ebs_optimized_available=false,
+        #        instance_store_volumes=0
+        #      >,
+        #      <Fog::Compute::AWS::Flavor
+        #        id="m3.xlarge",
+        #        bits=64,
+        #        cores=13,
+        #        disk=0,
+        #        name="M3 Extra Large",
+        #        ram=15360,
+        #        ebs_optimized_available=true,
+        #        instance_store_volumes=2
+        #      >,
+        #      <Fog::Compute::AWS::Flavor
+        #        id="m3.2xlarge",
+        #        bits=64,
+        #        cores=26,
+        #        disk=0,
+        #        name="M3 Double Extra Large",
+        #        ram=30720,
+        #        ebs_optimized_available=true,
+        #        instance_store_volumes=2
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
+        #        id="cc2.8xlarge",
+        #        bits=64,
+        #        cores=88,
+        #        disk=3370,
+        #        name="Cluster Compute Eight Extra Large",
+        #        ram=61952,
+        #        ebs_optimized_available=false,
+        #        instance_store_volumes=4
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
+        #        id="cg1.4xlarge",
+        #        bits=64,
+        #        cores=33.5,
+        #        disk=1690,
+        #        name="Cluster GPU Quadruple Extra Large",
+        #        ram=22528,
+        #        ebs_optimized_available=false,
+        #        instance_store_volumes=2
+        #      >
+        #    ]
+        #  >
+        #
+
+        def all
+          load(Fog::Compute::AWS::FLAVORS)
+          self
+        end
+
+        # Used to retrieve a flavor
+        # flavor_id is required to get the associated flavor information.
+        # flavors available currently:
+        #
+        # t1.micro
+        # m1.small, m1.medium, m1.large, m1.xlarge
+        # c1.medium, c1.xlarge
+        # c3.large, c3.xlarge, c3.2xlarge, c3.4xlarge, c3.8xlarge
+        # g2.2xlarge
+        # hs1.8xlarge
+        # m2.xlarge, m2.2xlarge, m2.4xlarge
+        # m3.xlarge, m3.2xlarge
+        # cr1.8xlarge
+        # cc1.4xlarge
+        # cc2.8xlarge
+        # cg1.4xlarge
+        # i2.xlarge, i2.2xlarge, i2.4xlarge, i2.8xlarge
+        #
+        # You can run the following command to get the details:
+        # AWS.flavors.get("t1.micro")
+        #
+        # ==== Returns
+        #
+        #>> AWS.flavors.get("t1.micro")
+        # <Fog::AWS::Compute::Flavor
+        #  id="t1.micro",
+        #  bits=0,
+        #  cores=2,
+        #  disk=0,
+        #  name="Micro Instance",
+        #  ram=613
+        #  ebs_optimized_available=false
+        #  instance_store_volumes=0
+        #>
+        #
+
+        def get(flavor_id)
+          self.class.new(:service => service).all.find {|flavor| flavor.id == flavor_id}
+        end
+      end
+    end
+  end
+end