fog 0.6.0 → 0.7.0

data/lib/fog/compute/models/virtual_box/medium_format.rb

@@ -0,0 +1,34 @@
+require 'fog/core/model'
+
+module Fog
+  module VirtualBox
+    class Compute
+
+      class MediumFormat < Fog::Model
+
+        identity :id
+
+        # attribute :capabilities
+        attribute :name
+
+        private
+
+        def raw
+          @raw
+        end
+        
+        def raw=(new_raw)
+          @raw = new_raw
+          raw_attributes = {}
+          for key in [:id, :name]
+            raw_attributes[key] = @raw.send(key)
+          end
+          merge_attributes(raw_attributes)
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/fog/compute/models/virtual_box/mediums.rb

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/compute/models/virtual_box/medium'
+
+module Fog
+  module VirtualBox
+    class Compute
+
+      class Mediums < Fog::Collection
+
+        model Fog::VirtualBox::Compute::Medium
+
+        def all
+          data = []
+          data.concat(connection.dvd_images)
+          data.concat(connection.floppy_images)
+          data.concat(connection.hard_disks)
+          data = data.map do |medium|
+            {:raw => medium}
+          end
+          load(data)
+        end
+
+        def get(medium_identity)
+          data = connection.find_medium(medium_identity)
+          new(:raw => data)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/compute/models/virtual_box/nat_engine.rb

@@ -0,0 +1,65 @@
+require 'fog/core/model'
+
+module Fog
+  module VirtualBox
+    class Compute
+
+      class NATEngine < Fog::Model
+
+        # identity :?
+
+        attribute :alias_mode
+        attribute :dns_pass_domain
+        attribute :dns_proxy
+        attribute :dns_use_host_resolver
+        attribute :host_ip
+        attribute :network
+        attribute :redirects
+        attribute :tftp_boot_file
+        attribute :tftp_next_server
+        attribute :tftp_prefix
+
+        attr_accessor :machine, :network_adapter
+
+        # def save
+        #   unless identity
+        #     requires :identity, :bus, :machine
+        #     with_session do |session|
+        #       self.raw = session.machine.add_storage_controller(identity, bus)
+        #     end
+        #     true
+        #   else
+        #     raise Fog::Errors::Error.new('Updating an existing storage_controller is not yet implemented. Contributions welcome!')
+        #   end
+        # end
+
+        undef_method :redirects
+        def redirects
+          Fog::VirtualBox::Compute::NATRedirects.new(
+            :connection => connection,
+            :machine    => machine,
+            :nat_engine => self
+          )
+        end
+
+        private
+
+        def raw
+          @raw
+        end
+        
+        def raw=(new_raw)
+          @raw = new_raw
+          raw_attributes = {}
+          for key in [:alias_mode, :dns_pass_domain, :dns_proxy, :dns_use_host_resolver, :host_ip, :network, :redirects, :tftp_boot_file, :tftp_next_server, :tftp_prefix]
+            raw_attributes[key] = @raw.send(key)
+          end
+          merge_attributes(raw_attributes)
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/fog/compute/models/virtual_box/nat_redirect.rb

@@ -0,0 +1,91 @@
+require 'fog/core/model'
+
+module Fog
+  module VirtualBox
+    class Compute
+
+      class NATRedirect < Fog::Model
+
+        identity :name
+
+        attribute :name
+        attribute :protocol
+        attribute :host_ip
+        attribute :host_port
+        attribute :guest_ip
+        attribute :guest_port
+
+        attr_accessor :machine, :nat_engine
+
+        def destroy
+          requires :nat_engine, :name
+          with_session do |session|
+            raw_network_adapter = session.machine.get_network_adapter(nat_engine.network_adapter.slot)
+            raw_nat_engine = raw_network_adapter.nat_driver
+            raw_nat_engine.remove_redirect(name)
+            session.machine.save_settings
+          end
+          true
+        end
+
+        def initialize(attributes = {})
+          self.name     = ''
+          self.protocol = :tcp
+          self.host_ip  = ''
+          self.guest_ip = ''
+          super
+        end
+
+        undef_method :protocol=
+        def protocol=(new_protocol)
+          attributes[:protocol] = case new_protocol
+          when '0'
+            :udp
+          when '1'
+            :tcp
+          else
+            new_protocol
+          end
+        end
+
+        def save
+          requires :nat_engine, :name, :protocol, :host_ip, :host_port, :guest_ip, :guest_port
+          with_session do |session|
+            raw_network_adapter = session.machine.get_network_adapter(nat_engine.network_adapter.slot)
+            raw_nat_engine = raw_network_adapter.nat_driver
+            raw_nat_engine.add_redirect(name, protocol, host_ip, host_port, guest_ip, guest_port)
+            session.machine.save_settings
+          end
+          true
+        end
+
+        private
+
+        def raw
+          @raw
+        end
+
+        def raw=(new_raw)
+          @raw = new_raw
+          name, protocol, host_ip, host_port, guest_ip, guest_port = new_raw.split(',')
+          raw_attributes = {:name => name, :protocol => protocol, :host_ip => host_ip, :host_port => host_port, :guest_ip => guest_ip, :guest_port => guest_port}
+          merge_attributes(raw_attributes)
+        end
+
+        def session
+          ::VirtualBox::Lib.lib.session
+        end
+
+        def with_session
+          raw_machine = machine.instance_variable_get(:@raw)
+          raw_machine.lock_machine(session, :write)
+          yield session
+          session.unlock_machine
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/fog/compute/models/virtual_box/nat_redirects.rb

@@ -0,0 +1,41 @@
+require 'fog/core/collection'
+require 'fog/compute/models/virtual_box/nat_redirect'
+
+module Fog
+  module VirtualBox
+    class Compute
+
+      class NATRedirects < Fog::Collection
+
+        model Fog::VirtualBox::Compute::NATRedirect
+
+        attr_accessor :machine, :nat_engine
+
+        def all
+          requires :machine, :nat_engine
+          data = nat_engine.instance_variable_get(:@raw).redirects.map do |nat_redirect|
+            {
+              :machine  => machine,
+              :raw      => nat_redirect
+            }
+          end
+          load(data)
+        end
+
+        def get(nat_redirect_name)
+          requires :machine, :nat_engine
+          all.detect do |nat_redirect|
+            nat_redirect.name == nat_redirect_name
+          end
+        end
+
+        def new(attributes = {})
+          requires :machine, :nat_engine
+          super({:machine => machine, :nat_engine => nat_engine}.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/compute/models/virtual_box/network_adapter.rb

@@ -0,0 +1,82 @@
+require 'fog/core/model'
+require 'fog/compute/models/virtual_box/nat_engine'
+
+module Fog
+  module VirtualBox
+    class Compute
+
+      class NetworkAdapter < Fog::Model
+
+        identity :slot
+
+        attribute :adapter_type
+        attribute :attachment_type
+        attribute :bandwidth_limit
+        attribute :boot_priority
+        attribute :cable_connected
+        attribute :enabled
+        attribute :host_interface
+        attribute :internal_network
+        attribute :line_speed
+        attribute :mac_address
+        attribute :nat_driver
+        attribute :nat_network
+        attribute :trace_enabled
+        attribute :trace_file
+        attribute :vde_network
+
+        attr_accessor :machine
+
+        def save
+          with_session do |session|
+            session_raw = session.machine.get_network_adapter(slot)
+            # for attribute in [:adapter_type, :bandwidth_limit, :boot_priority, :cable_connected, :enabled, :host_interface, :internal_network, :line_speed, :mac_address, :nat_network, :trace_enabled, :trace_file]
+            #   session_raw.send("#{attribute}=", attributes[attribute])
+            # end
+            session_raw.mac_address = mac_address
+            session.machine.save_settings
+          end
+        end
+
+        undef_method :nat_driver
+        def nat_driver
+          Fog::VirtualBox::Compute::NATEngine.new(
+            :connection       => connection,
+            :machine          => machine,
+            :network_adapter  => self,
+            :raw              => raw.nat_driver
+          )
+        end
+
+        private
+
+        def raw
+          @raw
+        end
+
+        def raw=(new_raw)
+          @raw = new_raw
+          raw_attributes = {}
+          for key in [:adapter_type, :attachment_type, :bandwidth_limit, :boot_priority, :cable_connected, :enabled, :host_interface, :internal_network, :line_speed, :mac_address, :nat_driver, :nat_network, :slot, :trace_enabled, :trace_file]
+            raw_attributes[key] = @raw.send(key)
+          end
+          merge_attributes(raw_attributes)
+        end
+
+        def session
+          ::VirtualBox::Lib.lib.session
+        end
+
+        def with_session
+          raw_machine = machine.instance_variable_get(:@raw)
+          raw_machine.lock_machine(session, :write)
+          yield session
+          session.unlock_machine
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/fog/compute/models/virtual_box/network_adapters.rb

@@ -0,0 +1,42 @@
+require 'fog/core/collection'
+require 'fog/compute/models/virtual_box/network_adapter'
+
+module Fog
+  module VirtualBox
+    class Compute
+
+      class NetworkAdapters < Fog::Collection
+
+        model Fog::VirtualBox::Compute::NetworkAdapter
+
+        attr_accessor :machine
+
+        def all
+          requires :machine
+          data = []
+          raw_machine = machine.instance_variable_get(:@raw)
+          connection.system_properties.network_adapter_count.times do |index|
+            data << {
+              :raw  => raw_machine.get_network_adapter(index)
+            }
+          end
+          load(data)
+        end
+
+        def get(network_adapter_slot)
+          requires :machine
+          raw_machine = machine.instance_variable_get(:@raw)
+          network_adapter = raw_machine.get_network_adapter(network_adapter_slot)
+          new(:raw => network_adapter)
+        end
+
+        def new(attributes = {})
+          requires :machine
+          super({ :machine => machine }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/compute/models/virtual_box/server.rb

@@ -0,0 +1,241 @@
+require 'fog/core/model'
+
+module Fog
+  module VirtualBox
+    class Compute
+
+      class Server < Fog::Model
+
+        identity :id
+
+        attribute :description
+        attribute :memory_size
+        attribute :name
+        attribute :os,          :aliases => :os_type_id
+        attribute :rtc_use_utc
+        attribute :session_state
+        attribute :status,      :aliases => :state
+        attribute :vram_size
+
+        # property :accelerate_2d_video_enabled, T_BOOL
+        # property :accelerate_3d_enabled, T_BOOL
+        # property :access_error, :VirtualBoxErrorInfo, :readonly => true
+        # property :accessible, T_BOOL, :readonly => true
+        # property :audio_adapter, :AudioAdapter, :readonly => true
+        # property :bandwidth_control, :BandwidthControl, :readonly => true
+        # property :bios_settings, :BIOSSettings, :readonly => true
+        # property :chipset_type, :ChipsetType
+        # property :clipboard_mode, :ClipboardMode
+        # property :cpu_count, T_UINT32
+        # property :cpu_execution_cap, T_UINT64
+        # property :cpu_hot_plug_enabled, T_BOOL
+        # property :current_snapshot, :Snapshot, :readonly => true
+        # property :current_state_modified, T_BOOL, :readonly => true
+        # property :fault_tolerance_address, WSTRING
+        # property :fault_tolerance_password, WSTRING
+        # property :fault_tolerance_port, T_UINT64
+        # property :fault_tolerance_state, :FaultToleranceState
+        # property :fault_tolerance_sync_interval, T_UINT64
+        # property :firmware_type, :FirmwareType
+        # property :guest_property_notification_patterns, WSTRING
+        # property :hardware_uuid, WSTRING
+        # property :hardware_version, WSTRING
+        # property :hpet_enabled, T_BOOL
+        # property :io_cache_enabled, T_BOOL
+        # property :io_cache_size, T_UINT32
+        # property :keyboard_hid_type, T_UINT32
+        # property :last_state_change, T_INT64, :readonly => true
+        # property :log_folder, WSTRING, :readonly => true
+        # property :medium_attachments, [:MediumAttachment], :readonly => true
+        # property :memory_balloon_size, T_UINT64
+        # property :monitor_count, T_UINT64
+        # property :page_fusion_enabled, T_BOOL
+        # property :parent, :VirtualBox, :readonly => true
+        # property :pci_device_assignments, [:PciDeviceAttachment], :readonly => true
+        # property :pointing_hid_type, T_UINT32
+        # property :session_pid, T_UINT64, :readonly => true
+        # property :session_type, WSTRING, :readonly => true
+        # property :settings_file_path, WSTRING, :readonly => true
+        # property :settings_modified, T_BOOL, :readonly => true
+        # property :shared_folders, [:SharedFolder], :readonly => true
+        # property :snapshot_count, T_UINT32, :readonly => true
+        # property :snapshot_folder, WSTRING
+        # property :state_file_path, WSTRING, :readonly => true
+        # property :storage_controllers, [:StorageController], :readonly => true
+        # property :teleporter_address, WSTRING
+        # property :teleporter_enabled, T_BOOL
+        # property :teleporter_password, WSTRING
+        # property :teleporter_port, T_UINT32
+        # property :usb_controller, :USBController, :readonly => true
+        # property :vrde_server, :VRDEServer, :readonly => true
+
+        attr_writer :private_key, :private_key_path, :public_key, :public_key_path, :username
+
+        def initialize(attributes={})
+          self.memory_size = 256
+          self.rtc_use_utc = true
+          self.vram_size   = 8
+          super
+        end
+
+        def destroy
+          requires :name, :raw
+          unless raw.state == :powered_off
+            stop
+            wait_for { raw.session_state == :closed }
+          end
+          raw.unregister(:full)
+          config_file = connection.compose_machine_filename(name)
+          config_directory = config_file.split(File::SEPARATOR)[0...-1].join(File::SEPARATOR)
+          FileUtils.rm_rf(config_directory)
+          true
+        end
+
+        def network_adapters
+          Fog::VirtualBox::Compute::NetworkAdapters.new(
+            :connection => connection,
+            :machine => self
+          )
+        end
+
+        def private_ip_address
+          nil
+        end
+
+        def private_key_path
+          @private_key_path ||= Fog.credentials[:private_key_path]
+          @private_key_path &&= File.expand_path(@private_key_path)
+        end
+
+        def private_key
+          @private_key ||= private_key_path && File.read(private_key_path)
+        end
+
+        def public_ip_address
+          nil
+        end
+
+        def public_key_path
+          @public_key_path ||= Fog.credentials[:public_key_path]
+          @public_key_path &&= File.expand_path(@public_key_path)
+        end
+
+        def public_key
+          @public_key ||= public_key_path && File.read(public_key_path)
+        end
+
+        def ready?
+          status == :running
+        end
+
+        def reboot
+          requires :raw
+          session.console.reset
+          true
+        end
+
+        def save
+          unless identity
+            requires :name, :os
+            self.raw = connection.create_machine(nil, name, os)
+            connection.register_machine(raw)
+            with_session do |session|
+              for attribute in [:description, :memory_size, :rtc_use_utc, :vram_size]
+                session.machine.send(:"#{attribute}=", attributes[attribute])
+              end
+              session.machine.save_settings
+            end
+            true
+          else
+            raise Fog::Errors::Error.new('Updating an existing server is not yet implemented. Contributions welcome!')
+          end
+        end
+
+        def scp(local_path, remote_path)
+          raise 'Not Implemented'
+          # requires :addresses, :username
+          # 
+          # options = {}
+          # options[:key_data] = [private_key] if private_key
+          # Fog::SCP.new(addresses['public'].first, username, options).upload(local_path, remote_path)
+        end
+
+        def setup(credentials = {})
+          raise 'Not Implemented'
+        #   requires :addresses, :identity, :public_key, :username
+        #   Fog::SSH.new(addresses['public'].first, username, credentials).run([
+        #     %{mkdir .ssh},
+        #     %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
+        #     %{passwd -l #{username}},
+        #     %{echo "#{attributes.to_json}" >> ~/attributes.json},
+        #     %{echo "#{metadata.to_json}" >> ~/metadata.json}
+        #   ])
+        # rescue Errno::ECONNREFUSED
+        #   sleep(1)
+        #   retry
+        end
+
+        def ssh(commands)
+          raise 'Not Implemented'
+          # requires :addresses, :identity, :username
+          # 
+          # options = {}
+          # options[:key_data] = [private_key] if private_key
+          # Fog::SSH.new(addresses['public'].first, username, options).run(commands)
+        end
+
+        def start(type = 'headless')
+          requires :raw
+          # session, type in ['gui', 'headless'], key[=value]\n env variables
+          raw.launch_vm_process(session, type, '').wait
+          true
+        end
+
+        def stop
+          requires :raw
+          session.console.power_down.wait
+          true
+        end
+
+        def storage_controllers
+          Fog::VirtualBox::Compute::StorageControllers.new(
+            :connection => connection,
+            :machine    => self
+          )
+        end
+
+        def username
+          @username ||= 'root'
+        end
+
+        private
+
+        def raw
+          @raw
+        end
+
+        def raw=(new_raw)
+          @raw = new_raw
+          raw_attributes = {}
+          for key in [:id, :description, :memory_size, :name, :os_type_id, :state]
+            raw_attributes[key] = @raw.send(key)
+          end
+          merge_attributes(raw_attributes)
+        end
+
+        def session
+          ::VirtualBox::Lib.lib.session
+        end
+
+        def with_session
+          raw.lock_machine(session, :write)
+          yield session
+          session.unlock_machine
+        end
+
+      end
+
+    end
+  end
+
+end