amazon-pricing 0.1.9 → 0.1.10

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/testtask'
 
 $: << File.expand_path(File.dirname(__FILE__), 'lib')
 
-require 'amazon-pricing/version'
+require File.join('amazon-pricing','version')
 
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
@@ -32,10 +32,10 @@ task :test do
 end
 
 desc "Prints current EC2 pricing in CSV format"
-task :print_price_list do
-  require 'lib/amazon-pricing'
-  pricing = AwsPricing::PriceList.new
-  line = "Region,Instance Type,API Name,Memory (MB),Disk (MB),Compute Units, Virtual Cores,OD Linux PPH,OD Windows PPH,OD RHEL PPH,OD SLES PPH,OD MsWinSQL PPH,OD MsWinSQLWeb PPH,"
+task :print_ec2_price_list do
+  require 'amazon-pricing'
+  pricing = AwsPricing::Ec2PriceList.new
+  line = "Region,Instance Type,API Name,Memory (MB),Disk (GB),Compute Units,Virtual Cores,Disk Type,OD Linux PPH,OD Windows PPH,OD RHEL PPH,OD SLES PPH,OD MsWinSQL PPH,OD MsWinSQLWeb PPH,"
   [:year1, :year3].each do |term|
     [:light, :medium, :heavy].each do |res_type|
       [:linux, :mswin, :rhel, :sles, :mswinSQL, :mswinSQLWeb].each do |os|
@@ -45,8 +45,8 @@ task :print_price_list do
   end
   puts line.chop
   pricing.regions.each do |region|
-    region.instance_types.each do |t|
-      line = "#{region.name},#{t.name},#{t.api_name},#{t.memory_in_mb},#{t.disk_in_mb},#{t.compute_units},#{t.virtual_cores},"
+    region.ec2_instance_types.each do |t|
+      line = "#{region.name},#{t.name},#{t.api_name},#{t.memory_in_mb},#{t.disk_in_gb},#{t.compute_units},#{t.virtual_cores},#{t.disk_type},"
       [:linux, :mswin, :rhel, :sles, :mswinSQL, :mswinSQLWeb].each do |os|
         line += "#{t.price_per_hour(os, :ondemand)},"
       end
@@ -62,4 +62,72 @@ task :print_price_list do
   end
 end
 
+
+desc "Prints current RDS pricing in CSV format"
+task :print_rds_price_list do
+  require 'amazon-pricing'
+  pricing = AwsPricing::RdsPriceList.new
+
+  line = "Region,Instance Type,API Name,Memory (MB),Disk (GB),Compute Units,Virtual Cores,Disk Type,"
+
+
+  [:mysql, :oracle, :oracle_byol, :sqlserver, :sqlserver_express, :sqlserver_web, :sqlserver_byol].each do |db|
+    if [:mysql, :oracle, :oracle_byol].include? db
+      [:standard,:multiAZ].each do |deploy_type|
+        line += "OD #{db} #{deploy_type} PPH,"
+      end
+    else
+      line += "OD #{db} PPH,"
+    end  
+  end
+
+
+  [:year1, :year3].each do |term|
+    [:light, :medium, :heavy].each do |res_type|
+      [:mysql, :oracle, :oracle_byol, :sqlserver, :sqlserver_express, :sqlserver_web, :sqlserver_byol].each do |db|
+        if [:mysql, :oracle, :oracle_byol].include? db
+          [:standard,:multiAZ].each do |deploy_type|
+            line += "#{term} #{res_type} #{deploy_type} #{db} Prepay,#{term} #{res_type} #{deploy_type} #{db} PPH,"
+          end
+        else
+          line += "#{term} #{res_type} #{db} Prepay,#{term} #{res_type} #{db} PPH,"
+        end
+      end
+    end
+  end
+
+ 
+  puts line.chop
+
+  pricing.regions.each do |region|
+    region.rds_instance_types.each do |t|
+      line = "#{region.name},#{t.name},#{t.api_name},#{t.memory_in_mb},#{t.disk_in_gb},#{t.compute_units},#{t.virtual_cores},#{t.disk_type},"
+      [:mysql, :oracle, :oracle_byol, :sqlserver, :sqlserver_express, :sqlserver_web, :sqlserver_byol].each do |db|
+         if [:mysql, :oracle, :oracle_byol].include? db
+            [:standard,:multiAZ].each do |deploy_type|
+              line += "#{t.price_per_hour(db, :ondemand, nil, deploy_type == :multiAZ)},"
+            end
+         else
+            line += "#{t.price_per_hour(db, :ondemand, nil, false)},"
+         end          
+      end
+
+      [:year1, :year3].each do |term|
+        [:light, :medium, :heavy].each do |res_type|
+          [:mysql, :oracle, :oracle_byol, :sqlserver, :sqlserver_express, :sqlserver_web, :sqlserver_byol].each do |db|
+            if [:mysql, :oracle, :oracle_byol].include? db
+              [:standard,:multiAZ].each do |deploy_type|
+                line += "#{t.prepay(db, res_type, term, deploy_type == :multiAZ)},#{t.price_per_hour(db, res_type, term, deploy_type == :multiAZ)},"
+              end
+            else
+              line += "#{t.prepay(db, res_type, term, false)},#{t.price_per_hour(db, res_type, term, false)},"
+            end
+          end
+        end
+      end
+      puts line.chop
+    end
+  end
+end
+
 task :default => [:test]

data/amazon-pricing.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+$:.push File.expand_path(File.join("..","lib"), __FILE__)
 require "amazon-pricing/version"
 
 Gem::Specification.new do |s|

data/lib/amazon-pricing.rb

@@ -18,16 +18,9 @@ module AwsPricing
   # Upon instantiating a PriceList object, all the corresponding pricing
   # information will be retrieved from Amazon via currently undocumented
   # json APIs.
-  class PriceList
+    class PriceList
     attr_accessor :regions
 
-    def initialize
-      @_regions = {}
-      get_ec2_on_demand_instance_pricing
-      get_ec2_reserved_instance_pricing
-      fetch_ec2_ebs_pricing
-    end
-
     def get_region(name)
       @_regions[@@Region_Lookup[name] || name]
     end
@@ -42,6 +35,12 @@ module AwsPricing
       region.get_instance_type(api_name)
     end
 
+    def fetch_url(url)
+      uri = URI.parse(url)
+      page = Net::HTTP.get_response(uri)
+      JSON.parse(page.body)
+    end
+
     protected
 
     attr_accessor :_regions
@@ -59,6 +58,33 @@ module AwsPricing
       region
     end
 
+    EC2_BASE_URL = "http://aws.amazon.com/ec2/pricing/"
+    RDS_BASE_URL = "http://aws.amazon.com/rds/pricing/"
+
+    # Lookup allows us to map to AWS API region names
+    @@Region_Lookup = {
+      'us-east-1' => 'us-east',
+      'us-west-1' => 'us-west',
+      'us-west-2' => 'us-west-2',
+      'eu-west-1' => 'eu-ireland',
+      'ap-southeast-1' => 'apac-sin',
+      'ap-southeast-2' => 'apac-syd',
+      'ap-northeast-1' => 'apac-tokyo',
+      'sa-east-1' => 'sa-east-1'
+    }
+
+  end
+
+
+  class Ec2PriceList < PriceList
+    
+    def initialize
+      @_regions = {}
+      get_ec2_on_demand_instance_pricing
+      get_ec2_reserved_instance_pricing
+      fetch_ec2_ebs_pricing
+    end
+
     protected
 
     @@OS_TYPES = [:linux, :mswin, :rhel, :sles, :mswinSQL, :mswinSQLWeb]
@@ -90,9 +116,9 @@ module AwsPricing
           # e.g. size = {"size"=>"xl", "valueColumns"=>[{"name"=>"mswinSQL", "prices"=>{"USD"=>"2.427"}}]}
           type['sizes'].each do |size|
             begin
-              api_name, name = InstanceType.get_name(type["type"], size["size"], type_of_instance != :ondemand)
-
-              region.add_or_update_instance_type(api_name, name, operating_system, type_of_instance, size)
+              api_name, name = Ec2InstanceType.get_name(type["type"], size["size"], type_of_instance != :ondemand)
+              
+              region.add_or_update_ec2_instance_type(api_name, name, operating_system, type_of_instance, size)
             rescue UnknownTypeError
               $stderr.puts "WARNING: encountered #{$!.message}"
             end
@@ -109,24 +135,118 @@ module AwsPricing
       end
     end
 
-    def fetch_url(url)
-      uri = URI.parse(url)
-      page = Net::HTTP.get_response(uri)
-      JSON.parse(page.body)
+  end
+
+
+
+  class RdsPriceList < PriceList
+    
+    def initialize
+      @_regions = {}
+       get_rds_on_demand_instance_pricing
+       get_rds_reserved_instance_pricing
     end
 
-    EC2_BASE_URL = "http://aws.amazon.com/ec2/pricing/"
+    protected
 
-    # Lookup allows us to map to AWS API region names
-    @@Region_Lookup = {
-      'us-east-1' => 'us-east',
-      'us-west-1' => 'us-west',
-      'us-west-2' => 'us-west-2',
-      'eu-west-1' => 'eu-ireland',
-      'ap-southeast-1' => 'apac-sin',
-      'ap-southeast-2' => 'apac-syd',
-      'ap-northeast-1' => 'apac-tokyo',
-      'sa-east-1' => 'sa-east-1'
-    }
+    @@DB_TYPE = [:mysql, :oracle, :sqlserver]
+    @@RES_TYPES = [:light, :medium, :heavy]
+    
+    @@OD_DB_DEPLOY_TYPE = {
+                           :mysql=> {:mysql=>["standard","multiAZ"]},
+                           :oracle=> {:oracle=>["li-standard","li-multiAZ"], :oracle_byol=>["byol-standard","byol-multiAZ"]},
+                           :sqlserver=> {:sqlserver=>["li-se"], :sqlserver_express=>["li-ex"], :sqlserver_web=>["li-web"], :sqlserver_byol=>["byol"]}
+                        }
+
+
+    @@RESERVED_DB_DEPLOY_TYPE = {
+                           :oracle=> {:oracle=>"li", :oracle_byol=>"byol"},
+                           :sqlserver=> {:sqlserver=>"li-se", :sqlserver_express=>"li-ex", :sqlserver_web=>"li-web", :sqlserver_byol=>"byol"}
+                          }
+
+    
+    def is_multi_az?(type)
+      return true if type.match("multiAZ")
+      false
+    end                                  
+
+    def get_rds_on_demand_instance_pricing
+      @@DB_TYPE.each do |db|
+        @@OD_DB_DEPLOY_TYPE[db].each {|db_type, db_instances|
+          db_instances.each do |dp_type|
+            if db == :mysql or db == :oracle
+              fetch_on_demand_rds_instance_pricing(RDS_BASE_URL+"#{db}/pricing-#{dp_type}-deployments.json",:ondemand, db_type)
+            elsif db == :sqlserver
+              fetch_on_demand_rds_instance_pricing(RDS_BASE_URL+"#{db}/sqlserver-#{dp_type}-ondemand.json",:ondemand, db_type)
+            end
+          end
+        }
+      end
+    end
+
+    def get_rds_reserved_instance_pricing
+       @@DB_TYPE.each do |db|
+        if db == :mysql
+          @@RES_TYPES.each do |res_type|
+            fetch_reserved_rds_instance_pricing(RDS_BASE_URL+"#{db}/pricing-#{res_type}-utilization-reserved-instances.json", res_type, db)
+          end
+        else
+          @@RESERVED_DB_DEPLOY_TYPE[db].each {|db_type, db_instance|
+            @@RES_TYPES.each do |res_type|
+              fetch_reserved_rds_instance_pricing(RDS_BASE_URL+"#{db}/pricing-#{db_instance}-#{res_type}-utilization-reserved-instances.json", res_type, db_type) if db == :oracle
+              fetch_reserved_rds_instance_pricing(RDS_BASE_URL+"#{db}/sqlserver-#{db_instance}-#{res_type}-ri.json", res_type, db_type) if db == :sqlserver           
+            end            
+          }
+        end
+      end
+    end
+
+    def fetch_on_demand_rds_instance_pricing(url, type_of_rds_instance, db_type)
+      res = fetch_url(url)
+      res['config']['regions'].each do |reg|
+        region_name = reg['region']
+        region = find_or_create_region(region_name)
+        reg['types'].each do |type|
+          type['tiers'].each do |tier|
+            begin
+              #
+              # this is special case URL, it is oracle - multiAZ type of deployment but it doesn't have mutliAZ attributes in json.
+              if url == "http://aws.amazon.com/rds/pricing/oracle/pricing-li-multiAZ-deployments.json"
+                isMultiAz = true
+              else
+                isMultiAz = is_multi_az? type["name"]
+              end              
+              api_name, name = RdsInstanceType.get_name(type["name"], tier["name"], type_of_rds_instance != :ondemand)
+              
+              region.add_or_update_rds_instance_type(api_name, name, db_type, type_of_rds_instance, tier, isMultiAz)
+            rescue UnknownTypeError
+              $stderr.puts "WARNING: encountered #{$!.message}"
+            end
+          end
+        end
+      end
+    end
+
+    def fetch_reserved_rds_instance_pricing(url, type_of_rds_instance, db_type)
+      res = fetch_url(url)
+      res['config']['regions'].each do |reg|
+        region_name = reg['region']
+        region = find_or_create_region(region_name)
+        reg['instanceTypes'].each do |type|
+          type['tiers'].each do |tier|
+            begin
+                isMultiAz = is_multi_az? type["type"]
+                api_name, name = RdsInstanceType.get_name(type["type"], tier["size"], true)
+                
+                region.add_or_update_rds_instance_type(api_name, name, db_type, type_of_rds_instance, tier, isMultiAz)
+            rescue UnknownTypeError
+              $stderr.puts "WARNING: encountered #{$!.message}"
+            end
+          end
+        end
+      end
+    end                              
   end
+
+
 end

data/lib/amazon-pricing/category-type.rb

@@ -0,0 +1,154 @@
+#--
+# Amazon Web Services Pricing Ruby library
+#
+# Ruby Gem Name::  amazon-pricing
+# Author::    Joe Kinsella (mailto:joe.kinsella@gmail.com)
+# Copyright:: Copyright (c) 2011-2013 CloudHealth
+# License::   Distributes under the same terms as Ruby
+# Home::      http://github.com/CloudHealth/amazon-pricing
+#++
+module AwsPricing
+
+  class CategoryType
+    attr_accessor :instance_type, :name, 
+      :ondemand_price_per_hour, :light_price_per_hour_1_year, :medium_price_per_hour_1_year, :heavy_price_per_hour_1_year,
+      :light_price_per_hour_3_year, :medium_price_per_hour_3_year, :heavy_price_per_hour_3_year,
+      :light_prepay_1_year, :light_prepay_3_year, :medium_prepay_1_year, :medium_prepay_3_year, :heavy_prepay_1_year, :heavy_prepay_3_year
+
+
+    def initialize(instance_type, name)
+      @instance_type = instance_type
+      @name = name
+    end
+
+    # Returns whether an instance_type is available. 
+    # type_of_instance = :ondemand, :light, :medium, :heavy
+    def available?(type_of_instance = :ondemand)
+      not price_per_hour(type_of_instance).nil?
+    end
+
+    # type_of_instance = :ondemand, :light, :medium, :heavy
+    # term = :year_1, :year_3, nil
+    def prepay(type_of_instance = :ondemand, term = nil)
+      case type_of_instance
+      when :ondemand
+        0
+      when :light
+        if term == :year1
+          @light_prepay_1_year
+        elsif term == :year3
+          @light_prepay_3_year
+        end
+      when :medium
+        if term == :year1
+          @medium_prepay_1_year
+        elsif term == :year3
+          @medium_prepay_3_year
+        end
+      when :heavy
+        if term == :year1
+          @heavy_prepay_1_year
+        elsif term == :year3
+          @heavy_prepay_3_year
+        end
+      end
+    end
+
+    # type_of_instance = :ondemand, :light, :medium, :heavy
+    # term = :year_1, :year_3, nil
+    def set_prepay(type_of_instance, term, price)
+      case type_of_instance
+      when :light
+        if term == :year1
+          @light_prepay_1_year = price
+        elsif term == :year3
+          @light_prepay_3_year = price
+        end
+      when :medium
+        if term == :year1
+          @medium_prepay_1_year = price
+        elsif term == :year3
+          @medium_prepay_3_year = price
+        end
+      when :heavy
+        if term == :year1
+          @heavy_prepay_1_year = price
+        elsif term == :year3
+          @heavy_prepay_3_year = price
+        end
+      end
+    end
+
+    # type_of_instance = :ondemand, :light, :medium, :heavy
+    # term = :year_1, :year_3, nil
+    def price_per_hour(type_of_instance = :ondemand, term = nil)
+      case type_of_instance
+      when :ondemand
+        @ondemand_price_per_hour
+      when :light
+        if term == :year1
+          @light_price_per_hour_1_year
+        elsif term == :year3
+          @light_price_per_hour_3_year
+        end
+      when :medium
+        if term == :year1
+          @medium_price_per_hour_1_year
+        elsif term == :year3
+          @medium_price_per_hour_3_year
+        end
+      when :heavy
+        if term == :year1
+          @heavy_price_per_hour_1_year
+        elsif term == :year3
+          @heavy_price_per_hour_3_year
+        end
+      end
+    end
+
+    # type_of_instance = :ondemand, :light, :medium, :heavy
+    # term = :year_1, :year_3, nil
+    def set_price_per_hour(type_of_instance, term, price_per_hour)
+      case type_of_instance
+      when :ondemand
+        @ondemand_price_per_hour = price_per_hour
+      when :light
+        if term == :year1
+          @light_price_per_hour_1_year = price_per_hour
+        elsif term == :year3
+          @light_price_per_hour_3_year = price_per_hour
+        end
+      when :medium
+        if term == :year1
+          @medium_price_per_hour_1_year = price_per_hour
+        elsif term == :year3
+          @medium_price_per_hour_3_year = price_per_hour
+        end
+      when :heavy
+        if term == :year1
+          @heavy_price_per_hour_1_year = price_per_hour
+        elsif term == :year3
+          @heavy_price_per_hour_3_year = price_per_hour
+        end
+      end
+    end
+
+    # type_of_instance = :ondemand, :light, :medium, :heavy
+    # term = :year_1, :year_3, nil
+    def get_breakeven_month(type_of_instance, term)
+      # Some regions and types do not have reserved available
+      ondemand_pph = price_per_hour(:ondemand)
+      reserved_pph = price_per_hour(type_of_instance, term)
+      return nil if ondemand_pph.nil? || reserved_pph.nil?
+
+      on_demand = 0
+      reserved = prepay(type_of_instance, term)
+      for i in 1..36 do
+        on_demand +=  ondemand_pph * 24 * 30.4 
+        reserved += reserved_pph * 24 * 30.4 
+        return i if reserved < on_demand
+      end
+      nil
+    end
+  end
+end

data/lib/amazon-pricing/database-type.rb

@@ -0,0 +1,13 @@
+#--
+# Amazon Web Services Pricing Ruby library
+#
+# Ruby Gem Name::  amazon-pricing
+# Author::    Joe Kinsella (mailto:joe.kinsella@gmail.com)
+# Copyright:: Copyright (c) 2011-2013 CloudHealth
+# License::   Distributes under the same terms as Ruby
+# Home::      http://github.com/CloudHealth/amazon-pricing
+#++
+module AwsPricing
+  class DatabaseType < CategoryType
+  end
+end

data/lib/amazon-pricing/ec2-instance-type.rb

@@ -0,0 +1,79 @@
+require 'amazon-pricing/instance-type'
+module AwsPricing
+  class Ec2InstanceType < InstanceType
+    
+    # Returns whether an instance_type is available. 
+    # operating_system = :linux, :mswin, :rhel, :sles, :mswinSQL, :mswinSQLWeb
+    # type_of_instance = :ondemand, :light, :medium, :heavy
+    def available?(type_of_instance = :ondemand, operating_system = :linux)
+      os = get_category_type(operating_system)
+      return false if os.nil?
+      os.available?(type_of_instance)
+    end
+
+    # operating_system = :linux, :mswin, :rhel, :sles, :mswinSQL, :mswinSQLWeb
+    # type_of_instance = :ondemand, :light, :medium, :heavy
+    def update_pricing(operating_system, type_of_instance, json)
+      os = get_category_type(operating_system)
+      if os.nil?
+        os = OperatingSystem.new(self, operating_system)
+        @category_types[operating_system] = os
+      end
+
+      if type_of_instance == :ondemand
+        # e.g. {"size"=>"sm", "valueColumns"=>[{"name"=>"linux", "prices"=>{"USD"=>"0.060"}}]}
+        values = Ec2InstanceType::get_values(json, operating_system)
+        price = coerce_price(values[operating_system.to_s])
+        os.set_price_per_hour(type_of_instance, nil, price)
+      else
+        json['valueColumns'].each do |val|
+          price = coerce_price(val['prices']['USD'])
+
+          case val["name"]
+          when "yrTerm1"
+            os.set_prepay(type_of_instance, :year1, price)
+          when "yrTerm3"
+            os.set_prepay(type_of_instance, :year3, price)
+          when "yrTerm1Hourly"
+            os.set_price_per_hour(type_of_instance, :year1, price)
+          when "yrTerm3Hourly"
+            os.set_price_per_hour(type_of_instance, :year3, price)
+          end
+        end
+      end
+    end
+
+    # Maintained for backward compatibility reasons
+    def operating_systems
+      category_types
+    end
+
+    protected
+    # Returns [api_name, name]
+    def self.get_name(instance_type, api_name, is_reserved = false)
+      # Let's handle new instances more gracefully
+      unless @@Memory_Lookup.has_key? api_name
+        raise UnknownTypeError, "Unknown instance type #{instance_type} #{api_name}", caller
+      end
+
+      name = @@Name_Lookup[api_name]
+
+      [api_name, name]
+    end
+
+
+    @@Name_Lookup = {
+      'm1.small' => 'Standard Small', 'm1.medium' => 'Standard Medium', 'm1.large' => 'Standard Large', 'm1.xlarge' => 'Standard Extra Large',
+      'm2.xlarge' => 'Hi-Memory Extra Large', 'm2.2xlarge' => 'Hi-Memory Double Extra Large', 'm2.4xlarge' => 'Hi-Memory Quadruple Extra Large',
+      'm3.xlarge' => 'M3 Extra Large Instance', 'm3.2xlarge' => 'M3 Double Extra Large Instance',
+      'c1.medium' => 'High-CPU Medium', 'c1.xlarge' => 'High-CPU Extra Large',
+      'hi1.4xlarge' => 'High I/O Quadruple Extra Large',
+      'cg1.4xlarge' => 'Cluster GPU Quadruple Extra Large',
+      'cc1.4xlarge' => 'Cluster Compute Quadruple Extra Large', 'cc2.8xlarge' => 'Cluster Compute Eight Extra Large',
+      't1.micro' => 'Micro',
+      'cr1.8xlarge' => 'High-Memory Cluster Eight Extra Large',
+      'hs1.8xlarge' => 'High-Storage Eight Extra Large',
+      'g2.2xlarge' => 'Cluster GPU Double Extra Large',
+    }    
+   end
+end

data/lib/amazon-pricing/instance-type.rb

@@ -19,93 +19,62 @@ module AwsPricing
   # $0.48/hour for Windows.
   #
   class InstanceType
-    attr_accessor :name, :api_name, :memory_in_mb, :disk_in_mb, :platform, :compute_units, :virtual_cores
-
-    # Initializes and InstanceType object given a region, the internal
-    # type (e.g. stdODI) and the json for the specific instance. The json is
-    # based on the current undocumented AWS pricing API.
+    attr_accessor :name, :api_name, :memory_in_mb, :platform, :compute_units, :virtual_cores, :disk_type, :disk_in_gb
+    
     def initialize(region, api_name, name)
-      @operating_systems = {}
+      @category_types = {}
 
       @region = region
       @name = name
       @api_name = api_name
 
       @memory_in_mb = @@Memory_Lookup[@api_name]
-      @disk_in_mb = @@Disk_Lookup[@api_name]
+      @disk_in_gb = @@Disk_Lookup[@api_name]
       @platform = @@Platform_Lookup[@api_name]
       @compute_units = @@Compute_Units_Lookup[@api_name]
       @virtual_cores = @@Virtual_Cores_Lookup[@api_name]
+      @disk_type = @@Disk_Type_Lookup[@api_name]
     end
 
-    def operating_systems
-      @operating_systems.values
+    # Keep this in for backwards compatibility within current major version of gem
+    def disk_in_mb
+      @disk_in_gb * 1000
     end
 
-    def get_operating_system(name)
-      @operating_systems[name]
+    def memory_in_gb
+      @memory_in_mb / 1000
     end
 
-    # Returns whether an instance_type is available. 
-    # operating_system = :linux, :mswin, :rhel, :sles, :mswinSQL, :mswinSQLWeb
-    # type_of_instance = :ondemand, :light, :medium, :heavy
-    def available?(type_of_instance = :ondemand, operating_system = :linux)
-      os = get_operating_system(operating_system)
-      return false if os.nil?
-      os.available?(type_of_instance)
+    def category_types
+      @category_types.values
     end
 
-    # type_of_instance = :ondemand, :light, :medium, :heavy
-    # term = :year_1, :year_3, nil
-    def price_per_hour(operating_system, type_of_instance, term = nil)
-      os = get_operating_system(operating_system)
-      os.price_per_hour(type_of_instance, term)
+    def get_category_type(name, multiAz = false)
+      if multiAz
+        db = @category_types["#{name}_multiAz"]
+      else
+        db = @category_types[name]
+      end      
     end
 
     # type_of_instance = :ondemand, :light, :medium, :heavy
     # term = :year_1, :year_3, nil
-    def prepay(operating_system, type_of_instance, term = nil)
-      os = get_operating_system(operating_system)
-      os.prepay(type_of_instance, term)
+    def price_per_hour(category_type, type_of_instance, term = nil, isMultiAz = false)
+      cat = get_category_type(category_type, isMultiAz)
+      cat.price_per_hour(type_of_instance, term) unless cat.nil?      
     end
 
-    # operating_system = :linux, :mswin, :rhel, :sles, :mswinSQL, :mswinSQLWeb
     # type_of_instance = :ondemand, :light, :medium, :heavy
-    def update_pricing(operating_system, type_of_instance, json)
-      os = get_operating_system(operating_system)
-      if os.nil?
-        os = OperatingSystem.new(self, operating_system)
-        @operating_systems[operating_system] = os
-      end
-
-      if type_of_instance == :ondemand
-        # e.g. {"size"=>"sm", "valueColumns"=>[{"name"=>"linux", "prices"=>{"USD"=>"0.060"}}]}
-        values = InstanceType::get_values(json)
-        price = coerce_price(values[operating_system.to_s])
-
-        os.set_price_per_hour(type_of_instance, nil, price)
-      else
-        json['valueColumns'].each do |val|
-          price = coerce_price(val['prices']['USD'])
-
-          case val["name"]
-          when "yrTerm1"
-            os.set_prepay(type_of_instance, :year1, price)
-          when "yrTerm3"
-            os.set_prepay(type_of_instance, :year3, price)
-          when "yrTerm1Hourly"
-            os.set_price_per_hour(type_of_instance, :year1, price)
-          when "yrTerm3Hourly"
-            os.set_price_per_hour(type_of_instance, :year3, price)
-          end
-        end
-      end
+    # term = :year_1, :year_3, nil
+    def prepay(category_type, type_of_instance, term = nil, isMultiAz = false)
+      cat = get_category_type(category_type, isMultiAz)
+      cat.prepay(type_of_instance, term) unless cat.nil?      
     end
 
     # type_of_instance = :ondemand, :light, :medium, :heavy
     # term = :year_1, :year_3, nil
-    def get_breakeven_month(operating_system, type_of_instance, term)
-      os = get_operating_system(operating_system)
+    def get_breakeven_month(category_types, type_of_instance, term)
+      os = get_category_type(category_types)
       os.get_breakeven_month(type_of_instance, term)
     end
 
@@ -113,46 +82,21 @@ module AwsPricing
 
     def coerce_price(price)
       return nil if price.nil? || price == "N/A"
-      price.to_f
-    end
-
-    #attr_accessor :size, :instance_type
-
-    # Returns [api_name, name]
-    def self.get_name(instance_type, api_name, is_reserved = false)
-      # Let's handle new instances more gracefully
-      unless @@Memory_Lookup.has_key? api_name
-        raise UnknownTypeError, "Unknown instance type #{instance_type} #{api_name}", caller
-      end
-
-      name = @@Name_Lookup[api_name]
-
-      [api_name, name]
+      price.gsub(",","").to_f
     end
 
-    # Turn json into hash table for parsing
-    def self.get_values(json)
-      # e.g. json = {"size"=>"xl", "valueColumns"=>[{"name"=>"mswinSQL", "prices"=>{"USD"=>"2.427"}}]}
+    def self.get_values(json, category_type)
       values = {}
-      json['valueColumns'].each do |val|
-        values[val['name']] = val['prices']['USD']
+      unless json['valueColumns'].nil?
+        json['valueColumns'].each do |val|
+          values[val['name']] = val['prices']['USD']
+        end
+      else
+        values[category_type.to_s] = json['prices']['USD']
       end
       values
     end
 
-    @@Name_Lookup = {
-      'm1.small' => 'Standard Small', 'm1.medium' => 'Standard Medium', 'm1.large' => 'Standard Large', 'm1.xlarge' => 'Standard Extra Large',
-      'm2.xlarge' => 'Hi-Memory Extra Large', 'm2.2xlarge' => 'Hi-Memory Double Extra Large', 'm2.4xlarge' => 'Hi-Memory Quadruple Extra Large',
-      'm3.xlarge' => 'M3 Extra Large Instance', 'm3.2xlarge' => 'M3 Double Extra Large Instance',
-      'c1.medium' => 'High-CPU Medium', 'c1.xlarge' => 'High-CPU Extra Large',
-      'hi1.4xlarge' => 'High I/O Quadruple Extra Large',
-      'cg1.4xlarge' => 'Cluster GPU Quadruple Extra Large',
-      'cc1.4xlarge' => 'Cluster Compute Quadruple Extra Large', 'cc2.8xlarge' => 'Cluster Compute Eight Extra Large',
-      't1.micro' => 'Micro',
-      'cr1.8xlarge' => 'High-Memory Cluster Eight Extra Large',
-      'hs1.8xlarge' => 'High-Storage Eight Extra Large',
-      'g2.2xlarge' => 'Cluster GPU Double Extra Large',
-    }
     @@Memory_Lookup = {
       'm1.small' => 1700, 'm1.medium' => 3750, 'm1.large' => 7500, 'm1.xlarge' => 15000,
       'm2.xlarge' => 17100, 'm2.2xlarge' => 34200, 'm2.4xlarge' => 68400,
@@ -166,6 +110,8 @@ module AwsPricing
       'cr1.8xlarge' => 244000,
       'hs1.8xlarge' => 117000,
       'g2.2xlarge' => 15000,
+      'db.m1.small' => 1700, 'db.m1.medium' => 3750, 'db.m1.large' => 7500, 'db.m1.xlarge' => 15000,
+      'db.m2.xlarge' => 17100, 'db.m2.2xlarge' => 34200, 'db.m2.4xlarge' => 68400, 'db.m2.8xlarge' => 136800
     }
     @@Disk_Lookup = {
       'm1.small' => 160, 'm1.medium' => 410, 'm1.large' =>850, 'm1.xlarge' => 1690,
@@ -180,6 +126,8 @@ module AwsPricing
       'cr1.8xlarge' => 240,
       'hs1.8xlarge' => 48000,
       'g2.2xlarge' => 60,
+      'db.m1.small' => 160, 'db.m1.medium' => 410, 'db.m1.large' =>850, 'db.m1.xlarge' => 1690,
+      'db.m2.xlarge' => 420, 'db.m2.2xlarge' => 850, 'db.m2.4xlarge' => 1690, 'db.m2.8xlarge' => 0
     }
     @@Platform_Lookup = {
       'm1.small' => 32, 'm1.medium' => 32, 'm1.large' => 64, 'm1.xlarge' => 64,
@@ -194,6 +142,8 @@ module AwsPricing
       'cr1.8xlarge' => 64,
       'hs1.8xlarge' => 64,
       'g2.2xlarge' => 64,
+      'db.m1.small' => 32, 'db.m1.medium' => 32, 'db.m1.large' => 64, 'db.m1.xlarge' => 64,
+      'db.m2.xlarge' => 64, 'db.m2.2xlarge' => 64, 'db.m2.4xlarge' => 64, 'db.m2.8xlarge' => 64
     }
     @@Compute_Units_Lookup = {
       'm1.small' => 1, 'm1.medium' => 2, 'm1.large' => 4, 'm1.xlarge' => 8,
@@ -208,6 +158,8 @@ module AwsPricing
       'hs1.8xlarge' => 35,
       'g2.2xlarge' => 26,
       'unknown' => 0,
+      'db.m1.small' => 1, 'db.m1.medium' => 2, 'db.m1.large' => 4, 'db.m1.xlarge' => 8,
+      'db.m2.xlarge' => 6, 'db.m2.2xlarge' => 13, 'db.m2.4xlarge' => 26, 'db.m2.8xlarge' => 52
     }
     @@Virtual_Cores_Lookup = {
       'm1.small' => 1, 'm1.medium' => 1, 'm1.large' => 2, 'm1.xlarge' => 4,
@@ -222,6 +174,24 @@ module AwsPricing
       'hs1.8xlarge' => 16,
       'g2.2xlarge' => 8,
       'unknown' => 0,
+      'db.m1.small' => 1, 'db.m1.medium' => 1, 'db.m1.large' => 2, 'db.m1.xlarge' => 4,
+      'db.m2.xlarge' => 2, 'db.m2.2xlarge' => 4, 'db.m2.4xlarge' => 8, 'db.m2.8xlarge' => 16
+    }
+    @@Disk_Type_Lookup = {
+      'm1.small' => :ephemeral, 'm1.medium' => :ephemeral, 'm1.large' => :ephemeral, 'm1.xlarge' => :ephemeral,
+      'm2.xlarge' => :ephemeral, 'm2.2xlarge' => :ephemeral, 'm2.4xlarge' => :ephemeral,
+      'm3.xlarge' => :ephemeral, 'm3.2xlarge' => :ephemeral,
+      'c1.medium' => :ephemeral, 'c1.xlarge' => :ephemeral,
+      'hi1.4xlarge' => :ssd,
+      'cg1.4xlarge' => :ephemeral,
+      'cc1.4xlarge' => :ephemeral, 'cc2.8xlarge' => :ephemeral,
+      't1.micro' => :ebs,
+      'cr1.8xlarge' => :ssd,
+      'hs1.8xlarge' => :ephemeral,
+      'g2.2xlarge' => :ssd,
+      'unknown' => :ephemeral,
+      'db.m1.small' => :ephemeral, 'db.m1.medium' => :ephemeral, 'db.m1.large' => :ephemeral, 'db.m1.xlarge' => :ephemeral,
+      'db.m2.xlarge' => :ephemeral, 'db.m2.2xlarge' => :ephemeral, 'db.m2.4xlarge' => :ephemeral, 'db.m2.8xlarge' => :ephemeral
     }
   end
 

data/lib/amazon-pricing/operating-system.rb

@@ -8,149 +8,6 @@
 # Home::      http://github.com/CloudHealth/amazon-pricing
 #++
 module AwsPricing
-
-  class OperatingSystem
-    attr_accessor :instance_type, :name, 
-      :ondemand_price_per_hour, :light_price_per_hour_1_year, :medium_price_per_hour_1_year, :heavy_price_per_hour_1_year,
-      :light_price_per_hour_3_year, :medium_price_per_hour_3_year, :heavy_price_per_hour_3_year,
-      :light_prepay_1_year, :light_prepay_3_year, :medium_prepay_1_year, :medium_prepay_3_year, :heavy_prepay_1_year, :heavy_prepay_3_year
-
-
-    def initialize(instance_type, name)
-      @instance_type = instance_type
-      @name = name
-    end
-
-    # Returns whether an instance_type is available. 
-    # type_of_instance = :ondemand, :light, :medium, :heavy
-    def available?(type_of_instance = :ondemand)
-      not price_per_hour(type_of_instance).nil?
-    end
-
-    # type_of_instance = :ondemand, :light, :medium, :heavy
-    # term = :year_1, :year_3, nil
-    def prepay(type_of_instance = :ondemand, term = nil)
-      case type_of_instance
-      when :ondemand
-        0
-      when :light
-        if term == :year1
-          @light_prepay_1_year
-        elsif term == :year3
-          @light_prepay_3_year
-        end
-      when :medium
-        if term == :year1
-          @medium_prepay_1_year
-        elsif term == :year3
-          @medium_prepay_3_year
-        end
-      when :heavy
-        if term == :year1
-          @heavy_prepay_1_year
-        elsif term == :year3
-          @heavy_prepay_3_year
-        end
-      end
-    end
-
-    # type_of_instance = :ondemand, :light, :medium, :heavy
-    # term = :year_1, :year_3, nil
-    def set_prepay(type_of_instance, term, price)
-      case type_of_instance
-      when :light
-        if term == :year1
-          @light_prepay_1_year = price
-        elsif term == :year3
-          @light_prepay_3_year = price
-        end
-      when :medium
-        if term == :year1
-          @medium_prepay_1_year = price
-        elsif term == :year3
-          @medium_prepay_3_year = price
-        end
-      when :heavy
-        if term == :year1
-          @heavy_prepay_1_year = price
-        elsif term == :year3
-          @heavy_prepay_3_year = price
-        end
-      end
-    end
-
-    # type_of_instance = :ondemand, :light, :medium, :heavy
-    # term = :year_1, :year_3, nil
-    def price_per_hour(type_of_instance = :ondemand, term = nil)
-      case type_of_instance
-      when :ondemand
-        @ondemand_price_per_hour
-      when :light
-        if term == :year1
-          @light_price_per_hour_1_year
-        elsif term == :year3
-          @light_price_per_hour_3_year
-        end
-      when :medium
-        if term == :year1
-          @medium_price_per_hour_1_year
-        elsif term == :year3
-          @medium_price_per_hour_3_year
-        end
-      when :heavy
-        if term == :year1
-          @heavy_price_per_hour_1_year
-        elsif term == :year3
-          @heavy_price_per_hour_3_year
-        end
-      end
-    end
-
-    # type_of_instance = :ondemand, :light, :medium, :heavy
-    # term = :year_1, :year_3, nil
-    def set_price_per_hour(type_of_instance, term, price_per_hour)
-      case type_of_instance
-      when :ondemand
-        @ondemand_price_per_hour = price_per_hour
-      when :light
-        if term == :year1
-          @light_price_per_hour_1_year = price_per_hour
-        elsif term == :year3
-          @light_price_per_hour_3_year = price_per_hour
-        end
-      when :medium
-        if term == :year1
-          @medium_price_per_hour_1_year = price_per_hour
-        elsif term == :year3
-          @medium_price_per_hour_3_year = price_per_hour
-        end
-      when :heavy
-        if term == :year1
-          @heavy_price_per_hour_1_year = price_per_hour
-        elsif term == :year3
-          @heavy_price_per_hour_3_year = price_per_hour
-        end
-      end
-    end
-
-    # type_of_instance = :ondemand, :light, :medium, :heavy
-    # term = :year_1, :year_3, nil
-    def get_breakeven_month(type_of_instance, term)
-      # Some regions and types do not have reserved available
-      ondemand_pph = price_per_hour(:ondemand)
-      reserved_pph = price_per_hour(type_of_instance, term)
-      return nil if ondemand_pph.nil? || reserved_pph.nil?
-
-      on_demand = 0
-      reserved = prepay(type_of_instance, term)
-      for i in 1..36 do
-        on_demand +=  ondemand_pph * 24 * 30.4 
-        reserved += reserved_pph * 24 * 30.4 
-        return i if reserved < on_demand
-      end
-      nil
-    end
-
+  class OperatingSystem < CategoryType
   end
-
 end

data/lib/amazon-pricing/rds-instance-type.rb

@@ -0,0 +1,89 @@
+require 'amazon-pricing/instance-type'
+module AwsPricing
+  class RdsInstanceType < InstanceType
+    # database_type = :mysql, :oracle, :sqlserver
+    # type_of_instance = :ondemand, :light, :medium, :heavy
+    def update_pricing(database_type, type_of_instance, json, isMultiAz)
+      db = get_category_type(database_type, isMultiAz)
+      if db.nil?
+        db = DatabaseType.new(self, database_type)        
+        if isMultiAz
+          @category_types["#{database_type}_multiAz"] = db
+        else
+          @category_types[database_type] = db
+        end
+      end
+
+      if type_of_instance == :ondemand
+        values = RdsInstanceType::get_values(json, database_type)
+        price = coerce_price(values[database_type.to_s])
+        db.set_price_per_hour(type_of_instance, nil, price)
+      else
+        json['valueColumns'].each do |val|
+          price = coerce_price(val['prices']['USD'])
+
+          case val["name"]
+          when "yrTerm1"
+            db.set_prepay(type_of_instance, :year1, price)
+          when "yrTerm3"
+            db.set_prepay(type_of_instance, :year3, price)
+          when "yrTerm1Hourly"
+            db.set_price_per_hour(type_of_instance, :year1, price)
+          when "yrTerm3Hourly"
+            db.set_price_per_hour(type_of_instance, :year3, price)
+          when "yearTerm1Hourly"
+            db.set_price_per_hour(type_of_instance, :year1, price)
+          when "yearTerm3Hourly"
+            db.set_price_per_hour(type_of_instance, :year3, price)  
+          end
+        end
+      end
+    end
+
+    protected 
+
+    # Returns [api_name, name]
+    def self.get_name(instance_type, size, is_reserved = false)
+      lookup = @@Api_Name_Lookup
+      lookup = @@Api_Name_Lookup_Reserved if is_reserved
+
+      # Let's handle new instances more gracefully
+      unless lookup.has_key? instance_type
+        raise UnknownTypeError, "Unknown instance type #{instance_type}", caller
+      else
+        api_name = lookup[instance_type][size]
+      end
+
+      lookup = @@Name_Lookup
+      lookup = @@Name_Lookup_Reserved if is_reserved
+      name = lookup[instance_type][size]
+
+      [api_name, name]
+    end
+
+    @@Api_Name_Lookup = {
+      'udbInstClass' => {'uDBInst'=>'db.t1.micro'},
+      'dbInstClass'=> {'uDBInst' => 'db.t1.micro', 'smDBInst' => 'db.m1.small', 'medDBInst' => 'db.m1.medium', 'lgDBInst' => 'db.m1.large', 'xlDBInst' => 'db.m1.xlarge'},
+      'hiMemDBInstClass'=> {'xlDBInst' => 'db.m2.xlarge', 'xxlDBInst' => 'db.m2.2xlarge', 'xxxxDBInst' => 'db.m2.4xlarge'},
+      'clusterHiMemDB' => {'xxxxxxxxl' => 'db.m2.8xlarge'},
+      'multiAZDBInstClass'=> {'uDBInst' => 'db.t1.micro', 'smDBInst' => 'db.m1.small', 'medDBInst' => 'db.m1.medium', 'lgDBInst' => 'db.m1.large', 'xlDBInst' => 'db.m1.xlarge'},
+      'multiAZHiMemInstClass'=> {'xlDBInst' => 'db.m2.xlarge', 'xxlDBInst' => 'db.m2.2xlarge', 'xxxxDBInst' => 'db.m2.4xlarge'},
+    }
+    @@Name_Lookup = {
+      'udbInstClass' => {'uDBInst'=>'Standard Micro'},
+      'dbInstClass'=> {'uDBInst' => 'Standard Micro', 'smDBInst' => 'Standard Small', 'medDBInst' => 'Standard Medium', 'lgDBInst' => 'Standard Large', 'xlDBInst' => 'Standard Extra Large'},
+      'hiMemDBInstClass'=> {'xlDBInst' => 'Standard High-Memory Extra Large', 'xxlDBInst' => 'Standard High-Memory Double Extra Large', 'xxxxDBInst' => 'Standard High-Memory Quadruple Extra Large'},
+      'clusterHiMemDB' => {'xxxxxxxxl' => 'Standard High-Memory Cluster Eight Extra Large'},
+      'multiAZDBInstClass'=> {'uDBInst' => 'Multi-AZ Micro', 'smDBInst' => 'Multi-AZ Small', 'medDBInst' => 'Multi-AZ Medium', 'lgDBInst' => 'Multi-AZ Large', 'xlDBInst' => 'Multi-AZ Extra Large'},
+      'multiAZHiMemInstClass'=> {'xlDBInst' => 'Multi-AZ High-Memory Extra Large', 'xxlDBInst' => 'Multi-AZ High-Memory Double Extra Large', 'xxxxDBInst' => 'Multi-AZ High-Memory Quadruple Extra Large'},
+    }
+    @@Api_Name_Lookup_Reserved = {
+      'stdDeployRes' => {'u' => 'db.t1.micro', 'micro' => 'db.t1.micro', 'sm' => 'db.m1.small', 'med' => 'db.m1.medium', 'lg' => 'db.m1.large', 'xl' => 'db.m1.xlarge', 'xlHiMem' => 'db.m2.xlarge', 'xxlHiMem' => 'db.m2.2xlarge', 'xxxxlHiMem' => 'db.m2.4xlarge', 'xxxxxxxxl' => 'db.m2.8xlarge'},
+      'multiAZdeployRes' => {'u' => 'db.t1.micro', 'micro' => 'db.t1.micro', 'sm' => 'db.m1.small', 'med' => 'db.m1.medium', 'lg' => 'db.m1.large', 'xl' => 'db.m1.xlarge', 'xlHiMem' => 'db.m2.xlarge', 'xxlHiMem' => 'db.m2.2xlarge', 'xxxxlHiMem' => 'db.m2.4xlarge', 'xxxxxxxxl' => 'db.m2.8xlarge'},
+    }
+    @@Name_Lookup_Reserved = {
+      'stdDeployRes' => {'u' => 'Standard Micro', 'micro' => 'Standard Micro', 'sm' => 'Standard Small', 'med' => 'Standard Medium', 'lg' => 'Standard Large', 'xl' => 'Standard Extra Large', 'xlHiMem' => 'Standard Extra Large High-Memory', 'xxlHiMem' => 'Standard Double Extra Large High-Memory', 'xxxxlHiMem' => 'Standard Quadruple Extra Large High-Memory', 'xxxxxxxxl' => 'Standard Eight Extra Large'}  ,
+      'multiAZdeployRes' => {'u' => 'Multi-AZ Micro', 'micro' => 'Multi-AZ Micro', 'sm' => 'Multi-AZ Small', 'med' => 'Multi-AZ Medium', 'lg' => 'Multi-AZ Large', 'xl' => 'Multi-AZ Extra Large', 'xlHiMem' => 'Multi-AZ Extra Large High-Memory', 'xxlHiMem' => 'Multi-AZ Double Extra Large High-Memory', 'xxxxlHiMem' => 'Multi-AZ Quadruple Extra Large High-Memory', 'xxxxxxxxl' => 'Multi-AZ Eight Extra Large'},
+    }
+   end
+end

data/lib/amazon-pricing/region.rb

@@ -19,35 +19,59 @@ module AwsPricing
 
     def initialize(name)
       @name = name
-      @instance_types = {}
+      @ec2_instance_types = {}
+      @rds_instance_types = {}
     end
 
-    def instance_types
-      @instance_types.values
+    def ec2_instance_types
+      @ec2_instance_types.values
+    end
+
+    def rds_instance_types
+      @rds_instance_types.values
     end
 
     # Returns whether an instance_type is available. 
     # operating_system = :linux, :mswin, :rhel, :sles, :mswinSQL, :mswinSQLWeb
     # type_of_instance = :ondemand, :light, :medium, :heavy
     def instance_type_available?(api_name, type_of_instance = :ondemand, operating_system = :linux)
-      instance = @instance_types[api_name]
+      instance = @ec2_instance_types[api_name]
       return false if instance.nil?
       instance.available?(type_of_instance, operating_system)
     end
 
     # type_of_instance = :ondemand, :light, :medium, :heavy
-    def add_or_update_instance_type(api_name, name, operating_system, type_of_instance, json)
-      current = get_instance_type(api_name)
+    def add_or_update_ec2_instance_type(api_name, name, operating_system, type_of_instance, json)
+      current = get_ec2_instance_type(api_name)
       if current.nil?
-        current = InstanceType.new(self, api_name, name)
-        @instance_types[api_name] = current
+        current = Ec2InstanceType.new(self, api_name, name)
+        @ec2_instance_types[api_name] = current
       end
       current.update_pricing(operating_system, type_of_instance, json)
       current
     end
 
+    def add_or_update_rds_instance_type(api_name, name, db_type, type_of_instance, json, isMultiAz)
+      current = get_rds_instance_type(api_name)
+      if current.nil?
+        current = RdsInstanceType.new(self, api_name, name)
+        @rds_instance_types[api_name] = current
+      end
+      current.update_pricing(db_type, type_of_instance, json, isMultiAz)
+      current
+    end
+
+    # Maintained for backward compatibility reasons (retrieves EC2 instance type)
     def get_instance_type(api_name)
-      @instance_types[api_name]
+      get_ec2_instance_type(api_name)
+    end
+
+    def get_ec2_instance_type(api_name)
+      @ec2_instance_types[api_name]
+    end
+
+    def get_rds_instance_type(api_name)
+      @rds_instance_types[api_name]
     end
 
   end

data/lib/amazon-pricing/version.rb

@@ -8,5 +8,5 @@
 # Home::      http://github.com/CloudHealth/amazon-pricing
 #++
 module AwsPricing
-  VERSION = '0.1.9'
+  VERSION = '0.1.10'
 end

data/spec/rds-amazon-pricing-spec.rb

@@ -0,0 +1,34 @@
+require 'amazon-pricing'
+
+describe AwsPricing::RdsPriceList do
+
+  before do
+          @region_name = ['us-east', 'us-west', 'us-west-2', 'eu-ireland', 'apac-sin', 'apac-syd', 'apac-tokyo', 'sa-east-1']
+          @db_types = [:mysql, :oracle, :oracle_byol, :sqlserver, :sqlserver_express, :sqlserver_web, :sqlserver_byol]
+  end
+
+  describe 'new' do
+    it 'RdsPriceList.new should return the valid response' do
+      result = AwsPricing::RdsPriceList.new
+      result.regions.each do |region|
+              # response should have valid region
+              expect(@region_name).to include(region.name)
+              # Result have valid db name
+              expect(@db_types).to include(region.rds_instance_types.first.category_types.first.name)
+              # values should not be nil
+              region.rds_instance_types.first.category_types.first.ondemand_price_per_hour.should_not be_nil
+              region.rds_instance_types.first.category_types.first.light_price_per_hour_1_year.should_not be_nil
+              region.rds_instance_types.first.category_types.first.medium_price_per_hour_1_year.should_not be_nil
+              region.rds_instance_types.first.category_types.first.heavy_price_per_hour_1_year.should_not be_nil
+      end
+    end
+  end
+
+  describe '::get_api_name' do
+    it "raises an UnknownTypeError on an unexpected instance type" do
+      expect {
+        AwsPricing::InstanceType::get_name 'QuantumODI', 'huge'
+      }.to raise_error(AwsPricing::UnknownTypeError)
+    end
+  end
+end

data/test/test-ec2-instance-types.rb

@@ -16,17 +16,17 @@ require 'test/unit'
 
 class TestEc2InstanceTypes < Test::Unit::TestCase
   def test_cc8xlarge_issue
-    pricing = AwsPricing::PriceList.new
+    pricing = AwsPricing::Ec2PriceList.new
     obj = pricing.get_instance_type('us-east', 'cc2.8xlarge')
     assert obj.api_name == 'cc2.8xlarge'
   end
 
   def test_name_lookup
-    pricing = AwsPricing::PriceList.new
+    pricing = AwsPricing::Ec2PriceList.new
     pricing.regions.each do |region|
       assert_not_nil region.name
 
-      region.instance_types.each do |instance|
+      region.ec2_instance_types.each do |instance|
         assert_not_nil(instance.api_name)
         assert_not_nil(instance.name)
       end
@@ -43,15 +43,15 @@ class TestEc2InstanceTypes < Test::Unit::TestCase
 
   def test_available
     # Validate instance types in specific regions are available
-    pricing = AwsPricing::PriceList.new
+    pricing = AwsPricing::Ec2PriceList.new
     region = pricing.get_region('us-east')
     assert region.instance_type_available?('m1.large')
   end
 
   def test_fetch_all_breakeven_months
-    pricing = AwsPricing::PriceList.new
+    pricing = AwsPricing::Ec2PriceList.new
     pricing.regions.each do |region|
-      region.instance_types.each do |instance|
+      region.ec2_instance_types.each do |instance|
         instance.operating_systems.each do |os|
           [:light, :medium, :heavy].each do |res_type|
             next if not instance.available?(res_type)
@@ -64,30 +64,30 @@ class TestEc2InstanceTypes < Test::Unit::TestCase
   end
 
   def test_breakeven_month
-    pricing = AwsPricing::PriceList.new
+    pricing = AwsPricing::Ec2PriceList.new
     region = pricing.get_region('us-east')
-    instance = region.get_instance_type('m1.large')
+    instance = region.get_ec2_instance_type('m1.large')
     bem = instance.get_breakeven_month(:linux, :heavy, :year1)
     assert bem == 6
   end
 
   def test_memory
     # Validate instance types in specific regions are available
-    pricing = AwsPricing::PriceList.new
+    pricing = AwsPricing::Ec2PriceList.new
     region = pricing.get_region('us-east')
-    instance = region.get_instance_type('m1.large')
+    instance = region.get_ec2_instance_type('m1.large')
     assert instance.memory_in_mb == 7500
   end
 
   def test_non_standard_region_name
-    pricing = AwsPricing::PriceList.new
+    pricing = AwsPricing::Ec2PriceList.new
     region = pricing.get_region('eu-west-1')
-    instance = region.get_instance_type('m1.large')
+    instance = region.get_ec2_instance_type('m1.large')
     assert instance.memory_in_mb == 7500
   end
 
   def test_ebs
-    pricing = AwsPricing::PriceList.new
+    pricing = AwsPricing::Ec2PriceList.new
     region = pricing.get_region('us-east')
     assert region.ebs_price.standard_per_gb == 0.10
     assert region.ebs_price.standard_per_million_io == 0.10
@@ -97,7 +97,7 @@ class TestEc2InstanceTypes < Test::Unit::TestCase
   end
 
   def test_ebs_not_null
-    pricing = AwsPricing::PriceList.new
+    pricing = AwsPricing::Ec2PriceList.new
     pricing.regions.each do |region|
       # Everyone should have standard pricing
       assert_not_nil region.ebs_price.standard_per_gb
@@ -107,9 +107,9 @@ class TestEc2InstanceTypes < Test::Unit::TestCase
   end
 
   def test_virtual_cores
-    pricing = AwsPricing::PriceList.new
+    pricing = AwsPricing::Ec2PriceList.new
     region = pricing.get_region('us-east')
-    instance = region.get_instance_type('m1.large')
+    instance = region.get_ec2_instance_type('m1.large')
     assert instance.virtual_cores == 2
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: amazon-pricing
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
   prerelease: 
 platform: ruby
 authors:
@@ -27,13 +27,18 @@ files:
 - Rakefile
 - amazon-pricing.gemspec
 - lib/amazon-pricing.rb
+- lib/amazon-pricing/category-type.rb
+- lib/amazon-pricing/database-type.rb
 - lib/amazon-pricing/ebs-price.rb
+- lib/amazon-pricing/ec2-instance-type.rb
 - lib/amazon-pricing/instance-type.rb
 - lib/amazon-pricing/operating-system.rb
+- lib/amazon-pricing/rds-instance-type.rb
 - lib/amazon-pricing/region.rb
 - lib/amazon-pricing/version.rb
 - spec/instance_type_spec.rb
 - spec/price_list_spec.rb
+- spec/rds-amazon-pricing-spec.rb
 - test/helper.rb
 - test/test-ec2-instance-types.rb
 homepage: http://github.com/CloudHealth/amazon-pricing
@@ -69,6 +74,7 @@ summary: Amazon Web Services Pricing Ruby gem
 test_files:
 - spec/instance_type_spec.rb
 - spec/price_list_spec.rb
+- spec/rds-amazon-pricing-spec.rb
 - test/helper.rb
 - test/test-ec2-instance-types.rb
 has_rdoc: