fog 0.11.0 → 1.0.0

data/lib/fog/vmfusion/models/compute/servers.rb

@@ -0,0 +1,37 @@
+require 'fog/core/collection'
+require 'fog/vmfusion/models/compute/server'
+
+module Fog
+  module Compute
+    class Vmfusion
+
+      class Servers < Fog::Collection
+
+        model Fog::Compute::Vmfusion::Server
+
+        def all(filter=nil)
+
+          data=[]
+
+          filter={} if filter.nil?
+          unless filter.has_key?(:name)
+            vms=::Fission::VM.all
+            vms.each do |vm|
+              data << { :raw => vm}
+            end
+          else
+            data << { :raw => ::Fission::VM.new(filter[:name])}
+          end
+
+          load(data)
+
+        end
+
+        def get(name)
+          self.all(:name =>name).first
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/voxel.rb

@@ -0,0 +1,16 @@
+require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
+require 'digest/md5'
+
+module Fog
+  module Voxel
+
+    extend Fog::Provider
+
+    service(:compute, 'voxel/compute', 'Compute')
+
+    def self.create_signature(secret, options)
+      to_sign = options.keys.map { |k| k.to_s }.sort.map { |k| "#{k}#{options[k.to_sym]}" }.join("")
+      Digest::MD7.hexdigest( secret + to_sign )
+    end
+  end
+end

data/lib/fog/voxel/compute.rb

@@ -0,0 +1,125 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'voxel'))
+require 'fog/compute'
+
+module Fog
+  module Compute
+    class Voxel < Fog::Service
+
+      requires :voxel_api_key, :voxel_api_secret
+      recognizes :host, :port, :scheme, :persistent
+
+      model_path 'fog/voxel/models/compute'
+      model       :image
+      collection  :images
+      model       :server
+      collection  :servers
+
+      request_path 'fog/voxel/requests/compute'
+      request :images_list
+      request :devices_list
+      request :devices_power
+      request :voxcloud_create
+      request :voxcloud_status
+      request :voxcloud_delete
+
+      class Mock
+        include Collections
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :last_modified => { :servers => {}, :statuses => {}, :images => {} },
+              :servers => [],
+              :statuses => {},
+              :images  => [
+                {'id' => 1,   'name' => "CentOS 4, 32-bit, base install"},
+                {'id' => 2,   'name' => "CentOS 4, 64-bit, base install"},
+                {'id' => 3,   'name' => "CentOS 5, 32-bit, base install"},
+                {'id' => 4,   'name' => "CentOS 5, 64-bit, base install"},
+                {'id' => 7,   'name' => "Fedora 10, 32-bit, base install"},
+                {'id' => 8,   'name' => "Fedora 10, 64-bit, base install"},
+                {'id' => 10,  'name' => "OpenSUSE 11, 64-bit, base install"},
+                {'id' => 11,  'name' => "Debian 5.0 \"lenny\", 32-bit, base install"},
+                {'id' => 12,  'name' => "Debian 5.0 \"lenny\", 64-bit, base install"},
+                {'id' => 13,  'name' => "Ubuntu 8.04 \"Hardy\", 32-bit, base install"},
+                {'id' => 14,  'name' => "Ubuntu 8.04 \"Hardy\", 64-bit, base install"},
+                {'id' => 15,  'name' => "Voxel Server Environment (VSE), 32-bit, base install"},
+                {'id' => 16,  'name' => "Voxel Server Environment (VSE), 64-bit, base install"},
+                {'id' => 32,  'name' => "Pantheon Official Mercury Stack for Drupal (based on VSE/64)"},
+                {'id' => 55,  'name' => "Ubuntu 10.04 \"Lucid\", 64-bit, base install"} ]
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          @voxel_api_key = options[:voxel_api_key]
+        end
+
+        def data
+          self.class.data[@voxel_api_key]
+        end
+
+        def reset_data
+          self.class.data.delete(@voxel_api_key)
+        end
+
+      end
+
+      class Real
+        include Collections
+
+        def initialize(options = {})
+          require 'time'
+          require 'digest/md5'
+
+          @voxel_api_key = options[:voxel_api_key]
+          @voxel_api_secret = options[:voxel_api_secret]
+
+          @connection_options = options[:connection_options] || {}
+          @host               = options[:host]    || "api.voxel.net"
+          @port               = options[:port]    || 443
+          @scheme             = options[:scheme]  || 'https'
+          @persistent         = options[:persistent] || false
+
+          Excon.ssl_verify_peer = false
+
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+        end
+
+        def request(method_name, options = {})
+          begin
+            parser = options.delete(:parser)
+            options.merge!({ :method => method_name, :timestamp => Time.now.xmlschema, :key => @voxel_api_key })
+            options[:api_sig] = create_signature(@voxel_api_secret, options)
+            data = @connection.request(
+              :method => "POST",
+              :query  => options,
+              :parser => parser,
+              :path   => "/version/1.0/"
+            )
+            unless data.body['stat'] == 'ok'
+              raise Fog::Compute::Voxel::Error, "#{data.body['err']['msg']}"
+            end
+            data
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Compute::Voxel::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+        end
+
+        def create_signature(secret, options)
+          to_sign = options.keys.map { |k| k.to_s }.sort.map { |k| "#{k}#{options[k.to_sym]}" }.join("")
+          Digest::MD5.hexdigest( secret + to_sign )
+        end
+      end
+    end
+  end
+end

data/lib/fog/voxel/models/compute/images.rb

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/voxel/models/compute/image'
+
+module Fog
+  module Compute
+    class Voxel
+
+      class Images < Fog::Collection
+
+        model Fog::Compute::Voxel::Image
+
+        def all
+          data = connection.images_list.body['images']
+          load(data)
+        end
+
+        def get(image_id)
+          data = connection.images_list(image_id).body['images']
+
+          if data.empty?
+            nil
+          else
+            new(data.first)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/voxel/models/compute/servers.rb

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/voxel/models/compute/server'
+
+module Fog
+  module Compute
+    class Voxel
+      class Servers < Fog::Collection
+
+        model Fog::Compute::Voxel::Server
+
+        def all
+          data = connection.devices_list.body['devices'].select {|device| device['type']['id'] == '3'}
+          load(data)
+        end
+
+        def get(device_id)
+          if device_id && server = connection.devices_list(device_id).body['devices']
+            new(server.first)
+          end
+        rescue Fog::Service::Error => error
+          if error.message == "The device_id passed in can't be matched to a valid device."
+            nil
+          else
+            raise error
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/voxel/requests/compute/devices_list.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Voxel
+      class Real
+
+        require 'fog/voxel/parsers/compute/devices_list'
+
+        def devices_list(device_id = nil)
+          options = {
+            :parser     => Fog::Parsers::Compute::Voxel::DevicesList.new,
+            :verbosity  => 'normal'
+          }
+
+          unless device_id.nil?
+            options[:device_id] = device_id
+          end
+
+          request("voxel.devices.list", options)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/voxel/requests/compute/devices_power.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Voxel
+      class Real
+
+        require 'fog/voxel/parsers/compute/basic'
+
+        def devices_power(device_id, power_action)
+          options = {
+            :device_id    => device_id,
+            :parser       => Fog::Parsers::Compute::Voxel::Basic.new,
+            :power_action => power_action,
+            :verbosity    => 'normal'
+          }
+
+          request("voxel.devices.power", options)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/voxel/requests/compute/images_list.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Voxel
+      class Real
+
+        require 'fog/voxel/parsers/compute/images_list'
+
+        def images_list(image_id = nil)
+          options = {
+            :parser     => Fog::Parsers::Compute::Voxel::ImagesList.new,
+            :verbosity  => 'compact'
+          }
+
+          unless image_id.nil?
+            options[:verbosity] = 'extended'
+            options[:image_id] = image_id
+          end
+
+          data = request("voxel.images.list", options)
+
+          if data.body['stat'] == "ok"
+            data
+          else
+            raise Fog::Compute::Voxel::NotFound
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/voxel/requests/compute/voxcloud_create.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Voxel
+      class Real
+
+        require 'fog/voxel/parsers/compute/voxcloud_create'
+
+        def voxcloud_create(options)
+          options[:parser] = Fog::Parsers::Compute::Voxel::VoxcloudCreate.new
+
+          if options.has_key?(:password)
+            options[:admin_password] = options[:password]
+            options.delete(:password)
+          end
+
+          request("voxel.voxcloud.create", options)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/voxel/requests/compute/voxcloud_delete.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Compute
+    class Voxel
+      class Real
+
+        require 'fog/voxel/parsers/compute/voxcloud_delete'
+
+        def voxcloud_delete(device_id)
+          options = {
+            :device_id  => device_id,
+            :parser     => Fog::Parsers::Compute::Voxel::VoxcloudDelete.new
+          }
+
+          request("voxel.voxcloud.delete", options)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/voxel/requests/compute/voxcloud_status.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Voxel
+      class Real
+
+        require 'fog/voxel/parsers/compute/voxcloud_status'
+
+        def voxcloud_status(device_id = nil)
+          options = {
+            :parser     => Fog::Parsers::Compute::Voxel::VoxcloudStatus.new,
+            :verbosity  => 'compact'
+          }
+
+          unless device_id.nil?
+            options[:device_id] = device_id
+          end
+
+          request("voxel.voxcloud.status", options)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/vsphere.rb

@@ -0,0 +1,17 @@
+require 'fog/core'
+
+module Fog
+  module Vsphere
+
+    extend Fog::Provider
+
+    module Errors
+      class ServiceError < Fog::Errors::Error; end
+      class SecurityError < ServiceError; end
+      class NotFound < ServiceError; end
+    end
+
+    service(:compute, 'vsphere/compute', 'Compute')
+
+  end
+end

data/lib/fog/vsphere/compute.rb

@@ -0,0 +1,158 @@
+require 'digest/sha2'
+
+module Fog
+  module Compute
+    class Vsphere < Fog::Service
+
+      requires :vsphere_username, :vsphere_password, :vsphere_server
+      recognizes :vsphere_port, :vsphere_path, :vsphere_ns
+      recognizes :vsphere_rev, :vsphere_ssl, :vsphere_expected_pubkey_hash
+
+      model_path 'fog/vsphere/models/compute'
+      model :server
+      collection :servers
+
+      request_path 'fog/vsphere/requests/compute'
+      request :current_time
+      request :find_vm_by_ref
+      request :list_virtual_machines
+      request :vm_power_off
+      request :vm_power_on
+      request :vm_reboot
+      request :vm_clone
+      request :vm_destroy
+
+      module Shared
+
+        attr_reader :vsphere_is_vcenter
+        attr_reader :vsphere_rev
+        attr_reader :vsphere_server
+        attr_reader :vsphere_username
+
+        # Utility method to convert a VMware managed object into an attribute hash.
+        # This should only really be necessary for the real class.
+        # This method is expected to be called by the request methods
+        # in order to massage VMware Managed Object References into Attribute Hashes.
+        def convert_vm_mob_ref_to_attr_hash(vm_mob_ref)
+          return nil unless vm_mob_ref
+          # A cloning VM doesn't have a configuration yet.  Unfortuantely we just get
+          # a RunTime exception.
+          begin
+            is_ready = vm_mob_ref.config ? true : false
+          rescue RuntimeError
+            is_ready = nil
+          end
+          {
+            'id'               => is_ready ? vm_mob_ref.config.instanceUuid : vm_mob_ref._ref,
+            'mo_ref'           => vm_mob_ref._ref,
+            'name'             => vm_mob_ref.name,
+            'uuid'             => is_ready ? vm_mob_ref.config.uuid : nil,
+            'instance_uuid'    => is_ready ? vm_mob_ref.config.instanceUuid : nil,
+            'hostname'         => vm_mob_ref.summary.guest.hostName,
+            'operatingsystem'  => vm_mob_ref.summary.guest.guestFullName,
+            'ipaddress'        => vm_mob_ref.summary.guest.ipAddress,
+            'power_state'      => vm_mob_ref.runtime.powerState,
+            'connection_state' => vm_mob_ref.runtime.connectionState,
+            'hypervisor'       => vm_mob_ref.runtime.host ? vm_mob_ref.runtime.host.name : nil,
+            'tools_state'      => vm_mob_ref.summary.guest.toolsStatus,
+            'tools_version'    => vm_mob_ref.summary.guest.toolsVersionStatus,
+            'mac_addresses'    => is_ready ? vm_mob_ref.macs : nil,
+            'is_a_template'    => is_ready ? vm_mob_ref.config.template : nil
+          }
+        end
+
+      end
+
+      class Mock
+
+        include Shared
+
+        def initialize(options={})
+          @vsphere_username = options[:vsphere_username]
+          @vsphere_password = 'REDACTED'
+          @vsphere_server   = options[:vsphere_server]
+          @vsphere_expected_pubkey_hash = options[:vsphere_expected_pubkey_hash]
+          @vsphere_is_vcenter = true
+          @vsphere_rev = '4.0'
+        end
+
+      end
+
+      class Real
+
+        include Shared
+
+        def initialize(options={})
+          require 'rbvmomi'
+          @vsphere_username = options[:vsphere_username]
+          @vsphere_password = options[:vsphere_password]
+          @vsphere_server   = options[:vsphere_server]
+          @vsphere_port     = options[:vsphere_port] || 443
+          @vsphere_path     = options[:vsphere_path] || '/sdk'
+          @vsphere_ns       = options[:vsphere_ns] || 'urn:vim25'
+          @vsphere_rev      = options[:vsphere_rev] || '4.0'
+          @vsphere_ssl      = options[:vsphere_ssl] || true
+          @vsphere_expected_pubkey_hash = options[:vsphere_expected_pubkey_hash]
+          @vsphere_must_reauthenticate = false
+
+          @connection = nil
+          # This is a state variable to allow digest validation of the SSL cert
+          bad_cert = false
+          loop do
+            begin
+              @connection = RbVmomi::VIM.new :host => @vsphere_server,
+                                             :port => @vsphere_port,
+                                             :path => @vsphere_path,
+                                             :ns   => @vsphere_ns,
+                                             :rev  => @vsphere_rev,
+                                             :ssl  => @vsphere_ssl,
+                                             :insecure => bad_cert
+              break
+            rescue OpenSSL::SSL::SSLError
+              raise if bad_cert
+              bad_cert = true
+            end
+          end
+
+          if bad_cert then
+            validate_ssl_connection
+          end
+
+          # Negotiate the API revision
+          if not options[:vsphere_rev]
+            rev = @connection.serviceContent.about.apiVersion
+            @connection.rev = [ rev, ENV['FOG_VSPHERE_REV'] || '4.1' ].min
+          end
+
+          @vsphere_is_vcenter = @connection.serviceContent.about.apiType == "VirtualCenter"
+          @vsphere_rev = @connection.rev
+
+          authenticate
+        end
+
+        private
+
+        def authenticate
+          begin
+            @connection.serviceContent.sessionManager.Login :userName => @vsphere_username,
+                                                            :password => @vsphere_password
+          rescue RbVmomi::VIM::InvalidLogin => e
+            raise Fog::Vsphere::Errors::ServiceError, e.message
+          end
+        end
+
+        # Verify a SSL certificate based on the hashed public key
+        def validate_ssl_connection
+          pubkey = @connection.http.peer_cert.public_key
+          pubkey_hash = Digest::SHA2.hexdigest(pubkey.to_s)
+          expected_pubkey_hash = @vsphere_expected_pubkey_hash
+          if pubkey_hash != expected_pubkey_hash then
+            raise Fog::Vsphere::Errors::SecurityError, "The remote system presented a public key with hash #{pubkey_hash} but we're expecting a hash of #{expected_pubkey_hash || '<unset>'}.  If you are sure the remote system is authentic set vsphere_expected_pubkey_hash: <the hash printed in this message> in ~/.fog"
+          end
+        end
+
+      end
+
+    end
+  end
+end