mirror of
https://github.com/OpenNebula/one.git
synced 2026-11-22 20:54:49 +09:00
691 lines
22 KiB
Ruby
691 lines
22 KiB
Ruby
# rubocop:disable Naming/FileName
|
|
# -------------------------------------------------------------------------- #
|
|
# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems #
|
|
# #
|
|
# Licensed 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. #
|
|
#--------------------------------------------------------------------------- #
|
|
|
|
ONE_LOCATION = ENV['ONE_LOCATION']
|
|
|
|
if !ONE_LOCATION
|
|
RUBY_LIB_LOCATION = '/usr/lib/one/ruby'
|
|
GEMS_LOCATION = '/usr/share/one/gems'
|
|
LOG_LOCATION = '/var/log/one'
|
|
VAR_LOCATION = '/var/lib/one'
|
|
ETC_LOCATION = '/etc/one'
|
|
LIB_LOCATION = '/usr/lib/one'
|
|
else
|
|
RUBY_LIB_LOCATION = ONE_LOCATION + '/lib/ruby'
|
|
GEMS_LOCATION = ONE_LOCATION + '/share/gems'
|
|
VAR_LOCATION = ONE_LOCATION + '/var'
|
|
LOG_LOCATION = ONE_LOCATION + '/var'
|
|
ETC_LOCATION = ONE_LOCATION + '/etc'
|
|
LIB_LOCATION = ONE_LOCATION + '/lib'
|
|
end
|
|
|
|
ONEFLOW_AUTH = VAR_LOCATION + '/.one/oneflow_auth'
|
|
ONEFLOW_LOG = LOG_LOCATION + '/oneflow.log'
|
|
CONFIGURATION_FILE = ETC_LOCATION + '/oneflow-server.conf'
|
|
|
|
if File.directory?(GEMS_LOCATION)
|
|
Gem.use_paths(GEMS_LOCATION)
|
|
$LOAD_PATH.reject! {|l| l =~ /(vendor|site)_ruby/ }
|
|
end
|
|
|
|
$LOAD_PATH << RUBY_LIB_LOCATION
|
|
$LOAD_PATH << RUBY_LIB_LOCATION + '/cloud'
|
|
$LOAD_PATH << LIB_LOCATION + '/oneflow/lib'
|
|
|
|
require 'rubygems'
|
|
require 'sinatra'
|
|
require 'yaml'
|
|
|
|
require 'CloudAuth'
|
|
require 'CloudServer'
|
|
|
|
require 'models'
|
|
require 'log'
|
|
|
|
require 'LifeCycleManager'
|
|
require 'EventManager'
|
|
|
|
DEFAULT_VM_NAME_TEMPLATE = '$ROLE_NAME_$VM_NUMBER_(service_$SERVICE_ID)'
|
|
|
|
##############################################################################
|
|
# Configuration
|
|
##############################################################################
|
|
|
|
begin
|
|
conf = YAML.load_file(CONFIGURATION_FILE)
|
|
rescue StandardError => e
|
|
STDERR.puts "Error parsing config file #{CONFIGURATION_FILE}: #{e.message}"
|
|
exit 1
|
|
end
|
|
|
|
conf[:debug_level] ||= 2
|
|
conf[:autoscaler_interval] ||= 90
|
|
conf[:default_cooldown] ||= 300
|
|
conf[:shutdown_action] ||= 'terminate'
|
|
conf[:action_number] ||= 1
|
|
conf[:action_period] ||= 60
|
|
conf[:vm_name_template] ||= DEFAULT_VM_NAME_TEMPLATE
|
|
conf[:wait_timeout] ||= 30
|
|
conf[:concurrency] ||= 10
|
|
conf[:auth] = 'opennebula'
|
|
|
|
set :bind, conf[:host]
|
|
set :port, conf[:port]
|
|
set :config, conf
|
|
|
|
# rubocop:disable Style/MixinUsage
|
|
include CloudLogger
|
|
# rubocop:enable Style/MixinUsage
|
|
|
|
logger = enable_logging ONEFLOW_LOG, conf[:debug_level].to_i
|
|
|
|
use Rack::Session::Pool, :key => 'oneflow'
|
|
|
|
Log.logger = logger
|
|
Log.level = conf[:debug_level].to_i
|
|
|
|
LOG_COMP = 'ONEFLOW'
|
|
|
|
Log.info LOG_COMP, 'Starting server'
|
|
|
|
begin
|
|
ENV['ONE_CIPHER_AUTH'] = ONEFLOW_AUTH
|
|
cloud_auth = CloudAuth.new(conf)
|
|
rescue StandardError => e
|
|
message = "Error initializing authentication system : #{e.message}"
|
|
Log.error LOG_COMP, message
|
|
STDERR.puts message
|
|
exit(-1)
|
|
end
|
|
|
|
set :cloud_auth, cloud_auth
|
|
|
|
##############################################################################
|
|
# Helpers
|
|
##############################################################################
|
|
|
|
before do
|
|
auth = Rack::Auth::Basic::Request.new(request.env)
|
|
|
|
if auth.provided? && auth.basic?
|
|
username, password = auth.credentials
|
|
|
|
@client = OpenNebula::Client.new("#{username}:#{password}",
|
|
conf[:one_xmlrpc])
|
|
else
|
|
error 401, 'A username and password must be provided'
|
|
end
|
|
end
|
|
|
|
# Set status error and return the error msg
|
|
#
|
|
# @param error_msg [String] Error message
|
|
# @param error_code [Integer] Http error code
|
|
def internal_error(error_msg, error_code)
|
|
status error_code
|
|
body error_msg
|
|
end
|
|
|
|
# Get HTTP error code based on OpenNebula eror code
|
|
#
|
|
# @param error [Integer] OpenNebula error code
|
|
def one_error_to_http(error)
|
|
case error
|
|
when OpenNebula::Error::ESUCCESS
|
|
200
|
|
when OpenNebula::Error::EAUTHORIZATION
|
|
401
|
|
when OpenNebula::Error::EAUTHENTICATION
|
|
403
|
|
when OpenNebula::Error::ENO_EXISTS
|
|
404
|
|
else
|
|
500
|
|
end
|
|
end
|
|
|
|
##############################################################################
|
|
# Defaults
|
|
##############################################################################
|
|
|
|
Role.init_default_cooldown(conf[:default_cooldown])
|
|
Role.init_default_shutdown(conf[:shutdown_action])
|
|
Role.init_force_deletion(conf[:force_deletion])
|
|
Role.init_default_vm_name_template(conf[:vm_name_template])
|
|
|
|
ServiceTemplate.init_default_vn_name_template(conf[:vn_name_template])
|
|
|
|
##############################################################################
|
|
# HTTP error codes
|
|
##############################################################################
|
|
|
|
VALIDATION_EC = 400 # bad request by the client
|
|
OPERATION_EC = 405 # operation not allowed (e.g: in current state)
|
|
GENERAL_EC = 500 # general error
|
|
|
|
##############################################################################
|
|
# LCM and Event Manager
|
|
##############################################################################
|
|
|
|
# TODO: make thread number configurable?
|
|
lcm = ServiceLCM.new(@client, conf[:concurrency], cloud_auth)
|
|
|
|
##############################################################################
|
|
# Service
|
|
##############################################################################
|
|
|
|
get '/service' do
|
|
# Read-only object
|
|
service_pool = OpenNebula::ServicePool.new(nil, @client)
|
|
|
|
rc = service_pool.info
|
|
if OpenNebula.is_error?(rc)
|
|
return internal_error(rc.message, one_error_to_http(rc.errno))
|
|
end
|
|
|
|
status 200
|
|
|
|
body service_pool.to_json
|
|
end
|
|
|
|
get '/service/:id' do
|
|
service = Service.new_with_id(params[:id], @client)
|
|
|
|
rc = service.info
|
|
if OpenNebula.is_error?(rc)
|
|
return internal_error(rc.message, one_error_to_http(rc.errno))
|
|
end
|
|
|
|
status 200
|
|
|
|
body service.to_json
|
|
end
|
|
|
|
delete '/service/:id' do
|
|
# Read-only object
|
|
service = OpenNebula::Service.new_with_id(params[:id], @client)
|
|
|
|
rc = service.info
|
|
if OpenNebula.is_error?(rc)
|
|
error CloudServer::HTTP_ERROR_CODE[rc.errno], rc.message
|
|
end
|
|
|
|
# Starts service undeploying async
|
|
rc = lcm.undeploy_action(@client, service.id)
|
|
|
|
if OpenNebula.is_error?(rc)
|
|
return internal_error(rc.message, one_error_to_http(rc.errno))
|
|
end
|
|
|
|
status 204
|
|
end
|
|
|
|
post '/service/:id/action' do
|
|
action = JSON.parse(request.body.read)['action']
|
|
opts = action['params']
|
|
|
|
case action['perform']
|
|
when 'recover'
|
|
if opts && opts['delete']
|
|
rc = lcm.recover_action(@client, params[:id], true)
|
|
else
|
|
rc = lcm.recover_action(@client, params[:id])
|
|
end
|
|
when 'chown'
|
|
if opts && opts['owner_id']
|
|
u_id = opts['owner_id'].to_i
|
|
g_id = (opts['group_id'] || -1).to_i
|
|
|
|
rc = lcm.chown_action(@client, params[:id], u_id, g_id)
|
|
else
|
|
rc = OpenNebula::Error.new("Action #{action['perform']}: " \
|
|
'You have to specify a UID')
|
|
end
|
|
when 'chgrp'
|
|
if opts && opts['group_id']
|
|
g_id = opts['group_id'].to_i
|
|
|
|
rc = lcm.chown_action(@client, params[:id], -1, g_id)
|
|
else
|
|
rc = OpenNebula::Error.new("Action #{action['perform']}: " \
|
|
'You have to specify a GID')
|
|
end
|
|
when 'chmod'
|
|
if opts && opts['octet']
|
|
rc = lcm.chmod_action(@client, params[:id], opts['octet'])
|
|
else
|
|
rc = OpenNebula::Error.new("Action #{action['perform']}: " \
|
|
'You have to specify an OCTET')
|
|
end
|
|
when 'rename'
|
|
if opts && opts['name']
|
|
rc = lcm.rename_action(@client, params[:id], opts['name'])
|
|
else
|
|
rc = OpenNebula::Error.new("Action #{action['perform']}: " \
|
|
'You have to specify a name')
|
|
end
|
|
# when 'update'
|
|
# if opts && opts['append']
|
|
# if opts['template_json']
|
|
# begin
|
|
# service.update(opts['template_json'], true)
|
|
# status 204
|
|
# rescue Validator::ParseException, JSON::ParserError => e
|
|
# OpenNebula::Error.new(e.message)
|
|
# end
|
|
# elsif opts['template_raw']
|
|
# service.update_raw(opts['template_raw'], true)
|
|
# status 204
|
|
# else
|
|
# OpenNebula::Error.new("Action #{action['perform']}: " \
|
|
# 'You have to provide a template')
|
|
# end
|
|
# else
|
|
# OpenNebula::Error.new("Action #{action['perform']}: " \
|
|
# 'Only supported for append')
|
|
# end
|
|
when *Role::SCHEDULE_ACTIONS
|
|
# Use defaults only if one of the options is supplied
|
|
opts['period'] ||= conf[:action_period]
|
|
opts['number'] ||= conf[:action_number]
|
|
|
|
rc = lcm.service_sched_action(@client,
|
|
params[:id],
|
|
action['perform'],
|
|
opts['period'],
|
|
opts['number'],
|
|
opts['args'])
|
|
else
|
|
rc = OpenNebula::Error.new(
|
|
"Action #{action['perform']} not supported"
|
|
)
|
|
end
|
|
|
|
if OpenNebula.is_error?(rc)
|
|
return internal_error(rc.message, one_error_to_http(rc.errno))
|
|
end
|
|
|
|
status 204
|
|
end
|
|
|
|
# put '/service/:id/role/:name' do
|
|
# service_pool = nil # OpenNebula::ServicePool.new(@client)
|
|
#
|
|
# rc = nil
|
|
# service_rc = service_pool.get(params[:id]) do |service|
|
|
# begin
|
|
# rc = service.update_role(params[:name], request.body.read)
|
|
# rescue Validator::ParseException, JSON::ParserError => e
|
|
# return internal_error(e.message, VALIDATION_EC)
|
|
# end
|
|
# end
|
|
#
|
|
# if OpenNebula.is_error?(service_rc)
|
|
# error CloudServer::HTTP_ERROR_CODE[service_rc.errno],
|
|
# service_rc.message
|
|
# end
|
|
#
|
|
# if OpenNebula.is_error?(rc)
|
|
# error CloudServer::HTTP_ERROR_CODE[rc.errno], rc.message
|
|
# end
|
|
#
|
|
# status 204
|
|
# end
|
|
|
|
post '/service/:id/role/:role_name/action' do
|
|
action = JSON.parse(request.body.read)['action']
|
|
opts = action['params']
|
|
|
|
# Use defaults only if one of the options is supplied
|
|
opts['period'] ||= conf[:action_period]
|
|
opts['number'] ||= conf[:action_number]
|
|
|
|
rc = lcm.sched_action(@client,
|
|
params[:id],
|
|
params[:role_name],
|
|
action['perform'],
|
|
opts['period'],
|
|
opts['number'],
|
|
opts['args'])
|
|
|
|
if OpenNebula.is_error?(rc)
|
|
return internal_error(rc.message, one_error_to_http(rc.errno))
|
|
end
|
|
|
|
status 204
|
|
end
|
|
|
|
post '/service/:id/scale' do
|
|
call_body = JSON.parse(request.body.read)
|
|
|
|
rc = lcm.scale_action(@client,
|
|
params[:id],
|
|
call_body['role_name'],
|
|
call_body['cardinality'].to_i,
|
|
call_body['force'])
|
|
|
|
if OpenNebula.is_error?(rc)
|
|
return internal_error(rc.message, one_error_to_http(rc.errno))
|
|
end
|
|
|
|
status 204
|
|
end
|
|
|
|
##############################################################################
|
|
# Service Template
|
|
##############################################################################
|
|
|
|
get '/service_template' do
|
|
s_template_pool = OpenNebula::ServiceTemplatePool
|
|
.new(@client, OpenNebula::Pool::INFO_ALL)
|
|
|
|
rc = s_template_pool.info
|
|
if OpenNebula.is_error?(rc)
|
|
error CloudServer::HTTP_ERROR_CODE[rc.errno], rc.message
|
|
end
|
|
|
|
status 200
|
|
|
|
body s_template_pool.to_json
|
|
end
|
|
|
|
get '/service_template/:id' do
|
|
service_template = OpenNebula::ServiceTemplate.new_with_id(params[:id],
|
|
@client)
|
|
|
|
rc = service_template.info
|
|
if OpenNebula.is_error?(rc)
|
|
error CloudServer::HTTP_ERROR_CODE[rc.errno], rc.message
|
|
end
|
|
|
|
status 200
|
|
|
|
body service_template.to_json
|
|
end
|
|
|
|
delete '/service_template/:id' do
|
|
service_template = OpenNebula::ServiceTemplate.new_with_id(params[:id],
|
|
@client)
|
|
|
|
rc = service_template.delete
|
|
if OpenNebula.is_error?(rc)
|
|
error CloudServer::HTTP_ERROR_CODE[rc.errno], rc.message
|
|
end
|
|
|
|
status 204
|
|
end
|
|
|
|
put '/service_template/:id' do
|
|
service_template = OpenNebula::ServiceTemplate.new_with_id(params[:id],
|
|
@client)
|
|
|
|
begin
|
|
rc = service_template.update(request.body.read)
|
|
rescue Validator::ParseException, JSON::ParserError => e
|
|
return internal_error(e.message, VALIDATION_EC)
|
|
end
|
|
|
|
if OpenNebula.is_error?(rc)
|
|
error CloudServer::HTTP_ERROR_CODE[rc.errno], rc.message
|
|
end
|
|
|
|
service_template.info
|
|
|
|
status 200
|
|
|
|
body service_template.to_json
|
|
end
|
|
|
|
post '/service_template' do
|
|
xml = OpenNebula::ServiceTemplate.build_xml
|
|
s_template = OpenNebula::ServiceTemplate.new(xml, @client)
|
|
|
|
begin
|
|
rc = s_template.allocate(request.body.read)
|
|
rescue Validator::ParseException, JSON::ParserError => e
|
|
return internal_error(e.message, VALIDATION_EC)
|
|
end
|
|
|
|
if OpenNebula.is_error?(rc)
|
|
error CloudServer::HTTP_ERROR_CODE[rc.errno], rc.message
|
|
end
|
|
|
|
s_template.info
|
|
|
|
status 201
|
|
|
|
# body Parser.render(rc)
|
|
body s_template.to_json
|
|
end
|
|
|
|
post '/service_template/:id/action' do
|
|
service_template = OpenNebula::ServiceTemplate.new_with_id(params[:id],
|
|
@client)
|
|
action = JSON.parse(request.body.read)['action']
|
|
opts = action['params']
|
|
opts = {} if opts.nil?
|
|
|
|
# rubocop:disable Style/ConditionalAssignment
|
|
case action['perform']
|
|
when 'instantiate'
|
|
rc = service_template.info
|
|
|
|
if OpenNebula.is_error?(rc)
|
|
return internal_error(rc.message, one_error_to_http(rc.errno))
|
|
end
|
|
|
|
merge_template = opts['merge_template']
|
|
service_json = JSON.parse(service_template.to_json)
|
|
|
|
# Check custom_attrs
|
|
body = service_json['DOCUMENT']['TEMPLATE']['BODY']
|
|
custom_attrs = body['custom_attrs']
|
|
|
|
if merge_template
|
|
custom_attrs_values = merge_template['custom_attrs_values']
|
|
end
|
|
|
|
if custom_attrs && !(custom_attrs.is_a? Hash)
|
|
return internal_error('Wrong custom_attrs format',
|
|
VALIDATION_EC)
|
|
end
|
|
|
|
if custom_attrs_values && !(custom_attrs_values.is_a? Hash)
|
|
return internal_error('Wrong custom_attrs_values format',
|
|
VALIDATION_EC)
|
|
end
|
|
|
|
if custom_attrs && !custom_attrs.empty? && !custom_attrs_values
|
|
return internal_error('No custom_attrs_values found',
|
|
VALIDATION_EC)
|
|
end
|
|
|
|
if custom_attrs &&
|
|
!custom_attrs.empty? &&
|
|
custom_attrs_values &&
|
|
!(custom_attrs.keys - custom_attrs_values.keys).empty?
|
|
return internal_error('Every custom_attrs key must have its ' \
|
|
'value defined at custom_attrs_value',
|
|
VALIDATION_EC)
|
|
end
|
|
|
|
# Check networks
|
|
networks = body['networks']
|
|
networks_values = merge_template['networks_values'] if merge_template
|
|
|
|
# Obtain defaults from template
|
|
if networks && !networks_values
|
|
networks_values = []
|
|
|
|
begin
|
|
networks.each do |key, value|
|
|
net = {}
|
|
net[key] = {}
|
|
|
|
# Format of all available defaults
|
|
#
|
|
# Existing: "net": "M|network|||id:0"
|
|
# Instantiate: "net": "M|network|||template_id:1"
|
|
# Reserve: "net": "M|network|||reserve_from:0"
|
|
value = value.split('|')[4].strip.split(':')
|
|
|
|
net[key][value[0]] = value[1]
|
|
|
|
networks_values << net
|
|
end
|
|
|
|
merge_template ||= {}
|
|
merge_template['networks_values'] = networks_values
|
|
rescue StandardError
|
|
return internal_error('Wrong networks format', VALIDATION_EC)
|
|
end
|
|
end
|
|
|
|
if networks && !(networks.is_a? Hash)
|
|
return internal_error('Wrong networks format', VALIDATION_EC)
|
|
end
|
|
|
|
if networks_values && networks_values.find {|v| !v.is_a? Hash }
|
|
return internal_error('Wrong networks_values format', VALIDATION_EC)
|
|
end
|
|
|
|
if networks && !networks_values
|
|
return internal_error('Missing networks_values', VALIDATION_EC)
|
|
end
|
|
|
|
if networks && networks_values && !(networks.keys -
|
|
networks_values.collect {|i| i.keys }.flatten).empty?
|
|
return internal_error('Every network key must have its value ' \
|
|
'defined at networks_value', VALIDATION_EC)
|
|
end
|
|
|
|
# remove escapes
|
|
if networks_values
|
|
networks_values.each do |net|
|
|
net.map do |_, value|
|
|
value.map do |_, value1|
|
|
value1.gsub!('\\"', '') if value1.is_a? String
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
# Creates service document
|
|
service = service_template.instantiate(merge_template)
|
|
|
|
if OpenNebula.is_error?(service)
|
|
return internal_error(service.message,
|
|
one_error_to_http(service.errno))
|
|
elsif service.is_a? StandardError
|
|
# there was a JSON validation error
|
|
return internal_error(service.message, GENERAL_EC)
|
|
else
|
|
# Starts service deployment async
|
|
rc = lcm.deploy_action(@client, service.id)
|
|
|
|
if OpenNebula.is_error?(rc)
|
|
return internal_error(rc.message, one_error_to_http(rc.errno))
|
|
end
|
|
|
|
service_json = service.nil? ? '' : service.to_json
|
|
|
|
status 201
|
|
body service_json
|
|
end
|
|
when 'chown'
|
|
if opts && opts['owner_id']
|
|
args = []
|
|
args << opts['owner_id'].to_i
|
|
args << (opts['group_id'].to_i || -1)
|
|
|
|
status 204
|
|
service_template.chown(*args)
|
|
else
|
|
OpenNebula::Error.new("Action #{action['perform']}: "\
|
|
'You have to specify a UID')
|
|
end
|
|
when 'chgrp'
|
|
if opts && opts['group_id']
|
|
status 204
|
|
service_template.chown(-1, opts['group_id'].to_i)
|
|
else
|
|
OpenNebula::Error.new("Action #{action['perform']}: "\
|
|
'You have to specify a GID')
|
|
end
|
|
when 'chmod'
|
|
if opts && opts['octet']
|
|
status 204
|
|
service_template.chmod_octet(opts['octet'])
|
|
else
|
|
OpenNebula::Error.new("Action #{action['perform']}: "\
|
|
'You have to specify an OCTET')
|
|
end
|
|
when 'update'
|
|
append = opts['append'] == true
|
|
|
|
if opts && opts['template_json']
|
|
begin
|
|
service_template.update(opts['template_json'], append)
|
|
|
|
status 204
|
|
rescue Validator::ParseException, JSON::ParserError => e
|
|
return internal_error(e.message, VALIDATION_EC)
|
|
end
|
|
elsif opts && opts['template_raw']
|
|
service_template.update_raw(opts['template_raw'], append)
|
|
|
|
status 204
|
|
else
|
|
OpenNebula::Error.new("Action #{action['perform']}: "\
|
|
'You have to provide a template')
|
|
end
|
|
when 'rename'
|
|
status 204
|
|
service_template.rename(opts['name'])
|
|
when 'clone'
|
|
if opts['recursive'] != 'none'
|
|
rc = service_template.clone_recursively(opts['name'],
|
|
opts['recursive'])
|
|
else
|
|
rc = service_template.clone(opts['name'])
|
|
end
|
|
|
|
if OpenNebula.is_error?(rc)
|
|
return internal_error(rc.message, GENERAL_EC)
|
|
end
|
|
|
|
new_stemplate = OpenNebula::ServiceTemplate.new_with_id(rc, @client)
|
|
|
|
rc = new_stemplate.info
|
|
|
|
if OpenNebula.is_error?(rc)
|
|
return internal_error(rc.message, GENERAL_EC)
|
|
end
|
|
|
|
status 201
|
|
body new_stemplate.to_json
|
|
else
|
|
OpenNebula::Error.new("Action #{action['perform']} not supported")
|
|
end
|
|
# rubocop:enable Style/ConditionalAssignment
|
|
|
|
if OpenNebula.is_error?(rc)
|
|
error CloudServer::HTTP_ERROR_CODE[rc.errno], rc.message
|
|
end
|
|
end
|
|
# rubocop:enable Naming/FileName
|