class Deltacloud::Drivers::Aruba::ArubaDriver

Constants

DEFAULT_DC

Public Instance Methods

addresses(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 238
def addresses(credentials, opts={})
  client = new_client(credentials)
  safely do
    get_all(client, :purchased_ip_addresses, :ip_address).collect do |ip|
        Address.new(:id => ip[:value], :instance_id => ip[:server_id])
    end
  end
end
associate_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 268
def associate_address(credentials, opts={})
  client = new_client(credentials)
  safely do

    get_all(client, :purchased_ip_addresses, :ip_address).collect do |ip|
      if ip[:value] == opts[:id]
        details = request client, :server_details, {:serverId => opts[:instance_id]}
        params = {
         :ipAddressResourceIds => {"arr:int" => ip[:resource_id]},
         :networkAdapterId => details[:network_adapters][:network_adapter].first[:id]
        }
        request client, :enqueue_associate_ip_address, params, "set"
        return
      end
    end
    raise "Could not find ip #{opts[:id]}"
  end
end
configured_providers() click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 200
def configured_providers
  Deltacloud::Drivers::driver_config[:aruba][:entrypoints]["compute"].keys
end
create_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 247
def create_address(credentials, opts={})
  client = new_client(credentials)
  safely do
    ip = request(client, :purchase_ip_address, {}, "set")
    address = Address.new(:id => ip[:value], :instance_id => nil)
  end
end
create_instance(credentials, image_id, opts={}) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 138
def create_instance(credentials, image_id, opts={})
  client = new_client(credentials, opts[:realm_id])
  safely do
    ram = opts[:hwp_memory].to_i / 1024
    if not opts[:password] or opts[:password] == ''
      raise "Missing Parameter 'password'"
    end
    params = {
      :server => {
        "arub:AdministratorPassword" => opts[:password].to_s,
        "arub:CPUQuantity" => opts[:hwp_cpu].to_s,
        "arub:Name" => opts[:name],
        "arub:OSTemplateId" => opts[:image_id].to_s,
        "arub:RAMQuantity" => ram.to_s,
        "arub:VirtualDisks" => {
          "arub:VirtualDiskDetails" => {
            "arub:Size" => opts[:hwp_storage]
          }
        }
      }
    }
    # since Aruba API does not return the new server id when calling
    # set_enqueue_server_creation, get the server_id from the job list
    prev_jobs = get_jobs(client, "AddVirtualMachine")
    request(client, :enqueue_server_creation, params, "set")
    jobs = get_jobs(client, "AddVirtualMachine") - prev_jobs
    convert_instance(client, jobs.sort_by {|j| j[:job_id].to_i}.reverse.first[:server_id])
  end
end
destroy_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 255
def destroy_address(credentials, opts={})
  client = new_client(credentials)
  safely do
    get_all(client, :purchased_ip_addresses, :ip_address).collect do |ip|
      if ip[:value] == opts[:id]
        request client, :remove_ip_address, {:ipAddressResourceId => ip[:resource_id]}, "set"
        return
      end
    end
    raise "Could not find ip #{opts[:id]}"
  end
end
destroy_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 192
def destroy_instance(credentials, id)
  client = new_client(credentials)
  safely do
    request(client, :enqueue_server_deletion, {:serverId => id}, "set")
    convert_instance client, id
  end
end
disassociate_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 287
def disassociate_address(credentials, opts={})
  client = new_client(credentials)
  safely do
    get_all(client, :purchased_ip_addresses, :ip_address).collect do |ip|
      if ip[:value] == opts[:id]
        details = request client, :server_details, {:serverId => ip[:server_id]}
        params = {
         :ipAddressResourceIds => {"arr:int" => ip[:resource_id]},
         :networkAdapterId => details[:network_adapters][:network_adapter].first[:id]
        }
        request client, :enqueue_deassociate_ip_address, params, "set"
        return
      end
    end
    raise "Could not find ip #{opts[:id]}"
  end
end
images(credentials, opts = {}) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 94
def images(credentials, opts = {})
  client = new_client(credentials)
  safely do
    hvs = get_all client, :hypervisors
    images = []
    hvs.each do |hv|
      hv[:templates][:template_details].each do |tpl|
        if opts[:id] and opts[:id] != tpl[:id]
          next
        end
        arch = tpl[:description] !~ %r64bit/ ? "i386" : "x86_64"
        images << Image.new(
          :id => tpl[:id],
          :name => tpl[:name],
          :description => tpl[:description],
          :architecture => arch,
          :owner_id => 0,
          :state => "AVAILABLE",
          :hardware_profiles => [InstanceProfile.new(hv[:hypervisor_type])]
        )
      end
    end
    images = filter_on( images, :architecture, opts )
    images = filter_on( images, :owner_id, opts )
    images = filter_on( images, :id, opts )
    images.sort_by{|e| [e.owner_id, e.architecture, e.name, e.description]}
  end
end
instances(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 123
def instances(credentials, opts={})
  client = new_client(credentials)

  safely do
    if opts[:id]
      instances = [convert_instance(client, opts[:id])]
    else
      instances = get_all(client, :servers).collect do |srv|
        convert_instance(client, srv[:server_id])
      end
    end
    filter_on(instances, :state, opts)
  end
end
realms(credentials, opts=nil) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 76
def realms(credentials, opts=nil)
  client = new_client(credentials)
  safely do
    datacenters = get_all(client,
                          :datacenter_configurations,
                          :datacenter_config).inject([]) do |res, dc|
      res << Realm.new(
        :id => dc[:datacenter_id],
        :name => dc[:name],
        :limit => :unlimited,
        :state => dc[:status]
      )
      res
    end
    datacenters
  end
end
reboot_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 184
def reboot_instance(credentials, id)
  client = new_client(credentials)
  safely do
    request(client, :enqueue_server_restart, {:serverId => id}, "set")
    convert_instance client, id
  end
end
start_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 168
def start_instance(credentials, id)
  client = new_client(credentials)
  safely do
    request(client, :enqueue_server_start, {:serverId => id}, "set")
    convert_instance client, id
  end
end
stop_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 176
def stop_instance(credentials, id)
  client = new_client(credentials)
  safely do
    request(client, :enqueue_server_stop, {:serverId => id}, "set")
    convert_instance client, id
  end
end
storage_volumes(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 204
def storage_volumes(credentials, opts={})
  client = new_client(credentials)
  safely do
    servers = get_all client, :servers
    volumes = servers.inject([]) do |result, srv|
      instance = convert_instance(client, srv[:server_id])
      details = request client, :server_details, {:serverId => instance.id}
      vdisks = details[:virtual_disks][:virtual_disk]
      vdisks = vdisks.kind_of?(Array) ? vdisks : [vdisks]
      vdisks.each do |vd|
        if instance.state == "STOPPED"
          actions = vd[:resource_type] == "HardDrive0" ? [:snapshot] : [:snapshot, :detach]
        else
          actions = []
        end
        result << StorageVolume.new(
          :id => vd[:resource_id],
          :name => "#{instance.name}-#{vd[:resource_type]}",
          :capacity => vd[:size],
          :instance_id => instance.id,
          :realm_id => instance.realm_id,
          :state => "IN-USE",
          :created => vd[:creation_date],
          :kind => 'data',
          :actions => actions,
          :device => nil
        ) if opts[:id].nil? or opts[:id] == vd[:resource_id]
      end
      result
    end
    volumes
  end
end
valid_credentials?(credentials) click to toggle source
# File lib/deltacloud/drivers/aruba/aruba_driver.rb, line 67
def valid_credentials?(credentials)
  begin
    new_client(credentials)
  rescue
    return false
  end
  true
end