brightbox-cli 0.13.1 → 0.14.0

data/lib/brightbox-cli/vendor/fog/lib/fog/virtual_box/models/compute/mediums.rb

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/virtual_box/models/compute/medium'
+
+module Fog
+  module Compute
+    class VirtualBox
+
+      class Mediums < Fog::Collection
+
+        model Fog::Compute::VirtualBox::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/brightbox-cli/vendor/fog/lib/fog/virtual_box/models/compute/nat_redirects.rb

@@ -0,0 +1,41 @@
+require 'fog/core/collection'
+require 'fog/virtual_box/models/compute/nat_redirect'
+
+module Fog
+  module Compute
+    class VirtualBox
+
+      class NATRedirects < Fog::Collection
+
+        model Fog::Compute::VirtualBox::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/brightbox-cli/vendor/fog/lib/fog/virtual_box/models/compute/network_adapter.rb

@@ -0,0 +1,82 @@
+require 'fog/core/model'
+require 'fog/virtual_box/models/compute/nat_engine'
+
+module Fog
+  module Compute
+    class VirtualBox
+
+      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::Compute::VirtualBox::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/brightbox-cli/vendor/fog/lib/fog/virtual_box/models/compute/network_adapters.rb

@@ -0,0 +1,42 @@
+require 'fog/core/collection'
+require 'fog/virtual_box/models/compute/network_adapter'
+
+module Fog
+  module Compute
+    class VirtualBox
+
+      class NetworkAdapters < Fog::Collection
+
+        model Fog::Compute::VirtualBox::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/brightbox-cli/vendor/fog/lib/fog/virtual_box/models/compute/servers.rb

@@ -0,0 +1,41 @@
+require 'fog/core/collection'
+require 'fog/virtual_box/models/compute/server'
+
+module Fog
+  module Compute
+    class VirtualBox
+
+      class Servers < Fog::Collection
+
+        model Fog::Compute::VirtualBox::Server
+
+        def all
+          data = connection.machines.map do |machine|
+            {
+              :raw => machine
+            }
+          end
+          load(data)
+        end
+
+        def bootstrap(new_attributes = {})
+          raise 'Not Implemented'
+          # server = create(new_attributes)
+          # server.start
+          # server.wait_for { ready? }
+          # server.setup(:password => server.password)
+          # server
+        end
+
+        def get(server_id)
+          machine = connection.find_machine(server_id)
+          new(:raw => machine)
+        rescue ::VirtualBox::Exceptions::ObjectNotFoundException
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/virtual_box/models/compute/storage_controllers.rb

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

data/lib/brightbox-cli/vendor/fog/lib/fog/vmfusion.rb

@@ -0,0 +1,11 @@
+require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
+
+module Fog
+  module Vmfusion
+
+    extend Fog::Provider
+
+    service(:compute, 'vmfusion/compute')
+
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/vmfusion/compute.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'vmfusion'))
+require 'fog/compute'
+
+module Fog
+  module Compute
+    class Vmfusion < Fog::Service
+
+      model_path 'fog/vmfusion/models/compute'
+      model       :server
+      collection  :servers
+
+      class Mock
+
+        def initialize(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          require 'fission'
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/vmfusion/models/compute/server.rb

@@ -0,0 +1,223 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Vmfusion
+
+      class Server < Fog::Model
+
+        identity :name
+
+        attribute :name
+        attribute :state
+
+        attr_accessor :password
+        attr_writer   :private_key, :private_key_path, :public_key, :public_key_path, :username
+
+        def initalize(attributes={})
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Creating a new vm is not yet supported')
+        end
+
+        def clone(name)
+          requires :raw
+
+          ::Fission::VM.clone(@raw.name,name)
+          return connection.servers.get(name)
+        end
+
+        def destroy(options={ :force => false})
+          requires :raw
+
+          if state=="running"
+            if options[:force]
+              @raw.stop
+            end
+          end
+
+          ::Fission::VM.delete @raw.name
+        end
+
+        def start
+          requires :raw
+
+          unless state=="running"
+            @raw.start
+            return true
+          else
+            return false
+          end
+        end
+
+        def stop
+          requires :raw
+
+          if state=="running"
+            @raw.stop
+            return true
+          else
+            return false
+          end
+        end
+
+        def reboot
+          requires :raw
+          if state=="running"
+            @raw.stop
+            wait_for { state!="running"}
+            @raw.start
+            return true
+          else
+            return false
+          end
+        end
+
+        def halt
+          requires :raw
+          if state=="running"
+            @raw.halt
+            return true
+          else
+            return false
+          end
+
+        end
+
+        def poweroff
+          requires :raw
+          halt
+        end
+
+        def shutdown
+          requires :raw
+          stop
+        end
+
+        def resume
+          requires :raw
+          @raw.resume
+        end
+
+        def suspend
+          requires :raw
+          @raw.suspend
+        end
+
+        def state
+          requires :raw
+          @raw.state
+        end
+
+        def ready?
+          state == "running"
+        end
+
+        def private_ip_address
+          ip_address(:private)
+        end
+
+        def public_ip_address
+          ip_address(:public)
+        end
+
+
+        def username
+          @username ||= 'root'
+        end
+
+        def ssh(commands)
+          requires :public_ip_address, :username
+
+          #requires :password, :private_key
+          ssh_options={}
+          ssh_options[:password] = password unless password.nil?
+          ssh_options[:key_data] = [private_key] if private_key
+
+          Fog::SSH.new(public_ip_address, @username, ssh_options).run(commands)
+
+        end
+
+        def scp(local_path, remote_path, upload_options = {})
+          requires :public_ip_address, :username
+
+          scp_options = {}
+          scp_options[:password] = password unless self.password.nil?
+          scp_options[:key_data] = [private_key] if self.private_key
+
+          Fog::SCP.new(public_ip_address, username, scp_options).upload(local_path, remote_path, upload_options)
+        end
+
+        # Sets up a new key
+        def setup(credentials = {})
+          requires :public_key, :public_ip_address, :username
+
+          credentials[:password] = password unless self.password.nil?
+          credentails[:key_data] = [private_key] if self.private_key
+
+          commands = [
+            %{mkdir .ssh},
+          ]
+          if public_key
+            commands << %{echo "#{public_key}" >> ~/.ssh/authorized_keys}
+          end
+
+          # wait for domain to be ready
+          Timeout::timeout(360) do
+            begin
+              Timeout::timeout(8) do
+                Fog::SSH.new(public_ip_address, username, credentials.merge(:timeout => 4)).run('pwd')
+              end
+            rescue Errno::ECONNREFUSED
+              sleep(2)
+              retry
+            rescue Net::SSH::AuthenticationFailed, Timeout::Error
+              retry
+            end
+          end
+          Fog::SSH.new(public_ip_address, username, credentials).run(commands)
+        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_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
+
+        private
+        def ip_address(key)
+          @raw.ip_address
+        end
+
+        def raw
+          @raw
+        end
+
+        def raw=(new_raw)
+          @raw = new_raw
+
+          raw_attributes = {
+            :name => new_raw.name,
+            :state => new_raw.state
+          }
+
+          merge_attributes(raw_attributes)
+        end
+
+      end
+    end
+  end
+end