addresses(credentials, opts={})
click to toggle source
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
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
create_address(credentials, opts={})
click to toggle source
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
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]
}
}
}
}
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
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
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
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
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
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
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
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
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
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
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
def valid_credentials?(credentials)
begin
new_client(credentials)
rescue
return false
end
true
end