bbrowning-deltacloud-core 0.0.1.1

data/lib/deltacloud/drivers/rimuhosting/rimuhosting_client.rb

@@ -0,0 +1,84 @@
+#
+# Copyright (C) 2009  RimuHosting Ltd
+# Author: Ivan Meredith <ivan@ivan.net.nz>
+#
+# 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 "net/http"
+require "net/https"
+require "rubygems"
+require "json"
+require "deltacloud/base_driver"
+
+module Deltacloud
+  module Drivers
+    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
+    @auth = "rimuhosting apikey=#{credentials.password}"
+  end
+
+  def request(resource, data='', method='GET')
+    headers = {"Accept" => "application/json", "Content-Type" => "application/json"}
+    if(!@auth.nil?)
+      headers["Authorization"] = @auth
+    end
+    r = @service.send_request(method, @uri.path + resource, data, headers)
+         puts r.body
+    res = JSON.parse(r.body)
+    res = res[res.keys[0]]
+
+    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
+
+  def list_images
+    request('/distributions')["distro_infos"]
+  end
+
+  def list_plans
+    request('/pricing-plans;server-type=VPS')["pricing_plan_infos"]
+  end
+
+  def list_nodes
+    request('/orders;include_inactive=N')["about_orders"]
+  end
+
+  def set_server_state(id, state)
+    json = {"reboot_request" => {"running_state" => state}}.to_json
+    request("/orders/order-#{id}-a/vps/running-state", json, 'PUT')
+  end
+
+  def delete_server(id)
+    request("/orders/order-#{id}-a/vps",'', 'DELETE')
+  end
+
+  def create_server(image_id, plan_code, name)
+    json = {:new_vps => {:instantiation_options => {:domain_name => name, :distro => image_id},
+                        :pricing_plan_code => plan_code}}.to_json
+    request('/orders/new-vps',json, 'POST')[:about_order]
+  end
+end
+
+    end
+  end
+end

data/lib/deltacloud/drivers/rimuhosting/rimuhosting_driver.rb

@@ -0,0 +1,144 @@
+#
+# Copyright (C) 2009  RimuHosting Ltd
+# Author: Ivan Meredith <ivan@ivan.net.nz>
+#
+# 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 "deltacloud/base_driver"
+require "deltacloud/drivers/rimuhosting/rimuhosting_client"
+
+module Deltacloud
+  module Drivers
+    module RimuHosting
+
+class RimuHostingDriver < Deltacloud::BaseDriver
+
+  feature :instances, :user_name
+
+  def images(credentails, opts=nil)
+    rh = RimuHostingClient.new(credentails)
+    images = rh.list_images.map do | image |
+      Image.new({
+              :id => image["distro_code"].gsub(/\./,"-"),
+              :name => image["distro_code"],
+              :description => image["distro_description"],
+              :owner_id => "root",
+              :architecture => "x86"
+      })
+    end
+    images.sort_by{|e| [e.description]}
+    images = filter_on( images, :id, opts)
+    images
+  end
+
+  def hardware_profiles(credentials, opts = nil)
+    rh = RimuHostingClient.new(credentials)
+    results = rh.list_plans.map do |plan|
+      # FIXME: x86 is not a valid architecture; what is Rimu offering ?
+      # FIXME: VPS plans offer a range of memory/storage, but that's
+      #        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"
+      end
+    end
+    filter_hardware_profiles(results, opts)
+  end
+
+  def realms(credentials, opts=nil)
+    [Realm.new( {
+            :id=>"rimu",
+            :name=>"RimuHosting",
+            :state=> "AVAILABLE"
+    } )]
+  end
+
+  def instances(credentials, opts=nil)
+     rh = RimuHostingClient.new(credentials)
+    instances = rh.list_nodes.map do | inst |
+      convert_srv_to_instance(inst)
+    end
+    instances = filter_on( instances, :id, opts)
+    instances = filter_on( instances, :state, opts )
+    instances
+  end
+
+  def reboot_instance(credentials, id)
+     rh = RimuHostingClient.new(credentials)
+    rh.set_server_state(id, :RESTARTING)
+  end
+
+  def start_instance(credentials, id)
+    rh = RimuHostingClient.new(credentials)
+    rh.set_server_state(id, :STARTED)
+  end
+
+  def stop_instance(credentials, id)
+    destroy_instance(credentials, id)
+  end
+
+  def destroy_instance(credentials, id)
+     rh = RimuHostingClient.new(credentials)
+    rh.delete_server(id)
+  end
+
+  def create_instance(credentials, image_id, opts)
+     rh = RimuHostingClient.new(credentials)
+    # really need to raise an exception here.
+    hwp_id = opts[:hwp_id] || 1
+    # really bad, but at least its a fqdn
+    name = Time.now.to_s + '.com'
+    if (opts[:name]) then
+      name = opts[:name]
+    end
+    convert_srv_to_instance(rh.create_server(image_id, hwp_id, name))
+
+  end
+
+  def convert_srv_to_instance( inst )
+    Instance.new({
+            :id => inst["order_oid"].to_s,
+            :name => inst["domain_name"],
+            :image_id => "lenny",
+            :state => "RUNNING",
+            :name => inst["domain_name"],
+            :realm_id => "RH",
+            :owner_id => "root",
+            :instance_profile => InstanceProfile.new("none"),
+            :actions => instance_actions_for("RUNNING"),
+            :public_addresses => inst["allocated_ips"]["primary_ip"]
+    })
+  end
+
+  define_instance_states do
+    start.to( :pending )          .automatically
+
+    pending.to( :running )        .automatically
+
+    running.to( :running )        .on(:reboot)
+    running.to( :shutting_down )  .on(:stop)
+
+    shutting_down.to( :stopped )  .automatically
+
+    stopped.to( :finish )         .automatically
+  end
+
+
+end
+
+    end
+  end
+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