bbrowning-deltacloud-core 0.0.4-java → 0.0.6-java

data/lib/deltacloud/drivers/ec2/ec2_driver.rb

@@ -310,6 +310,15 @@ class EC2Driver < Deltacloud::BaseDriver
     end
   end
 
+  def valid_credentials?(credentials)
+    client = new_client(credentials)
+    # FIXME: We need to do this call to determine if
+    #        EC2 is working with given credentials. There is no
+    #        other way to check, if given credentials are valid or not.
+    realms = client.describe_availability_zones rescue false
+    return realms ? true : false
+  end
+
   private
 
   def new_client(credentials)

data/lib/deltacloud/drivers/gogrid/gogrid_driver.rb

@@ -192,6 +192,15 @@ class GogridDriver < Deltacloud::BaseDriver
     return creds
   end
 
+  def valid_credentials?(credentials)
+    client = new_client(credentials)
+    # FIXME: We need to do this call to determine if
+    #        GoGrid is working with given credentials. There is no
+    #        other way to check, if given credentials are valid or not.
+    return false unless new_client(credentials).request('common/lookup/list', { 'lookup' => 'ip.datacenter' })
+    true
+  end
+
   define_instance_states do
     start.to( :pending )         .automatically
     pending.to( :running )       .automatically

data/lib/deltacloud/drivers/mock/mock_driver.rb

@@ -257,6 +257,15 @@ class MockDriver < Deltacloud::BaseDriver
     snapshots
   end
 
+  def valid_credentials?(credentials)
+    begin
+      check_credentials(credentials)
+      return true
+    rescue Deltacloud::AuthException
+    end
+    return false
+  end
+
   private
 
   def check_credentials(credentials)

data/lib/deltacloud/drivers/rackspace/rackspace_driver.rb

@@ -131,6 +131,15 @@ class RackspaceDriver < Deltacloud::BaseDriver
     instances
   end
 
+  def valid_credentials?(credentials)
+    begin
+      new_client(credentials)
+    rescue
+      return false
+    end
+    true
+  end
+
 
   def convert_srv_to_instance(srv)
     inst = Instance.new(:id => srv["id"].to_s,

data/lib/deltacloud/drivers/terremark/terremark_driver.rb

@@ -191,6 +191,15 @@ def destroy_instance(credentials, id)
   end
 end
 
+def valid_credentials?(credentials)
+  begin
+    new_client(credentials)
+  rescue Deltacloud::AuthException
+    return false
+  end
+  true
+end
+
 #--
 # PRIVATE METHODS:
 #--

data/lib/deltacloud/drivers/virtualbox/virtualbox_driver.rb

@@ -0,0 +1,253 @@
+#
+# Copyright (C) 2009  Red Hat, Inc.
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+# INSTALLATION:
+# 1. You need VirtualBox and VBoxManage tool installed
+# 2. You need to setup some images manually inside VirtualBox
+# 3. You need to install 'Guest Additions' to this images for metrics
+# 4. You need a lot of hard drive space ;-)
+
+# NETWORKING:
+# For now, the VM is always started with bridged networking. The NIC
+# it uses defaults to eth0, but may be overriden with the VIRTUALBOX_NIC
+# environment variable. This should be the NIC name as expected by Virtualbox.
+# For example, on my Macbook Pro this is 'en1: AirPort'
+
+require 'deltacloud/base_driver'
+require 'virtualbox'
+
+module Deltacloud
+  module Drivers
+    module Virtualbox
+      class VirtualboxDriver < Deltacloud::BaseDriver
+
+        ( REALMS = [
+          Realm.new({
+            :id => 'local',
+            :name => 'localhost',
+            :limit => 100,
+            :state => 'AVAILABLE'
+          })
+        ] ) unless defined?( REALMS )
+
+        define_hardware_profile 'small' do
+          cpu           1
+          memory        0.5
+          storage       1
+          architecture  `uname -m`.strip
+        end
+
+        define_hardware_profile 'medium' do
+          cpu           1
+          memory        1
+          storage       1
+          architecture  `uname -m`.strip
+        end
+
+        define_hardware_profile 'large' do
+          cpu           2
+          memory        2
+          storage       1
+          architecture  `uname -m`.strip
+        end
+
+        define_instance_states do
+          start.to( :pending )       .on( :create )
+          pending.to( :running )     .automatically
+          running.to( :stopped )     .on( :stop )
+          stopped.to( :running )     .on( :start )
+          stopped.to( :finish )      .on( :destroy )
+        end
+
+        def realms(credentials, opts = nil)
+          return REALMS if ( opts.nil? )
+          results = REALMS
+          results = filter_on( results, :id, opts )
+          results
+        end
+
+        def images(credentials, opts = nil)
+          images = convert_images(VirtualBox::VM.all)
+          images = filter_on( images, :id, opts )
+          images = filter_on( images, :architecture, opts )
+          images.sort_by{|e| [e.owner_id, e.description]}
+        end
+
+        def instances(credentials, opts = nil)
+          instances = convert_instances(VirtualBox::VM.all)
+          instances = filter_on( instances, :id, opts )
+          instances = filter_on( instances, :state, opts )
+          instances = filter_on( instances, :image_id, opts )
+          instances
+        end
+
+        def create_instance(credentials, image_id, opts)
+          image = images(credentials, { :id => image_id }).first
+
+          # Choose a name for the new vm unless one was given
+          name = opts[:name]
+          if name.nil? or name.empty?
+            # random uniqueish name w/o having to pull in UUID gem
+            name = "#{image.name} - #{(Time.now.to_f * 1000).to_i}#{rand(1000)}"
+          end
+
+          hwp = find_hardware_profile(credentials, opts[:hwp_id], image_id)
+          parent_vm = VirtualBox::VM.find(image.id)
+
+          # Create new virtual machine
+          vm = VirtualBox::VM.create(name, parent_vm.os_type_id)
+          new_uid = vm.uuid
+
+          # Add Hardware profile to this machine
+          vm.memory_size = ((hwp.memory.value*1.024)*1000).to_i
+          vm.cpu_count = hwp.cpu.value.to_i
+          vm.vram_size = 16
+
+          # Copy the network adapter settings from the parent vm
+          vm.network_adapters[0].enabled = true
+          vm.network_adapters[0].attachment_type = parent_vm.network_adapters[0].attachment_type
+          vm.network_adapters[0].host_interface = parent_vm.network_adapters[0].host_interface
+
+          # Store some metadata using extra data fields
+          vm.extra_data['deltacloud_hwp_id'] = hwp.name
+          vm.extra_data['deltacloud_image_id'] = image_id
+
+          vm.save
+
+          # Clone the disk image in a separate thread because it can take a long time
+          Thread.new do
+            # Reload the vm objects because they probably aren't safe to
+            # reuse across threads
+            parent_vm = VirtualBox::VM.find(image.id)
+            vm = VirtualBox::VM.find(new_uid)
+
+            # Add storage
+            # This will 'reuse' existing image
+            parent_hdd = hard_disk(parent_vm)
+            new_location = File.join(File.dirname(parent_hdd.location), "#{name}.vdi")
+
+            new_hd = parent_hdd.clone(new_location, "VDI")
+            vm.add_storage_controller('IDE Controller', :ide, :piix4)
+            vm.attach_storage('IDE Controller', 0, 0, :hard_disk, new_hd.uuid)
+            vm.start
+            if opts[:user_data]
+              user_data = opts[:user_data].gsub("\n", '') # remove newlines from base64 encoded text
+              vm.guest_property["/Deltacloud/UserData"] = user_data
+            end
+          end
+          instances(credentials, :id => new_uid).first
+        end
+
+        def reboot_instance(credentials, id)
+          vm = VirtualBox::VM.find(id)
+          vm.control(:reset)
+        end
+
+        def stop_instance(credentials, id)
+          vm = VirtualBox::VM.find(id)
+          unless vm.shutdown
+            vm.stop
+          end
+        end
+
+        def start_instance(credentials, id)
+          vm = VirtualBox::VM.find(id)
+          vm.start
+        end
+
+        def destroy_instance(credentials, id)
+          vm = VirtualBox::VM.find(id)
+          vm.destroy(:destroy_medium => :delete)
+        end
+
+        private
+
+        def convert_instances(instances)
+          vms = []
+          instances.each do |instance|
+            volume = convert_volume(instance)
+            state = convert_state(instance.state, volume)
+            ip = vbox_get_ip(instance)
+            hwp_name = instance.extra_data['deltacloud_hwp_id'] || 'small'
+            image_id = instance.extra_data['deltacloud_image_id'] || ''
+            vms << Instance.new(:id => instance.uuid,
+                                :image_id => image_id,
+                                :name => instance.name,
+                                :state => state,
+                                :owner_id => ENV['USER'] || ENV['USERNAME'] || 'nobody',
+                                :realm_id => 'local',
+                                :public_addresses => ip,
+                                :private_addresses => ip,
+                                :actions => instance_actions_for(state),
+                                :instance_profile => InstanceProfile.new(hwp_name))
+          end
+          vms
+        end
+
+        # Warning: You need VirtualHost guest additions for this
+        def vbox_get_ip(instance)
+          ip = instance.guest_property["/VirtualBox/GuestInfo/Net/0/V4/IP"]
+          ip.nil? ? [] : [ip]
+        end
+
+        def convert_state(state, volume)
+          return 'PENDING' if volume.nil?
+          state = state.to_s.strip.upcase
+          case state
+          when 'POWEROFF' then 'STOPPED'
+          when 'POWERED_OFF' then 'STOPPED'
+          else
+            state
+          end
+        end
+
+        def convert_volume(vm)
+          hdd = hard_disk(vm)
+          return nil if hdd.nil?
+          StorageVolume.new(:id => hdd.uuid,
+                            :created => Time.now,
+                            :state => 'AVAILABLE',
+                            :capacity => hdd.logical_size,
+                            :instance_id => vm.uuid,
+                            :device => hdd.type)
+        end
+
+        def hard_disk(vm)
+          attachment = vm.medium_attachments.select { |ma| ma.type == :hard_disk }.first
+          attachment.nil? ? nil : attachment.medium
+        end
+
+        def convert_images(images)
+          vms = []
+          images.each do |image|
+            hdd = hard_disk(image)
+            next unless hdd
+            capacity = ", #{hdd.logical_size} MBytes HDD"
+            vms << Image.new(:id => image.uuid,
+                             :name => image.name,
+                             :description => "#{image.memory_size} MB RAM, #{image.cpu_count} CPU#{capacity}",
+                             :owner_id => ENV['USER'] || ENV['USERNAME'] || 'nobody',
+                             :architecture => `uname -m`.strip)
+          end
+          vms
+        end
+
+      end
+    end
+  end
+end

data/lib/drivers.rb

@@ -6,6 +6,7 @@ DRIVERS = {
   :rimuhosting => { :name => "RimuHosting"},
   :opennebula => { :name => "Opennebula", :class => "OpennebulaDriver" },
   :terremark => { :name => "Terremark"},
+  :virtualbox => { :name => "Virtualbox" },
   :mock => { :name => "Mock" }
 }
 

data/server.rb

@@ -42,6 +42,9 @@ get '/' do redirect url_for('/api'); end
 
 get '/api\/?' do
     @version = 0.1
+    if params[:force_auth]
+      return [401, 'Authentication failed'] unless driver.valid_credentials?(credentials)
+    end
     respond_to do |format|
         format.xml { haml :"api/show" }
         format.json do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 0
-    - 4
-  version: 0.0.4
+    - 6
+  version: 0.0.6
 platform: java
 authors: 
   - Red Hat, Inc.
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-01 00:00:00 -04:00
+date: 2010-09-19 00:00:00 -04:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -197,6 +197,7 @@ files:
   - lib/deltacloud/drivers/rimuhosting/rimuhosting_client.rb
   - lib/deltacloud/drivers/rimuhosting/rimuhosting_driver.rb
   - lib/deltacloud/drivers/terremark/terremark_driver.rb
+  - lib/deltacloud/drivers/virtualbox/virtualbox_driver.rb
   - lib/deltacloud/helpers/application_helper.rb
   - lib/deltacloud/helpers/conversion_helper.rb
   - lib/deltacloud/helpers/hardware_profiles_helper.rb