bbrowning-deltacloud-core 0.0.6-java → 0.0.6.1-java

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

@@ -186,7 +186,8 @@ class EC2Driver < Deltacloud::BaseDriver
         :monitoring_enabled => true,
         :instance_type => hwp.name,
         :disable_api_termination => false,
-        :instance_initiated_shutdown_behavior => 'terminate'
+        :instance_initiated_shutdown_behavior => 'terminate',
+        :security_group => opts[:security_group]
       )
       return convert_instance( ec2_instances.instancesSet.item.first, 'pending' )
     end
@@ -310,15 +311,6 @@ 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,15 +192,6 @@ 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,15 +257,6 @@ 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,15 +131,6 @@ 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,15 +191,6 @@ 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/drivers.rb

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

data/server.rb

@@ -42,9 +42,6 @@ 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

@@ -6,7 +6,8 @@ version: !ruby/object:Gem::Version
     - 0
     - 0
     - 6
-  version: 0.0.6
+    - 1
+  version: 0.0.6.1
 platform: java
 authors: 
   - Red Hat, Inc.
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-19 00:00:00 -04:00
+date: 2010-09-24 00:00:00 -04:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -197,7 +198,6 @@ 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

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

@@ -1,253 +0,0 @@
-#
-# 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