shaba/one
1
0
Fork 0
mirror of https://github.com/OpenNebula/one.git synced 2025-03-21 14:50:08 +03:00
Code Releases Wiki Activity

Merge branch 'feature-1091'

Browse Source
This commit is contained in:
Ruben S. Montero 2012-02-13 14:57:58 +01:00
commit 17ac1484bd
11 changed files with 159 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/cloud/common/CloudClient.rb
View File

@ -61,7 +61,7 @@ module CloudClient
# #########################################################################
def self.get_one_auth
if ENV["ONE_AUTH"] and !ENV["ONE_AUTH"].empty? and
File.file?(ENV["ONE_AUTH"])
File.file?(ENV["ONE_AUTH"])
one_auth=File.read(ENV["ONE_AUTH"]).strip.split(':')
elsif File.file?(DEFAULT_AUTH_FILE)
one_auth=File.read(DEFAULT_AUTH_FILE).strip.split(':')
@ -91,24 +91,30 @@ module CloudClient
end
begin
http.start do |connection|
res = http.start do |connection|
block.call(connection)
end
rescue Errno::ECONNREFUSED => e
str = "Error connecting to server (#{e.to_s}).\n"
str << "Server: #{url.host}:#{url.port}"
return CloudClient::Error.new(str)
return CloudClient::Error.new(str,"503")
rescue Errno::ETIMEDOUT => e
str = "Error timeout connecting to server (#{e.to_s}).\n"
str << "Server: #{url.host}:#{url.port}"
return CloudClient::Error.new(str)
return CloudClient::Error.new(str,"504")
rescue Timeout::Error => e
str = "Error timeout while connected to server (#{e.to_s}).\n"
str << "Server: #{url.host}:#{url.port}"
return CloudClient::Error.new(str)
return CloudClient::Error.new(str,"504")
end
if res.is_a?(Net::HTTPSuccess)
res
else
CloudClient::Error.new(res.body, res.code)
end
end
@ -118,10 +124,12 @@ module CloudClient
# #########################################################################
class Error
attr_reader :message
attr_reader :code
# +message+ a description of the error
def initialize(message=nil)
def initialize(message=nil, code="500")
@message=message
@code=code
end
def to_s()
@ -140,7 +148,7 @@ end
# Command line help functions
module CloudCLI
def print_xml(xml_text)
def print_xml(xml_text)
begin
doc = REXML::Document.new(xml_text)
rescue REXML::ParseException => e

2
src/cloud/occi/lib/ImageOCCI.rb
View File

@ -23,6 +23,8 @@ class ImageOCCI < Image
<STORAGE href="<%= base_url %>/storage/<%= self.id.to_s %>">
<ID><%= self.id.to_s %></ID>
<NAME><%= self.name %></NAME>
<USER href="<%= base_url %>/user/<%= self['UID'] %>" name="<%= self['UNAME'] %>"/>
<GROUP><%= self['GNAME'] %></GROUP>
<STATE><%= self.state_str %></STATE>
<% if self['TYPE'] != nil %>
<TYPE><%= self.type_str %></TYPE>

13
src/cloud/occi/lib/ImagePoolOCCI.rb
View File

@ -14,20 +14,21 @@
# limitations under the License. #
#--------------------------------------------------------------------------- #
require 'OpenNebula'
include OpenNebula
require 'ImageOCCI'
class ImagePoolOCCI < ImagePool
OCCI_IMAGE_POOL = %q{
<STORAGE_COLLECTION>
<% self.each{ |im| %>
<% if verbose %>
<%= im.to_occi(base_url) %>
<% else %>
<STORAGE href="<%= base_url %>/storage/<%= im.id.to_s %>" name="<%= im.name %>"/>
<% end %>
<% } %>
</STORAGE_COLLECTION>
}
# Creates the OCCI representation of a Virtual Machine Pool
def to_occi(base_url)
begin
@ -40,5 +41,9 @@ class ImagePoolOCCI < ImagePool
return occi_text.gsub(/\n\s*/,'')
end
def factory(element_xml)
ImageOCCI.new(element_xml,@client)
end
end

326
src/cloud/occi/lib/OCCIClient.rb
View File

@ -30,11 +30,13 @@ module OCCIClient
#####################################################################
class Client
attr_accessor :endpoint
######################################################################
# Initialize client library
######################################################################
def initialize(endpoint_str=nil, user=nil, pass=nil,
timeout=nil, debug_flag=true)
timeout=nil, debug_flag=true)
@debug = debug_flag
@timeout = timeout
@ -65,50 +67,30 @@ module OCCIClient
# Pool Resource Request Methods #
#################################
def get_root
get('/')
end
######################################################################
# Retieves the available Instance types
######################################################################
def get_instance_types
get('/instance_type')
end
######################################################################
# Post a new VM to the VM Pool
# :instance_type
# :xmlfile
######################################################################
def post_vms(xmlfile)
xml=File.read(xmlfile)
url = URI.parse(@endpoint+"/compute")
req = Net::HTTP::Post.new(url.path)
req.body=xml
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) do |http|
http.request(req)
end
if CloudClient::is_error?(res)
return res
else
return res.body
end
post('/compute', xmlfile)
end
######################################################################
# Retieves the pool of Virtual Machines
######################################################################
def get_vms
url = URI.parse(@endpoint+"/compute")
req = Net::HTTP::Get.new(url.path)
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) {|http|
http.request(req)
}
if CloudClient::is_error?(res)
return res
else
return res.body
end
get('/compute')
end
######################################################################
@ -116,44 +98,14 @@ module OCCIClient
# :xmlfile xml description of the Virtual Network
######################################################################
def post_network(xmlfile)
xml=File.read(xmlfile)
url = URI.parse(@endpoint+"/network")
req = Net::HTTP::Post.new(url.path)
req.body=xml
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) do |http|
http.request(req)
end
if CloudClient::is_error?(res)
return res
else
return res.body
end
post('/network', xmlfile)
end
######################################################################
# Retieves the pool of Virtual Networks
######################################################################
def get_networks
url = URI.parse(@endpoint+"/network")
req = Net::HTTP::Get.new(url.path)
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) {|http|
http.request(req)
}
if CloudClient::is_error?(res)
return res
else
return res.body
end
get('/network')
end
######################################################################
@ -251,22 +203,10 @@ module OCCIClient
# Retieves the pool of Images owned by the user
######################################################################
def get_images
url = URI.parse(@endpoint+"/storage")
req = Net::HTTP::Get.new(url.path)
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) {|http|
http.request(req)
}
if CloudClient::is_error?(res)
return res
else
return res.body
end
get('/storage')
end
####################################
# Entity Resource Request Methods #
####################################
@ -275,20 +215,7 @@ module OCCIClient
# :id VM identifier
######################################################################
def get_vm(id)
url = URI.parse(@endpoint+"/compute/" + id.to_s)
req = Net::HTTP::Get.new(url.path)
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) {|http|
http.request(req)
}
if CloudClient::is_error?(res)
return res
else
return res.body
end
get('/compute/'+id.to_s)
end
######################################################################
@ -296,57 +223,14 @@ module OCCIClient
# :xmlfile Compute OCCI xml representation
######################################################################
def put_vm(xmlfile)
xml = File.read(xmlfile)
begin
vm_info = REXML::Document.new(xml).root
rescue Exception => e
error = CloudClient::Error.new(e.message)
return error
end
if vm_info.elements['ID'] == nil
return CloudClient::Error.new("Can not find COMPUTE_ID")
end
vm_id = vm_info.elements['ID'].text
url = URI.parse(@endpoint+'/compute/' + vm_id)
req = Net::HTTP::Put.new(url.path)
req.body = xml
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) do |http|
http.request(req)
end
if CloudClient::is_error?(res)
return res
else
return res.body
end
put('/compute/', xmlfile)
end
####################################################################
# :id Compute identifier
####################################################################
def delete_vm(id)
url = URI.parse(@endpoint+"/compute/" + id.to_s)
req = Net::HTTP::Delete.new(url.path)
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) {|http|
http.request(req)
}
if CloudClient::is_error?(res)
return res
else
return res.body
end
delete('/compute/'+id.to_s)
end
######################################################################
@ -354,20 +238,7 @@ module OCCIClient
# :id Virtual Network identifier
######################################################################
def get_network(id)
url = URI.parse(@endpoint+"/network/" + id.to_s)
req = Net::HTTP::Get.new(url.path)
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) {|http|
http.request(req)
}
if CloudClient::is_error?(res)
return res
else
return res.body
end
get('/network/'+id.to_s)
end
######################################################################
@ -375,78 +246,22 @@ module OCCIClient
# :xmlfile Network OCCI xml representation
######################################################################
def put_network(xmlfile)
xml = File.read(xmlfile)
begin
vnet_info = REXML::Document.new(xml).root
rescue Exception => e
error = CloudClient::Error.new(e.message)
return error
end
if vnet_info.elements['ID'] == nil
return CloudClient::Error.new("Can not find NETWORK_ID")
end
vnet_id = vnet_info.elements['ID'].text
url = URI.parse(@endpoint+'/network/' + vnet_id)
req = Net::HTTP::Put.new(url.path)
req.body = xml
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) do |http|
http.request(req)
end
if CloudClient::is_error?(res)
return res
else
return res.body
end
put('/network/', xmlfile)
end
######################################################################
# :id VM identifier
######################################################################
def delete_network(id)
url = URI.parse(@endpoint+"/network/" + id.to_s)
req = Net::HTTP::Delete.new(url.path)
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) {|http|
http.request(req)
}
if CloudClient::is_error?(res)
return res
else
return res.body
end
delete('/network/'+id.to_s)
end
#######################################################################
#######################################################################
# Retieves an Image
# :image_uuid Image identifier
######################################################################
def get_image(image_uuid)
url = URI.parse(@endpoint+"/storage/"+image_uuid)
req = Net::HTTP::Get.new(url.path)
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) {|http|
http.request(req)
}
if CloudClient::is_error?(res)
return res
else
return res.body
end
def get_image(id)
get('/storage/'+id.to_s)
end
######################################################################
@ -454,26 +269,67 @@ module OCCIClient
# :xmlfile Storage OCCI xml representation
######################################################################
def put_image(xmlfile)
xml = File.read(xmlfile)
put('/storage/', xmlfile)
end
######################################################################
# :id VM identifier
######################################################################
def delete_image(id)
delete('/storage/'+id.to_s)
end
private
def get(path)
url = URI.parse(@endpoint+path)
req = Net::HTTP::Get.new(url.path)
do_request(url, req)
end
def post(path, xmlfile)
url = URI.parse(@endpoint+path)
req = Net::HTTP::Post.new(url.path)
req.body=File.read(xmlfile)
do_request(url, req)
end
def delete(path, xmlfile)
url = URI.parse(@endpoint+path)
req = Net::HTTP::Delete.new(url.path)
do_request(url, req)
end
def put(path, xmlfile)
xml = File.read(xmlfile)
# Get ID from XML
begin
image_info = REXML::Document.new(xml).root
info = REXML::Document.new(xml).root
rescue Exception => e
error = OpenNebula::Error.new(e.message)
error = CloudClient::Error.new(e.message)
return error
end
if image_info.elements['ID'] == nil
return CloudClient::Error.new("Can not find STORAGE_ID")
if info.elements['ID'] == nil
return CloudClient::Error.new("Can not find RESOURCE ID")
end
image_id = image_info.elements['ID'].text
url = URI.parse(@endpoint+'/storage/' + image_id)
resource_id = info.elements['ID'].text
url = URI.parse(@endpoint+path + resource_id)
req = Net::HTTP::Put.new(url.path)
req.body = xml
do_request(url, req)
end
def do_request(url, req)
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) do |http|
@ -486,25 +342,5 @@ module OCCIClient
return res.body
end
end
######################################################################
# :id VM identifier
######################################################################
def delete_image(id)
url = URI.parse(@endpoint+"/storage/" + id.to_s)
req = Net::HTTP::Delete.new(url.path)
req.basic_auth @occiauth[0], @occiauth[1]
res = CloudClient::http_start(url, @timeout) {|http|
http.request(req)
}
if CloudClient::is_error?(res)
return res
else
return res.body
end
end
end
end
end

34
src/cloud/occi/lib/OCCIServer.rb
View File

@ -62,11 +62,11 @@ class OCCIServer < CloudServer
# Prepare the OCCI XML Response
# resource:: _Pool_ or _PoolElement_ that represents a OCCI resource
# [return] _String_,_Integer_ Resource Representation or error, status code
def to_occi_xml(resource, code)
xml_response = resource.to_occi(@base_url)
def to_occi_xml(resource, opts)
xml_response = resource.to_occi(@base_url, opts[:verbose])
return xml_response, 500 if OpenNebula.is_error?(xml_response)
return xml_response, code
return xml_response, opts[:code]
end
############################################################################
@ -122,7 +122,7 @@ class OCCIServer < CloudServer
return rc, CloudServer::HTTP_ERROR_CODE[rc.errno]
end
return to_occi_xml(vmpool, 200)
return to_occi_xml(vmpool, :status=>200, :verbose=>request.params['verbose'])
end
@ -142,7 +142,7 @@ class OCCIServer < CloudServer
return rc, CloudServer::HTTP_ERROR_CODE[rc.errno]
end
return to_occi_xml(network_pool, 200)
return to_occi_xml(network_pool, :status=>200, :verbose=>request.params['verbose'])
end
# Gets the pool representation of STORAGES
@ -161,7 +161,7 @@ class OCCIServer < CloudServer
return rc, CloudServer::HTTP_ERROR_CODE[rc.errno]
end
return to_occi_xml(image_pool, 200)
return to_occi_xml(image_pool, :status=>200, :verbose=>request.params['verbose'])
end
# Gets the pool representation of USERs
@ -178,7 +178,7 @@ class OCCIServer < CloudServer
return rc, CloudServer::HTTP_ERROR_CODE[rc.errno]
end
return to_occi_xml(user_pool, 200)
return to_occi_xml(user_pool, :status=>200, :verbose=>request.params['verbose'])
end
############################################################################
@ -214,7 +214,7 @@ class OCCIServer < CloudServer
# --- Prepare XML Response ---
vm.info
return to_occi_xml(vm, 201)
return to_occi_xml(vm, :status=>201)
end
# Get the representation of a COMPUTE resource
@ -233,7 +233,7 @@ class OCCIServer < CloudServer
return rc, CloudServer::HTTP_ERROR_CODE[rc.errno]
end
return to_occi_xml(vm, 200)
return to_occi_xml(vm, :status=>200)
end
@ -277,7 +277,7 @@ class OCCIServer < CloudServer
return result, code
else
vm.info
return to_occi_xml(vm, code)
return to_occi_xml(vm, :status=>code)
end
end
@ -307,7 +307,7 @@ class OCCIServer < CloudServer
# --- Prepare XML Response ---
network.info
return to_occi_xml(network, 201)
return to_occi_xml(network, :status=>201)
end
# Retrieves a NETWORK resource
@ -325,7 +325,7 @@ class OCCIServer < CloudServer
return rc, CloudServer::HTTP_ERROR_CODE[rc.errno]
end
return to_occi_xml(network, 200)
return to_occi_xml(network, :status=>200)
end
# Deletes a NETWORK resource
@ -371,7 +371,7 @@ class OCCIServer < CloudServer
# --- Prepare XML Response ---
vnet.info
return to_occi_xml(vnet, 202)
return to_occi_xml(vnet, :status=>202)
end
############################################################################
@ -411,7 +411,7 @@ class OCCIServer < CloudServer
# --- Prepare XML Response ---
image.info
return to_occi_xml(image, 201)
return to_occi_xml(image, :status=>201)
end
# Get a STORAGE resource
@ -430,7 +430,7 @@ class OCCIServer < CloudServer
end
# --- Prepare XML Response ---
return to_occi_xml(image, 200)
return to_occi_xml(image, :status=>200)
end
# Deletes a STORAGE resource (Not yet implemented)
@ -484,7 +484,7 @@ class OCCIServer < CloudServer
# --- Prepare XML Response ---
image.info
return to_occi_xml(image, 202)
return to_occi_xml(image, :status=>202)
end
# Get the representation of a USER
@ -503,6 +503,6 @@ class OCCIServer < CloudServer
return rc, CloudServer::HTTP_ERROR_CODE[rc.errno]
end
return to_occi_xml(user, 200)
return to_occi_xml(user, :status=>200)
end
end

1
src/cloud/occi/lib/UserOCCI.rb
View File

@ -27,6 +27,7 @@ class UserOCCI < User
<USER href="<%= base_url %>/user/<%= self.id.to_s %>">
<ID><%= self.id.to_s %></ID>
<NAME><%= self.name %></NAME>
<GROUP><%= self['GNAME'] %></GROUP>
<QUOTA>
<% user_quota.each { |key,value|
key_s = key.to_s.upcase

13
src/cloud/occi/lib/UserPoolOCCI.rb
View File

@ -14,20 +14,21 @@
# limitations under the License. #
#--------------------------------------------------------------------------- #
require 'OpenNebula'
include OpenNebula
require 'UserOCCI'
class UserPoolOCCI < UserPool
OCCI_USER_POOL = %q{
<USER_COLLECTION>
<% self.each{ |user| %>
<% if verbose %>
<%= user.to_occi(base_url) %>
<% else %>
<USER href="<%= base_url %>/user/<%= user.id.to_s %>" name="<%= user.name %>"/>
<% end %>
<% } %>
</USER_COLLECTION>
}
# Creates the OCCI representation of a User Pool
def to_occi(base_url)
begin
@ -40,4 +41,8 @@ class UserPoolOCCI < UserPool
return occi_text.gsub(/\n\s*/,'')
end
def factory(element_xml)
UserOCCI.new(element_xml,@client)
end
end

2
src/cloud/occi/lib/VirtualMachineOCCI.rb
View File

@ -22,6 +22,8 @@ class VirtualMachineOCCI < VirtualMachine
OCCI_VM = %q{
<COMPUTE href="<%= base_url %>/compute/<%= self.id.to_s %>">
<ID><%= self.id.to_s%></ID>
<USER href="<%= base_url %>/user/<%= self['UID'] %>" name="<%= self['UNAME'] %>"/>
<GROUP><%= self['GNAME'] %></GROUP>
<CPU><%= self['TEMPLATE/CPU'] %></CPU>
<MEMORY><%= self['TEMPLATE/MEMORY'] %></MEMORY>
<NAME><%= self.name%></NAME>

16
src/cloud/occi/lib/VirtualMachinePoolOCCI.rb
View File

@ -14,22 +14,24 @@
# limitations under the License. #
#--------------------------------------------------------------------------- #
require 'OpenNebula'
include OpenNebula
require 'VirtualMachineOCCI'
class VirtualMachinePoolOCCI < VirtualMachinePool
OCCI_VM_POOL = %q{
<COMPUTE_COLLECTION>
<% self.each{ |vm| %>
<% self.each{ |vm| %>
<% if verbose %>
<%= vm.to_occi(base_url) %>
<% else %>
<COMPUTE href="<%= base_url %>/compute/<%= vm.id.to_s %>" name="<%= vm.name %>"/>
<% end %>
<% } %>
</COMPUTE_COLLECTION>
}
# Creates the OCCI representation of a Virtual Machine Pool
def to_occi(base_url)
def to_occi(base_url, verbose=false)
begin
occi = ERB.new(OCCI_VM_POOL)
occi_text = occi.result(binding)
@ -40,5 +42,9 @@ class VirtualMachinePoolOCCI < VirtualMachinePool
return occi_text.gsub(/\n\s*/,'')
end
def factory(element_xml)
VirtualMachineOCCI.new(element_xml,@client)
end
end

2
src/cloud/occi/lib/VirtualNetworkOCCI.rb
View File

@ -24,6 +24,8 @@ class VirtualNetworkOCCI < VirtualNetwork
<NETWORK href="<%= base_url %>/network/<%= self.id.to_s %>">
<ID><%= self.id.to_s %></ID>
<NAME><%= self.name %></NAME>
<USER href="<%= base_url %>/user/<%= self['UID'] %>" name="<%= self['UNAME'] %>"/>
<GROUP><%= self['GNAME'] %></GROUP>
<% if self['TEMPLATE/DESCRIPTION'] != nil %>
<DESCRIPTION><%= self['TEMPLATE/DESCRIPTION'] %></DESCRIPTION>
<% end %>

14
src/cloud/occi/lib/VirtualNetworkPoolOCCI.rb
View File

@ -14,15 +14,17 @@
# limitations under the License. #
#--------------------------------------------------------------------------- #
require 'OpenNebula'
include OpenNebula
require 'VirtualNetworkOCCI'
class VirtualNetworkPoolOCCI < VirtualNetworkPool
OCCI_NETWORK_POOL = %q{
<NETWORK_COLLECTION>
<% self.each{ |vn| %>
<% self.each{ |vn| %>
<% if verbose %>
<%= vn.to_occi(base_url) %>
<% else %>
<NETWORK href="<%= base_url %>/network/<%= vn.id.to_s %>" name="<%= vn.name %>"/>
<% end %>
<% } %>
</NETWORK_COLLECTION>
}
@ -39,4 +41,8 @@ class VirtualNetworkPoolOCCI < VirtualNetworkPool
return occi_text.gsub(/\n\s*/,'')
end
def factory(element_xml)
VirtualNetworkOCCI.new(element_xml,@client)
end
end