fog 1.2.0 → 1.3.0

data/lib/fog/ibm.rb

@@ -0,0 +1,176 @@
+require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
+
+module Fog
+  module IBM
+
+    extend Fog::Provider
+
+    service(:compute, 'ibm/compute', 'Compute')
+    service(:storage, 'ibm/storage', 'Storage')
+
+    # Provisioning is very slow. We'll pass this arg explicitly until there's a way
+    # to set the default timeout on a per-provider basis.
+    TIMEOUT = 1800
+
+    class Connection < Fog::Connection
+
+      ENDPOINT = 'https://www-147.ibm.com/computecloud/enterprise/api/rest/20100331'
+
+      def initialize(user, password)
+        require 'multi_json'
+        @user = user
+        @password = password
+        @endpoint = URI.parse(ENDPOINT)
+        @base_path = @endpoint.path
+        super("#{@endpoint.scheme}://#{@endpoint.host}:#{@endpoint.port}")
+      end
+
+      def request(options)
+        options[:path] = @base_path + options[:path]
+        options[:headers] ||= {}
+        options[:headers]['Authorization'] = auth_header
+        options[:headers]['Accept'] = 'application/json'
+        options[:headers]['Accept-Encoding'] = 'gzip'
+        unless options[:body].nil?
+          options[:headers]['Content-Type'] = 'application/x-www-form-urlencoded'
+          options[:body] = form_encode(options[:body])
+        end
+        response = super(options)
+        unless response.body.empty?
+          response.body = MultiJson.decode(response.body)
+        end
+        response
+      end
+
+      def auth_header
+        @auth_header ||= 'Basic ' + Base64.encode64("#{@user}:#{@password}").gsub("\n",'')
+      end
+
+      def form_encode(params)
+        params.reject {|k, v| v.nil? }.map {|pair| pair.map {|x| URI.escape(x.to_s) }.join('=') }.join('&')
+      end
+    end
+
+    class Mock
+      class << self
+
+        def id
+          Fog::Mock.random_numbers(7).to_i.to_s
+        end
+        alias :instance_id :id
+        alias :request_id  :id
+
+        def primary_ip
+          { "type" => 0, "ip" => Fog::IBM::Mock.ip_address, "hostname" => Fog::IBM::Mock.hostname }
+        end
+
+        def ip_address
+          ip = []
+          4.times do
+            ip << Fog::Mock.random_numbers(rand(3) + 1).to_i.to_s # remove leading 0
+          end
+          ip.join('.')
+        end
+
+        def hostname
+          "vhost" + Fog::Mock.random_numbers(3).to_i.to_s + ".fake.compute.ihost.com"
+        end
+
+        # Miliseconds since epoch
+        def launch_time
+          (Time.now.tv_sec * 1000).to_i
+        end
+
+        # 1 year from now, in miliseconds since epoch
+        def expiry_time
+          ((Time.now.tv_sec + 31556926) * 1000).to_i
+        end
+
+        def owner
+          "user" + Fog::Mock.random_numbers(3).to_i.to_s + "@company.com"
+        end
+
+        def key_material
+          OpenSSL::PKey::RSA.generate(1024)
+        end
+
+        def private_image(name, description)
+          {
+            "name"        => name,
+            "createdTime" => Fog::IBM::Mock.launch_time,
+            "productCodes"=> [],
+            "id"          => Fog::IBM::Mock.instance_id,
+            "description" => description,
+            "visibility"  => "PRIVATE",
+            "state"       => 0
+          }
+        end
+
+        def create_instance(name, image_id, instance_type, location, options)
+          {
+            "name"          => name,
+            "location"      => location,
+            "keyName"       => options[:key_name],
+            "primaryIP"     => Fog::IBM::Mock.primary_ip,
+            "productCodes"  => [],
+            "requestId"     => Fog::IBM::Mock.request_id,
+            "imageId"       => image_id,
+            "launchTime"    => Fog::IBM::Mock.launch_time,
+            "id"            => Fog::IBM::Mock.instance_id,
+            "volumes"       => [],
+            "isMiniEphemeral" => "false",
+            "instanceType"  => instance_type,
+            "diskSize"      => "60",
+            "requestName"   => "",
+            "secondaryIP"   => [],
+            "status"        => 1,
+            "software"      => [
+              { "name"=>"SUSE Linux Enterprise Server",
+                "type"=>"OS",
+                "version"=>"11 SP1" }
+            ],
+            "expirationTime"=> Fog::IBM::Mock.expiry_time,
+            "owner"         => Fog::IBM::Mock.owner
+          }
+        end
+
+        def create_volume(name, format, location_id, size, offering_id)
+          {
+            "instanceId"  => "0",
+            "state"       => 1,
+            "size"        => size,
+            "offeringId"  => offering_id,
+            "ioPrice" => {
+              "rate"  => 0.11,
+              "unitOfMeasure" => "CNT",
+              "countryCode"   => "897",
+              "effectiveDate" => Fog::IBM::Mock.launch_time,
+              "currencyCode"  => "USD",
+              "pricePerQuantity"  => 1
+            },
+            "owner"       => Fog::IBM::Mock.owner,
+            "createdTime" => Fog::IBM::Mock.launch_time,
+            "location"    => location_id,
+            "productCodes"=> [],
+            "format"      => format,
+            "name"        => name,
+            "id"          => Fog::IBM::Mock.id,
+          }
+        end
+
+        def create_address(location_id, offering_id, vlan_id)
+          # TODO: Figure out vlan handling
+          {
+            "id"        => Fog::IBM::Mock.id,
+            "location"  => location_id,
+            "offeringId"=> offering_id,
+            "ip"        => "",
+            "state"     => 0
+          }
+        end
+
+      end
+    end
+
+  end
+end

data/lib/fog/ibm/compute.rb

@@ -0,0 +1,233 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'ibm'))
+require 'fog/compute'
+
+module Fog
+  module Compute
+    class IBM < Fog::Service
+
+      requires :ibm_username, :ibm_password
+      recognizes :location
+
+      model_path 'fog/ibm/models/compute'
+
+      model :image
+      collection :images
+      model :server
+      collection :servers
+      model :address
+      collection :addresses
+      model :key
+      collection :keys
+      model :location
+      collection :locations
+
+      request_path 'fog/ibm/requests/compute'
+
+      request :list_images
+      request :create_image
+      request :clone_image
+      request :delete_image
+      request :get_image
+      request :get_image_agreement
+      request :get_image_manifest
+      # request :get_image_swbundles
+      # request :get_image_swbundle
+
+      request :list_instances
+      request :create_instance
+      request :delete_instance
+      request :modify_instance
+      request :get_instance
+      request :get_instance_logs
+      # request :get_instance_swbundle
+
+      request :get_request
+
+      request :list_addresses
+      request :list_address_offerings
+      request :list_vlans
+      request :create_address
+      request :delete_address
+
+      request :list_keys
+      request :create_key
+      request :delete_key
+      request :modify_key
+      request :get_key
+
+      request :list_locations
+      request :get_location
+
+      class Real
+        def initialize(options={})
+          @connection = Fog::IBM::Connection.new(options[:ibm_username], options[:ibm_password])
+        end
+
+        private
+
+        def request(options)
+          begin
+            @connection.request(options)
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Compute::IBM::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+        end
+      end
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :instances    => {},
+              :images       => populate_images,
+              :keys         => {},
+              :locations    => populate_locations,
+              :private_keys => {},
+              :addresses    => {}
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def data
+          self.class.data[@ibm_username]
+        end
+
+        def reset_data
+          self.class.data.delete(@ibm_username)
+          @data = self.class.data[@ibm_username]
+        end
+
+        def initialize(options={})
+          @ibm_username = options[:ibm_username]
+          @ibm_password = options[:ibm_password]
+          @data = self.class.data[@ibm_username]
+        end
+
+        def self.populate_images
+          images = {}
+          images["20010001"] = {
+            "name"=>"SUSE Linux Enterprise Server 11 SP1 for x86",
+            "manifest"=>"https://www-147.ibm.com/cloud/enterprise/ram.ws/RAMSecure/artifact/{6CD09CE4-E99B-D72F-6C29-233C9B2A1676}/1.0/parameters.xml",
+            "state"=>1,
+            "visibility"=>"PUBLIC",
+            "owner"=>"SYSTEM",
+            "platform"=>"SUSE Linux Enterprise Server/11 SP1",
+            "location"=>"41",
+            "createdTime"=>1282466781000,
+            "supportedInstanceTypes"=>
+            [{"detail"=>"Copper - 32 bit (vCPU: 1, RAM: 2 GiB, Disk: 60 GiB)",
+               "label"=>"Copper 32 bit",
+               "price"=>{"rate"=>0.095, "unitOfMeasure"=>"UHR  ", "countryCode"=>"897", "effectiveDate"=>-1, "currencyCode"=>"USD", "pricePerQuantity"=>1},
+               "id"=>"COP32.1/2048/60"},
+             {"detail"=>"Bronze - 32 bit (vCPU: 1, RAM: 2 GiB, Disk: 235 GiB)",
+               "label"=>"Bronze 32 bit",
+               "price"=>{"rate"=>0.115, "unitOfMeasure"=>"UHR  ", "countryCode"=>"897", "effectiveDate"=>-1, "currencyCode"=>"USD", "pricePerQuantity"=>1},
+               "id"=>"BRZ32.1/2048/60*175"},
+             {"detail"=>"Silver - 32 bit (vCPU: 2, RAM: 4 GiB, Disk: 410 GiB)",
+               "label"=>"Silver 32 bit",
+               "price"=>{"rate"=>0.2, "unitOfMeasure"=>"UHR  ", "countryCode"=>"897", "effectiveDate"=>-1, "currencyCode"=>"USD", "pricePerQuantity"=>1},
+               "id"=>"SLV32.2/4096/60*350"},
+             {"detail"=>"Gold - 32 bit (vCPU: 4, RAM: 4 GiB, Disk: 410 GiB)",
+               "label"=>"Gold 32 bit",
+               "price"=>{"rate"=>0.33, "unitOfMeasure"=>"UHR  ", "countryCode"=>"897", "effectiveDate"=>-1, "currencyCode"=>"USD", "pricePerQuantity"=>1},
+               "id"=>"GLD32.4/4096/60*350"}],
+            "productCodes"=>["rtpSr7dKs9ARDmuPy6WPgV"],
+            "documentation"=>"https://www-147.ibm.com/cloud/enterprise/ram.ws/RAMSecure/artifact/{6CD09CE4-E99B-D72F-6C29-233C9B2A1676}/1.0/GettingStarted.html",
+            "id"=>"20010001",
+            "description"=>"Suse Linux 32 bit"
+          }
+          images
+        end
+
+        def self.populate_locations
+          locations = {}
+          locations["41"] = {
+            "state"=>1,
+            "location"=>"RTP",
+            "capabilities"=>[
+              {"entries"=>{"EXT3"=>["ext3"], "RAW"=>["raw"]}, "id"=>"oss.storage.format"},
+              {"entries"=>{}, "id"=>"oss.instance.spec.i386"},
+              {"entries"=>{}, "id"=>"oss.instance.spec.x86_64"},
+              {"entries"=>{}, "id"=>"oss.storage.availabilityarea"}],
+            "name"=>"Raleigh, U.S.A",
+            "id"=>"41",
+            "description"=>"This data center is located in Raleigh, North Carolina, U.S.A. The services provided are: Guest Instances, Image Capture, Persistent Storage, Reserved IP, Private VLAN/VPN."
+          }
+          locations["61"] = {
+            "state"=>1,
+            "location"=>"EHN",
+            "capabilities"=>[
+              {"entries"=>{"EXT3"=>["ext3"], "RAW"=>["raw"]}, "id"=>"oss.storage.format"},
+              {"entries"=>{}, "id"=>"oss.instance.spec.i386"},
+              {"entries"=>{}, "id"=>"oss.instance.spec.x86_64"},
+              {"entries"=>{}, "id"=>"oss.storage.availabilityarea"}],
+            "name"=>"Ehningen, Germany",
+            "id"=>"61",
+            "description"=>"This data center is located in Ehningen(near Baden-Wurttemberg), Germany. The services provided are: Guest Instances, Image Capture, Persistent Storage, Reserved IP, Private VLAN/VPN."
+          }
+          locations["82"] = {
+            "state"=>1,
+            "location"=>"us-co-dc1",
+            "capabilities"=>[
+              {"entries"=>{"EXT3"=>["ext3"], "RAW"=>["raw"]}, "id"=>"oss.storage.format"},
+              {"entries"=>{}, "id"=>"oss.instance.spec.i386"},
+              {"entries"=>{}, "id"=>"oss.instance.spec.x86_64"},
+              {"entries"=>{}, "id"=>"oss.storage.availabilityarea"}],
+            "name"=>"Boulder1, U.S.A",
+            "id"=>"82",
+            "description"=>"This data center is located in Boulder(near Denver), Colorado, U.S.A. The services provided are: Guest Instances, Image Capture, Persistent Storage, Reserved IP, Private VLAN/VPN."
+          }
+          locations["101"] = {
+            "state"=>1,
+            "location"=>"ca-on-dc1",
+            "capabilities"=>[
+              {"entries"=>{"EXT3"=>["ext3"], "RAW"=>["raw"]}, "id"=>"oss.storage.format"},
+              {"entries"=>{}, "id"=>"oss.instance.spec.i386"},
+              {"entries"=>{}, "id"=>"oss.instance.spec.x86_64"},
+              {"entries"=>{}, "id"=>"oss.storage.availabilityarea"}],
+            "name"=>"Markham, Canada",
+            "id"=>"101",
+            "description"=>"This data center is located in Markham(near Toronto), Ontario, Canada. The services provided are: Guest Instances, Image Capture, Persistent Storage, Reserved IP, Private VLAN/VPN."
+          }
+          locations["121"] = {
+            "state"=>1,
+            "location"=>"ap-jp-dc1",
+            "capabilities"=>[
+              {"entries"=>{"EXT3"=>["ext3"], "RAW"=>["raw"]}, "id"=>"oss.storage.format"},
+              {"entries"=>{}, "id"=>"oss.instance.spec.i386"},
+              {"entries"=>{}, "id"=>"oss.instance.spec.x86_64"},
+              {"entries"=>{}, "id"=>"oss.storage.availabilityarea"}],
+            "name"=>"Makuhari, Japan",
+            "id"=>"121",
+            "description"=>"This data center is located in Makuhari(near Tokoyo), Japan. The services provided are: Guest Instances, Image Capture, Persistent Storage, Reserved IP, Private VLAN/VPN."
+          }
+          locations["141"] = {
+            "state"=>1,
+            "location"=>"ap-sg-dc1",
+            "capabilities"=>[
+              {"entries"=>{"EXT3"=>["ext3"], "RAW"=>["raw"]}, "id"=>"oss.storage.format"},
+              {"entries"=>{}, "id"=>"oss.instance.spec.i386"},
+              {"entries"=>{}, "id"=>"oss.instance.spec.x86_64"},
+              {"entries"=>{}, "id"=>"oss.storage.availabilityarea"}],
+            "name"=>"Singapore, Singapore",
+            "id"=>"141",
+            "description"=>"This data center is located in Singapore. The services provided are: Guest Instances, Image Capture, Persistent Storage, Reserved IP, Private VLAN/VPN."
+          }
+          locations
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class IBM
+      class Address < Fog::Model
+
+        STATES = {
+          0 => 'New',
+          1 => 'Allocating',
+          2 => 'Free',
+          3 => 'Attached',
+          4 => 'Releasing',
+          5 => 'Released',
+          6 => 'Failed',
+          7 => 'Release pending',
+        }
+
+        identity :id
+
+        attribute :type
+        attribute :location
+        attribute :ip
+        attribute :state
+        attribute :instance_id, :aliases => 'instanceId'
+        attribute :offering_id, :aliases => 'offeringId'
+        attribute :vlan_id, :aliases => 'vlanId'
+        attribute :hostname
+        attribute :mode
+        attribute :owner
+
+        def initialize(new_attributes={})
+          super(new_attributes)
+          self.offering_id ||= '20001223'
+          self.location ||= '82'
+        end
+
+        def save
+          requires :offering_id, :location
+          data = connection.create_address(location, offering_id,
+                                           :vlan_id => vlan_id,
+                                           :ip => ip)
+          merge_attributes(data.body)
+          true
+        end
+
+        def state
+          STATES[attributes[:state]]
+        end
+
+        def ready?
+          state == 'Free' || state == 'Released'
+        end
+
+        def destroy
+          requires :id
+          connection.delete_address(id).body['success']
+        end
+      end
+    end
+  end
+end