deltacloud-core 0.0.1 → 0.0.2

data/lib/deltacloud/drivers/{rimu/rimu_hosting_client.rb → rimuhosting/rimuhosting_client.rb}

@@ -24,17 +24,14 @@ require "deltacloud/base_driver"
 
 module Deltacloud
   module Drivers
-    module Rimu
+    module RimuHosting
 
 class RimuHostingClient
   def initialize(credentials ,baseuri = 'https://rimuhosting.com/r')
     @uri = URI.parse(baseuri)
     @service = Net::HTTP.new(@uri.host, @uri.port)
     @service.use_ssl = true
-    if credentials.provided?
-      @auth = "rimuhosting apikey=#{credentials.password}"
-    end
-
+    @auth = "rimuhosting apikey=#{credentials.password}"
   end
 
   def request(resource, data='', method='GET')
@@ -47,8 +44,9 @@ class RimuHostingClient
     res = JSON.parse(r.body)
     res = res[res.keys[0]]
 
-    if(res['response_type'] == "ERROR" and res['error_info']['error_class'] == "PermissionException")
-      raise DeltaCloud::AuthException.new
+    if(res['response_type'] == "ERROR" and ( (res['error_info']['error_class'] == "PermissionException") or
+					     (res['error_info']['error_class'] == "LoginRequired") )) 
+      raise Deltacloud::AuthException.new
     end
     res
   end
@@ -58,7 +56,6 @@ class RimuHostingClient
   end
 
   def list_plans
-    puts "testsdasfdsf"
     request('/pricing-plans;server-type=VPS')["pricing_plan_infos"]
   end
 

data/lib/deltacloud/drivers/{rimu/rimu_hosting_driver.rb → rimuhosting/rimuhosting_driver.rb}

@@ -17,11 +17,11 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 require "deltacloud/base_driver"
-require "deltacloud/drivers/rimu/rimu_hosting_client"
+require "deltacloud/drivers/rimuhosting/rimuhosting_client"
 
 module Deltacloud
   module Drivers
-    module Rimu
+    module RimuHosting
 
 class RimuHostingDriver < Deltacloud::BaseDriver
 
@@ -51,8 +51,8 @@ class RimuHostingDriver < Deltacloud::BaseDriver
       #        not contained in hte pricing_plan_infos
       HardwareProfile.new(plan["pricing_plan_code"]) do
         memory plan["minimum_memory_mb"].to_f
-        storage => plan["minimum_disk_gb"].to_i
-        architecture => "x86"
+        storage plan["minimum_disk_gb"].to_i
+        architecture "x86"
       end
     end
     filter_hardware_profiles(results, opts)
@@ -118,7 +118,8 @@ class RimuHostingDriver < Deltacloud::BaseDriver
             :realm_id => "RH",
             :owner_id => "root",
             :instance_profile => InstanceProfile.new("none"),
-            :actions => instance_actions_for("RUNNING")
+            :actions => instance_actions_for("RUNNING"),
+            :public_addresses => inst["allocated_ips"]["primary_ip"]
     })
   end
 

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

@@ -0,0 +1,261 @@
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#
+# This driver uses the fog library (Geemus - Wesley Beary) to talk to terremark... see
+#                                   http://github.com/geemus/fog
+# see terremark vcloud express api at:
+# https://community.vcloudexpress.terremark.com/en-us/product_docs/w/wiki/d-complete-vcloud-express-api-document.aspx
+#
+# 02 May 2010
+#
+require 'deltacloud/base_driver'
+require 'fog'
+require 'excon'
+require 'nokogiri'
+
+module Deltacloud
+  module Drivers
+    module Terremark
+
+class TerremarkDriver < Deltacloud::BaseDriver
+
+  feature :instances, :user_name
+
+#--
+# Vapp State Map... for use with convert_instance (get an integer back from terremark)
+#--
+VAPP_STATE_MAP = { "0" =>  "PENDING", "1" =>  "PENDING", "2" =>  "STOPPED", "4" =>  "RUNNING" }
+
+#--
+# HARDWARE PROFILES
+#--
+  define_hardware_profile 'default' do
+    cpu   [1,2,4,8]
+    memory  [512, 1024, 2048, 4096, 8192]
+    storage (1..500).to_a
+  end
+  #storage_disks [1..15]
+
+#--
+# IMAGES
+#--
+#aka "vapp_templates"
+  def images(credentials, opts=nil)
+      image_list = []
+      terremark_client = new_client(credentials)
+      vdc_id = terremark_client.default_vdc_id
+      catalogItems = terremark_client.get_catalog(vdc_id).body['CatalogItems']
+      catalogItems.each{ |catalog_item|
+        current_item_id = catalog_item['href'].split('/').last
+        current_item = terremark_client.get_catalog_item(current_item_id).body['Entity']
+          if(current_item['type'] == 'application/vnd.vmware.vcloud.vAppTemplate+xml')
+            image_list << convert_image(current_item, credentials.user)
+          end
+      } #end of catalogItems.each
+      image_list = filter_on( image_list, :id, opts )
+      image_list = filter_on( image_list, :architecture, opts )
+      image_list = filter_on( image_list, :owner_id, opts )
+      image_list
+  end
+
+#--
+# REALMS
+#--
+#only one realm... everything in US?
+  def realms(credentials, opts=nil)
+     [Realm.new( {
+      :id=>"US-Miami",
+      :name=>"United States - Miami",
+      :state=> "AVAILABLE"
+    } )]
+  end
+
+#--
+# INSTANCES
+#--
+#aka vApps
+  def instances(credentials, opts=nil)
+      instances = []
+      terremark_client = new_client(credentials)
+      vdc_items = terremark_client.get_vdc(terremark_client.default_vdc_id()).body['ResourceEntities']
+      vdc_items.each{|current_item|
+        if(current_item['type'] == 'application/vnd.vmware.vcloud.vApp+xml')
+           vapp_id =  current_item['href'].split('/').last
+           vapp = terremark_client.get_vapp(vapp_id)
+           instances  << convert_instance(vapp, terremark_client, credentials.user)
+        end
+      }#end vdc_items.each
+      instances = filter_on( instances, :id, opts )
+      instances
+  end
+
+#--
+# FINITE STATE MACHINE
+#--
+#by default new instance --> powered_off
+  define_instance_states do
+    start.to(:pending)            .on( :create )
+    pending.to(:stopped)          .automatically
+    stopped.to(:running)          .on( :start )
+    running.to(:running)          .on( :reboot )
+    running.to(:shutting_down)    .on( :stop )
+    shutting_down.to(:stopped)    .automatically
+    stopped.to(:end)              .on( :destroy )
+   end
+
+
+#--
+# CREATE INSTANCE
+#--
+#launch a vapp template. Needs a name, ram, no. cpus, id of vapp_template
+  def create_instance(credentials, image_id, opts)
+    new_vapp = nil
+    vapp_opts = {} #assemble options to pass to Fog::Terremark::Real.instantiate_vapp_template
+    terremark_hwp = hardware_profiles(credentials, {:name => 'default'}).first #sanity check values against default
+    name = opts['name'] #name could be nil or length 0 or too long
+    name = "inst#{Time.now.to_i}" if (name.nil? || (name.length == 0))
+    name = name.slice(0..13) #name < 15 chars (says terremark)
+    unless ( (terremark_hwp.include?(:cpu, opts[:hwp_cpu].to_i)) &&
+              (terremark_hwp.include?(:memory, opts[:hwp_memory].to_i)) ) then
+       raise Deltacloud::Validation::Failure.new(Deltacloud::Validation::Param.new(["cpu"]), "Error with cpu and/or memory values. you said cpu->#{opts[:hwp_cpu]} and mem->#{opts[:hwp_memory]}")
+    end
+    vapp_opts['cpus'] = opts[:hwp_cpu]
+    vapp_opts['memory'] =  opts[:hwp_memory]
+    terremark_client = new_client(credentials)
+#######
+#FIXME#  what happens if there is an issue getting the new vapp id? (eg even though created succesfully)
+#######
+    vapp_id = terremark_client.instantiate_vapp_template(name, image_id, vapp_opts).body['href'].split('/').last
+    new_vapp = terremark_client.get_vapp(vapp_id)
+    return convert_instance(new_vapp, terremark_client, credentials.user) #return an Instance object
+  end
+
+#--
+# REBOOT INSTANCE
+#--
+  def reboot_instance(credentials, id)
+    terremark_client =  new_client(credentials)
+    terremark_client.power_reset(id)
+  end
+
+#--
+# START INSTANCE
+#--
+def start_instance(credentials, id)
+    terremark_client =  new_client(credentials)
+    terremark_client.power_on(id)
+end
+
+#--
+# STOP INSTANCE
+#--
+def stop_instance(credentials, id)
+    terremark_client = new_client(credentials)
+    terremark_client.power_shutdown(id)
+end
+
+#--
+# DESTROY INSTANCE
+#--
+#shuts down... in terremark need to do a futher delete to get rid of a vapp entirely
+def destroy_instance(credentials, id)
+    terremark_client = new_client(credentials)
+    terremark_client.delete_vapp(id)
+end
+
+#--
+# PRIVATE METHODS:
+#--
+
+ private
+
+#--
+# CONVERT IMAGE
+#--
+#gets a vapp_template from a catalog and makes it a Image
+  def convert_image(catalog_vapp_template, account_name)
+    name = catalog_vapp_template['name']
+    #much fudging ensues
+    #arch = name.scan(/(36|24).bit/).first
+    #k enuf o'that now!
+    arch = "n/a" #Leaving out entirely as we don't get one from terremark (could parse but its a fudge)
+    Image.new( {
+                  :id => catalog_vapp_template['href'].split('/').last,
+                  :name => catalog_vapp_template['name'],
+                  :architecture => arch,
+                  :owner_id => account_name,
+                  :description => catalog_vapp_template['name']
+               })
+  end
+
+#--
+# CONVERT INSTANCE
+#--
+  def convert_instance(vapp, terremark_client, account_name)
+      vapp_private_ip = vapp.body['IpAddress']
+      vapp_public_ip = terremark_client.get_public_ips(terremark_client.default_vdc_id).body['PublicIpAddresses'].first['name']#get_public_address(terremark_client, vapp_private_ip)
+      vapp_status = vapp.body['status']
+      current_state = VAPP_STATE_MAP[vapp_status] #status == 0->BEING_CREATED 2->OFF 4->ON
+      profile = InstanceProfile.new("default")
+      name = vapp.body['name']
+      if current_state != "PENDING" #can only grab this stuff after instance is created
+        profile.cpu = vapp.body['VirtualHardware']['cpu']
+        profile.memory = vapp.body['VirtualHardware']['ram']
+#######
+#FIXME# could be more that one disk... but for now capture only first
+#######
+        disk = ((vapp.body['VirtualHardware']['disks'].first.to_i) / 1024 / 1024).to_s
+        profile.storage = disk
+#######
+#FIXME# this is a hack, shouldn't place this info next to name as some clients may rely on name field... probably will introduce
+####### a new field in the API for this (e.g. description/text field... human readable)
+      #name = "#{name} - [ #{vapp.body['OperatingSystem']['Description']} ]"
+      end
+      Instance.new( {
+                    :id => vapp.body['href'].split('/').last,
+                    :owner_id => "#{account_name}",
+                    #:image_id => "n/a", #cant get this... see https://community.vcloudexpress.terremark.com/en-us/discussion_forums/f/60/t/376.aspx
+                    :name => name,
+                    :realm_id => "US-Miami",
+                    :state => current_state,
+                    :actions => instance_actions_for(current_state),
+                    :public_addresses => vapp_public_ip,
+                    :private_addresses => vapp_private_ip,
+                    :instance_profile => profile
+                    } )
+  end
+
+#--
+# NEW CLIENT
+#--
+#use supplied credentials to make a new client for talking to terremark
+  def new_client(credentials)
+    #Fog constructor expecting  credentials[:terremark_password] and credentials[:terremark_username]
+    terremark_credentials = {:terremark_vcloud_username => "#{credentials.user}", :terremark_vcloud_password => "#{credentials.password}" }
+    terremark_client = Fog::Terremark::Vcloud.new(terremark_credentials)
+    vdc_id = terremark_client.default_vdc_id
+    if (vdc_id.nil?)
+       raise DeltaCloud::AuthException.new
+    end
+    terremark_client
+  end
+
+
+end
+
+    end
+  end
+end

data/lib/deltacloud/hardware_profile.rb

@@ -117,6 +117,28 @@ module Deltacloud
       p && p.default.to_s == v
     end
 
+    def to_hash
+      props = []
+      self.each_property do |p|
+        if p.kind.eql? :fixed
+          props << { :kind => p.kind, :value => p.value, :name => p.name, :unit => p.unit } 
+        else
+          param = { :operation => "create", :method => "post", :name => p.name }
+          if p.kind.eql? :range
+            param[:range] = { :first => p.first, :last => p.last }
+          elsif p.kind.eql? :enum
+            param[:enum] = p.values.collect { |v| { :entry => v } }
+          end
+          param
+          props << { :kind => p.kind, :value => p.default, :name => p.name, :unit => p.unit, :param => param }
+        end
+      end
+      {
+        :id => self.name,
+        :properties => props
+      }
+    end
+
     def include?(prop, v)
       p = @properties[prop]
       p.nil? || p.include?(v)

data/lib/deltacloud/helpers/application_helper.rb

@@ -35,4 +35,22 @@ module ApplicationHelper
     end
     s+="</ul>"
   end
+
+  def instance_action_method(action)
+    collections[:instances].operations[action.to_sym].method
+  end
+
+  def driver_has_feature?(feature_name)
+    not driver.features(:instances).select{ |f| f.name.eql?(feature_name) }.empty?
+  end
+
+  def driver_has_auth_features?
+    driver_has_feature?(:authentication_password) || driver_has_feature?(:authentication_key)
+  end
+
+  def driver_auth_feature_name
+    return 'key' if driver_has_feature?(:authentication_key)
+    return 'password' if driver_has_feature?(:authentication_password)
+  end
+
 end

data/lib/deltacloud/helpers/conversion_helper.rb

@@ -17,15 +17,14 @@
 
 
 require 'deltacloud/base_driver'
-require 'converters/xml_converter'
 
 module ConversionHelper
 
   def convert_to_json(type, obj)
-    if ( [ :flavor, :account, :image, :realm, :instance, :storage_volume, :storage_snapshot ].include?( type ) )
+    if ( [ :flavor, :account, :image, :realm, :instance, :storage_volume, :storage_snapshot, :hardware_profile ].include?( type ) )
       if Array.eql?(obj.class)
         data = obj.collect do |o|
-          o.to_hash.merge({ :href => self.send(:"#{type}_url", o.id ) })
+          o.to_hash.merge({ :href => self.send(:"#{type}_url", type.eql?(:hardware_profile) ? o.name : o.id ) })
         end
         type = type.to_s.pluralize
       else

data/lib/deltacloud/method_serializer.rb

@@ -0,0 +1,84 @@
+#
+# Copyright (C) 2009  Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'base64'
+require 'digest'
+
+module MethodSerializer
+
+  module Cache
+
+    def cache_dir
+      storage_dir = $methods_cache_dir || File.join(File.dirname(__FILE__), 'cache')
+      class_dir = self.class.name.split('::').last
+      class_dir ||= self.class.name
+      File.join(storage_dir, class_dir.downcase)
+    end
+
+    def serialize_data(method_name, args, data)
+      File.open(cache_file_name(method_name, args), 'w') do |f|
+        f.puts(Base64.encode64(Marshal.dump(data)))
+      end
+      return data
+    end
+
+    def deserialize_data(method_name, args)
+      begin
+        data = File.readlines(cache_file_name(method_name, args)).join
+        Marshal.load(Base64.decode64(data))
+      rescue Errno::ENOENT
+        return false
+      end
+    end
+
+    def args_hash(args)
+      if args.class == Hash
+        args = args.to_a.collect {|i| [i[0].to_s, i[1]]}.sort
+      end
+      Digest::SHA1.hexdigest(args.to_s)
+    end
+
+    def cache_file_name(method_name, args)
+      FileUtils.mkdir_p(cache_dir) unless File.directory?(cache_dir)
+      method_name = $scenario_prefix ? "#{$scenario_prefix}_#{method_name}" : method_name
+      File.join(cache_dir, "#{method_name}.#{args_hash(args)}")
+    end
+
+    def self.wrap_methods(c, opts={})
+      $methods_cache_dir = opts[:cache_dir]
+      $scenario_prefix = nil
+      c.class_eval do
+        cached_methods.each do |m|
+          next if c.instance_methods(false).include?("original_#{m}")
+          alias_method "original_#{m}".to_sym, m.to_sym
+          define_method m.to_sym do |*args|
+            args = args.first if args.size.eql?(1) and not args.first.class.eql?(Array)
+            output = deserialize_data(m, args)
+            unless output
+              output = method("original_#{m}".to_sym).to_proc[args]
+              return serialize_data(m, args, output)
+            else
+              return output
+            end
+          end
+        end
+      end
+    end
+
+  end
+
+end