steamcannon-deltacloud-core 0.0.7.1

data/lib/deltacloud/drivers/rhevm/rhevm_driver.rb

@@ -0,0 +1,258 @@
+#
+# 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.
+
+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()
+    case st
+    when "UP"
+      "RUNNING"
+    when "DOWN"
+      "STOPPED"
+    when "POWERING UP"
+      "PENDING"
+  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

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

@@ -0,0 +1,85 @@
+#
+# Copyright (C) 2009  RimuHosting Ltd
+# Author: Ivan Meredith <ivan@ivan.net.nz>
+#
+# 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.
+
+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,166 @@
+#
+# Copyright (C) 2009  RimuHosting Ltd
+# Author: Ivan Meredith <ivan@ivan.net.nz>
+#
+# 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.
+
+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)
+    safely do
+      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
+    end
+    images.sort_by{|e| [e.description]}
+    images = filter_on( images, :id, opts)
+    images
+  end
+
+  def hardware_profiles(credentials, opts = nil)
+    safely do
+      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
+    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)
+    safely do
+      rh = RimuHostingClient.new(credentials)
+      instances = rh.list_nodes.map do | inst |
+        convert_srv_to_instance(inst)
+      end
+    end
+    instances = filter_on( instances, :id, opts)
+    instances = filter_on( instances, :state, opts )
+    instances
+  end
+
+  def reboot_instance(credentials, id)
+    safely do
+      rh = RimuHostingClient.new(credentials)
+      rh.set_server_state(id, :RESTARTING)
+    end
+  end
+
+  def start_instance(credentials, id)
+    safely do
+      rh = RimuHostingClient.new(credentials)
+      rh.set_server_state(id, :STARTED)
+    end
+  end
+
+  def stop_instance(credentials, id)
+    destroy_instance(credentials, id)
+  end
+
+  def destroy_instance(credentials, id)
+    safely do
+      rh = RimuHostingClient.new(credentials)
+      return rh.delete_server(id)
+    end
+  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"],
+            :launch_time => inst["billing_info"]["order_date"]["iso_format"]
+    })
+  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
+
+  def safely(&block)
+    begin
+      block.call
+    rescue Exception => e
+      raise Deltacloud::BackendError.new(500, e.class.to_s, e.message, e.backtrace)
+    end
+  end
+
+
+end
+
+    end
+  end
+end