bbrowning-deltacloud-core 0.0.1.1

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

@@ -0,0 +1,129 @@
+#
+# 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 "net/http"
+require "net/https"
+require 'rubygems'
+require 'json'
+
+#
+# author: Michael Neale
+# TODO: catch generic errors in JSON response and throw (probably)
+#
+module Deltacloud
+  module Drivers
+    module Rackspace
+
+class RackspaceClient
+
+  @@AUTH_API = URI.parse('https://auth.api.rackspacecloud.com/v1.0')
+
+  def initialize(username, auth_key)
+    http = Net::HTTP.new(@@AUTH_API.host,@@AUTH_API.port)
+    http.use_ssl = true
+    authed = http.get(@@AUTH_API.path, {'X-Auth-User' => username, 'X-Auth-Key' => auth_key})
+    if authed.is_a?(Net::HTTPUnauthorized)
+      raise Deltacloud::AuthException, "Failed to authenticate to Rackspace"
+    elsif !authed.is_a?(Net::HTTPSuccess)
+      backend_error!(resp)
+    end
+    @auth_token  = authed.header['X-Auth-Token']
+    @service_uri = URI.parse(authed.header['X-Server-Management-Url'])
+    @service = Net::HTTP.new(@service_uri.host, @service_uri.port)
+    @service.use_ssl = true
+  end
+
+  def list_flavors
+    JSON.parse(get('/flavors/detail'))['flavors']
+  end
+
+  def list_images
+    JSON.parse(get('/images/detail'))['images']
+  end
+
+  def list_servers
+      JSON.parse(get('/servers/detail'))['servers']
+  end
+
+
+  def load_server_details( server_id )
+    JSON.parse(get("/servers/#{server_id}"))['server']
+  end
+
+
+  def start_server(image_id, flavor_id, name)
+    json = { :server => { :name => name,
+                          :imageId => image_id.to_i,
+                          :flavorId => flavor_id.to_i }}.to_json
+    # FIXME: The response has the root password in 'adminPass'; we somehow
+    # need to communicate this back since it's the only place where we can
+    # get it from
+    JSON.parse(post("/servers", json, headers).body)["server"]
+  end
+
+  def delete_server(server_id)
+    delete("/servers/#{server_id}", headers)
+  end
+
+  def reboot_server(server_id)
+    json = { :reboot => { :type => :SOFT }}.to_json
+    post("/servers/#{server_id}/action", json, headers)
+  end
+
+
+  def headers
+    {"Accept" => "application/json", "X-Auth-Token" => @auth_token, "Content-Type" => "application/json"}
+  end
+
+  private
+  def get(path)
+    resp = @service.get(@service_uri.path + path, {"Accept" => "application/json", "X-Auth-Token" => @auth_token})
+    unless resp.is_a?(Net::HTTPSuccess)
+      backend_error!(resp)
+    end
+    resp.body
+  end
+
+  def post(path, json, headers)
+    resp = @service.post(@service_uri.path + path, json, headers)
+    unless resp.is_a?(Net::HTTPSuccess)
+      backend_error!(resp)
+    end
+    resp
+  end
+
+  def delete(path, headers)
+    resp = @service.delete(@service_uri.path + path, headers)
+    unless resp.is_a?(Net::HTTPSuccess)
+      backend_error!(resp)
+    end
+    resp
+  end
+
+  def backend_error!(resp)
+    json = JSON.parse(resp.body)
+    cause = json.keys[0]
+    code = json[cause]["code"]
+    message = json[cause]["message"]
+    details = json[cause]["details"]
+    raise Deltacloud::BackendError.new(code, cause, message, details)
+  end
+
+end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+#
+# 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 'deltacloud/base_driver'
+require 'deltacloud/drivers/rackspace/rackspace_client'
+
+module Deltacloud
+  module Drivers
+    module Rackspace
+
+class RackspaceDriver < Deltacloud::BaseDriver
+
+  feature :instances, :user_name
+
+  def hardware_profiles(credentials, opts = nil)
+    racks = new_client( credentials )
+    results = racks.list_flavors.map do |flav|
+      HardwareProfile.new(flav["id"].to_s) do
+        architecture 'x86_64'
+        memory flav["ram"].to_i
+        storage flav["disk"].to_i
+      end
+    end
+    filter_hardware_profiles(results, opts)
+  end
+
+  def images(credentials, opts=nil)
+    racks = new_client( credentials )
+    results = racks.list_images.map do |img|
+      Image.new( {
+                   :id=>img["id"].to_s,
+                   :name=>img["name"],
+                   :description => img["name"] + " " + img["status"] + "",
+                   :owner_id=>"root",
+                   :architecture=>'x86_64'
+                 } )
+    end
+    results.sort_by{|e| [e.description]}
+    results = filter_on( results, :id, opts )
+    results
+  end
+
+  #rackspace does not at this stage have realms... its all US/TX, all the time (at least at time of writing)
+  def realms(credentials, opts=nil)
+    [Realm.new( {
+      :id=>"us",
+      :name=>"United States",
+      :state=> "AVAILABLE"
+    } )]
+  end
+
+  def reboot_instance(credentials, id)
+    racks = new_client(credentials)
+    racks.reboot_server(id)
+  end
+
+  def stop_instance(credentials, id)
+    destroy_instance(credentials, id)
+  end
+
+  def destroy_instance(credentials, id)
+    racks = new_client(credentials)
+    racks.delete_server(id)
+  end
+
+
+  #
+  # create instance. Default to flavor 1 - really need a name though...
+  # In rackspace, all flavors work with all images.
+  #
+  def create_instance(credentials, image_id, opts)
+    racks = new_client( credentials )
+    hwp_id = opts[:hwp_id] || 1
+    name = Time.now.to_s
+    if (opts[:name]) then name = opts[:name] end
+    convert_srv_to_instance(racks.start_server(image_id, hwp_id, name))
+  end
+
+  #
+  # Instances
+  #
+  def instances(credentials, opts=nil)
+    racks = new_client(credentials)
+    instances = []
+    if (opts.nil?)
+      instances = racks.list_servers.map do |srv|
+        convert_srv_to_instance(srv)
+      end
+    else
+      instances << convert_srv_to_instance(racks.load_server_details(opts[:id]))
+    end
+    instances = filter_on( instances, :id, opts )
+    instances = filter_on( instances, :state, opts )
+    instances
+  end
+
+
+  def convert_srv_to_instance(srv)
+    status = srv["status"] == "ACTIVE" ? "RUNNING" : "PENDING"
+    inst = Instance.new(:id => srv["id"].to_s,
+                        :owner_id => "root",
+                        :realm_id => "us")
+    inst.name = srv["name"]
+    inst.state = srv["status"] == "ACTIVE" ? "RUNNING" : "PENDING"
+    inst.actions = instance_actions_for(inst.state)
+    inst.image_id = srv["imageId"].to_s
+    inst.instance_profile = InstanceProfile.new(srv["flavorId"].to_s)
+    if srv["addresses"]
+      inst.public_addresses  = srv["addresses"]["public"]
+      inst.private_addresses = srv["addresses"]["private"]
+    end
+    inst
+  end
+
+  def new_client(credentials)
+    RackspaceClient.new(credentials.user, credentials.password)
+  end
+
+  define_instance_states do
+    start.to( :pending )          .on( :create )
+
+    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/rhevm/rhevm_driver.rb

@@ -0,0 +1,254 @@
+#
+# 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 'deltacloud/base_driver'
+require 'yaml'
+
+module Deltacloud
+  module Drivers
+    module RHEVM
+
+class RHEVMDriver < Deltacloud::BaseDriver
+
+  SCRIPT_DIR = File.dirname(__FILE__) + '/scripts'
+  CONFIG = YAML.load_file(File.dirname(__FILE__) + '/../../../../config/rhevm_config.yml')
+  SCRIPT_DIR_ARG = '"' + SCRIPT_DIR + '"'
+  DELIM_BEGIN="<_OUTPUT>"
+  DELIM_END="</_OUTPUT>"
+  POWERSHELL="c:\\Windows\\system32\\WindowsPowerShell\\v1.0\\powershell.exe"
+  NO_OWNER=""
+
+  feature :instances, :user_name
+
+  #
+  # Execute a Powershell command, and convert the output
+  # to YAML in order to get back an array of maps.
+  #
+  def execute(credentials, command, *args)
+    args = args.to_a
+    argString = genArgString(credentials, args)
+    puts argString
+    outputMaps = {}
+    output = `#{POWERSHELL} -command "&{#{File.join(SCRIPT_DIR, command)} #{argString}; exit $LASTEXITCODE}`
+    exitStatus = $?.exitstatus
+    puts(output)
+    puts("EXITSTATUS #{exitStatus}")
+    st = output.index(DELIM_BEGIN)
+    if (st)
+      st += DELIM_BEGIN.length
+      ed = output.index(DELIM_END)
+      output = output.slice(st, (ed-st))
+      # Lets make it yaml
+      output.strip!
+      if (output.length > 0)
+        outputMaps = YAML.load(self.toYAML(output))
+      end
+    end
+    outputMaps
+  end
+
+  def genArgString(credentials, args)
+    commonArgs = [SCRIPT_DIR_ARG, credentials.user, credentials.password, CONFIG["domain"]]
+    commonArgs.concat(args)
+    commonArgs.join(" ")
+  end
+
+  def toYAML(output)
+    yOutput = "- \n" + output
+    yOutput.gsub!(/^(\w*)[ ]*:[ ]*([A-Z0-9a-z._ -:{}]*)/,' \1: "\2"')
+    yOutput.gsub!(/^[ ]*$/,"- ")
+    puts(yOutput)
+    yOutput
+  end
+
+  def statify(state)
+    st = state.nil? ? "" : state.upcase()
+    return "running" if st == "UP"
+    return "stopped" if st == "DOWN"
+    return "pending" if st == "POWERING UP"
+    st
+  end
+
+  define_hardware_profile 'rhevm'
+
+  #
+  # Realms
+  #
+
+  def realms(credentials, opts=nil)
+    domains = execute(credentials, "storageDomains.ps1")
+    if (!opts.nil? && opts[:id])
+        domains = domains.select{|d| opts[:id] == d["StorageId"]}
+    end
+
+    realms = []
+    domains.each do |dom|
+      realms << domain_to_realm(dom)
+    end
+    realms
+  end
+
+  def domain_to_realm(dom)
+    Realm.new({
+      :id => dom["StorageId"],
+      :name => dom["Name"],
+      :limit => dom["AvailableDiskSize"]
+    })
+  end
+
+
+
+  #
+  # Images
+  #
+
+  def images(credentials, opts=nil )
+    templates = []
+    if (opts.nil?)
+      templates = execute(credentials, "templates.ps1")
+    else
+      if (opts[:id])
+        templates = execute(credentials, "templateById.ps1", opts[:id])
+      end
+    end
+    images = []
+    templates.each do |templ|
+      images << template_to_image(templ)
+    end
+    images
+  end
+
+  def template_to_image(templ)
+    Image.new({
+      :id => templ["TemplateId"],
+      :name => templ["Name"],
+      :description => templ["Description"],
+      :architecture => templ["OperatingSystem"],
+      :owner_id => NO_OWNER,
+      :mem_size_md => templ["MemSizeMb"],
+      :instance_count => templ["ChildCount"],
+      :state => templ["Status"],
+      :capacity => templ["SizeGB"]
+    })
+  end
+
+  #
+  # Instances
+  #
+
+  define_instance_states do
+    start.to(:stopped)            .on( :create )
+
+    pending.to(:shutting_down)    .on( :stop )
+    pending.to(:running)          .automatically
+
+    running.to(:pending)          .on( :reboot )
+    running.to(:shutting_down)    .on( :stop )
+
+    shutting_down.to(:stopped)    .automatically
+    stopped.to(:pending)          .on( :start )
+    stopped.to(:finish)           .on( :destroy )
+  end
+
+  def instances(credentials, opts=nil)
+    vms = []
+    if (opts.nil?)
+      vms = execute(credentials, "vms.ps1")
+    else
+      if (opts[:id])
+        vms = execute(credentials, "vmById.ps1", opts[:id])
+      end
+    end
+    instances = []
+    vms.each do |vm|
+      instances << vm_to_instance(vm)
+    end
+    instances = filter_on( instances, :id, opts )
+    instances = filter_on( instances, :state, opts )
+    instances
+  end
+
+  def vm_to_instance(vm)
+    Instance.new({
+      :id => vm["VmId"],
+      :description => vm["Description"],
+      :name => vm["Name"],
+      :architecture => vm["OperatingSystem"],
+      :owner_id => NO_OWNER,
+      :image_id => vm["TemplateId"],
+      :state => statify(vm["Status"]),
+      :instance_profile => InstanceProfile.new("rhevm"),
+      :actions => instance_actions_for(statify(vm["Status"])),
+    })
+  end
+
+  def start_instance(credentials, image_id)
+    vm = execute(credentials, "startVm.ps1", image_id)
+    vm_to_instance(vm[0])
+  end
+
+  def stop_instance(credentials, image_id)
+    vm = execute(credentials, "stopVm.ps1", image_id)
+    vm_to_instance(vm[0])
+  end
+
+  def create_instance(credentials, image_id, opts)
+    name = opts[:name]
+    name = "Inst-#{rand(10000)}" if (name.nil? or name.empty?)
+    realm_id = opts[:realm_id]
+    if (realm_id.nil?)
+        realms = filter_on(realms(credentials, opts), :name, :name => "data")
+        puts realms[0]
+        realm_id = realms[0].id
+    end
+    vm = execute(credentials, "addVm.ps1", image_id, name, realm_id)
+    vm_to_instance(vm[0])
+  end
+
+  def reboot_instance(credentials, image_id)
+    vm = execute(credentials, "rebootVm.ps1", image_id)
+    vm_to_instance(vm[0])
+  end
+
+  def destroy_instance(credentials, image_id)
+    vm = execute(credentials, "deleteVm.ps1", image_id)
+    vm_to_instance(vm[0])
+  end
+
+  #
+  # Storage Volumes
+  #
+
+  def storage_volumes(credentials, ids=nil)
+    volumes = []
+    volumes
+  end
+
+  #
+  # Storage Snapshots
+  #
+
+  def storage_snapshots(credentials, ids=nil)
+    snapshots = []
+    snapshots
+  end
+
+end
+
+    end
+  end
+end