stackforge/aviator
Code Issues Proposed changes

Retire stackforge/aviator

Browse Source
This commit is contained in:
Monty Taylor 2015-10-17 16:00:27 -04:00
parent 27731a18b9
commit 7609b0f29b
582 changed files with 7 additions and 59838 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.coveralls.yml
View File

@ -1 +0,0 @@
service_name: travis-ci

23
.gitignore vendored
View File

@ -1,23 +0,0 @@
*.gem
*.rbc
.bundle
.config
.yardoc
Gemfile.lock
InstalledFiles
_yardoc
coverage
doc/
lib/bundler/man
pkg
rdoc
spec/reports
test/tmp
test/version_tmp
tmp/*.*
!tmp/.gitignore
.DS_Store
test/environment.yml
vcr.log
.ruby-gemset
.ruby-version

17
.travis.yml
View File

@ -1,17 +0,0 @@
language: ruby
rvm:
- 1.8.7
- 1.9.3
- 2.0.0
branches:
only:
- master
- develop
- release
bundler_args: --without development
script:
- cp test/environment.yml.travis-ci test/environment.yml
- bundle exec rake
after_script:
- cat tmp/aviator.log
- cat tmp/vcr.log

21
Gemfile
View File

@ -1,21 +0,0 @@
source 'https://rubygems.org'
# Specify your gem's dependencies in aviator.gemspec
gemspec
# Putting these gems in the test group so that
# we can tell travis-ci not to build any of the
# development gems. Makes the build run faster.
group :test do
if Aviator::Compatibility::RUBY_1_8_MODE
gem 'mime-types', '~> 1.25.1'
end
gem 'rake'
gem 'simplecov', '~> 0.7.0'
gem 'coveralls', '~> 0.7.0'
gem 'json', '~> 1.7.0'
gem 'minitest', '~> 4.7.0'
gem 'minitest-reporters', '~> 0.14.20'
gem 'vcr', '~> 2.8.0'
end

6
Guardfile
View File

@ -1,6 +0,0 @@
guard 'minitest' do
watch(%r|^lib/aviator\.rb|) { "test" }
watch(%r|^test/test_helper\.rb|) { "test" }
watch(%r|^lib/aviator/(.*)\.rb|) { |m| "test/aviator/#{m[1]}_test.rb" }
watch(%r|^test/aviator/.*_test\.rb|) # Run the matched file
end

22
LICENSE.txt
View File

@ -1,22 +0,0 @@
Copyright (c) 2014 Mark Maglana
MIT License
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

10
README.md
View File

@ -1,10 +0,0 @@
![Aviator](https://raw.github.com/aviator/www/gh-pages/images/logo-small.png)
<br/>An elegantly designed OpenStack SDK for Ruby
[![Build Status](https://travis-ci.org/aviator/aviator.png?branch=master)](https://travis-ci.org/aviator/aviator)
[![Coverage Status](https://coveralls.io/repos/aviator/aviator/badge.png?branch=master)](https://coveralls.io/r/aviator/aviator?branch=master)
[![Code Climate](https://codeclimate.com/github/aviator/aviator.png)](https://codeclimate.com/github/aviator/aviator)
[![Gem Version](https://badge.fury.io/rb/aviator.png)](http://badge.fury.io/rb/aviator)
<a href="http://aviator.github.io/www/">Usage and Installation</a>

7
README.rst Normal file
View File

@ -0,0 +1,7 @@
This project is no longer maintained.
The contents of this repository are still available in the Git source code
management system. To see the contents of this repository before it reached
its end of life, please check out the previous commit with
"git checkout HEAD^1".

9
Rakefile
View File

@ -1,9 +0,0 @@
require "bundler/gem_tasks"
require "rake/testtask"
Rake::TestTask.new(:test) do |t|
t.pattern = "test/aviator/**/*_test.rb"
t.libs.push 'test'
end
task :default => :test

43
aviator.gemspec
View File

@ -1,43 +0,0 @@
# coding: utf-8
lib = File.expand_path('../lib', __FILE__)
$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
require 'aviator/version'
require 'aviator/compatibility'
require 'rbconfig'
Gem::Specification.new do |spec|
spec.name = "aviator"
spec.version = Aviator::VERSION
spec.authors = ["Mark Maglana"]
spec.email = ["mmaglana@gmail.com"]
spec.description = %q{ A lightweight Ruby library for the OpenStack API }
spec.summary = %q{ A lightweight Ruby library for the OpenStack API }
spec.homepage = "http://aviator.github.io/www/"
spec.license = "MIT"
spec.files = `git ls-files`.split($/)
spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
spec.require_paths = ["lib"]
spec.add_dependency 'faraday', '0.8.8'
spec.add_dependency 'thor', '~> 0.18.1'
spec.add_dependency 'terminal-table', '>= 1.4.5'
spec.add_development_dependency "bundler", ">= 1.0"
spec.add_development_dependency 'rb-fsevent', '~> 0.9.0'
spec.add_development_dependency 'guard', '~> 1.8.0'
spec.add_development_dependency 'guard-rake', '~> 0.0.0'
spec.add_development_dependency 'guard-minitest', '~> 0.5.0'
if /darwin|mac os/ === RbConfig::CONFIG['host_os']
spec.add_development_dependency 'terminal-notifier-guard', '~> 1.5.3'
else
spec.add_development_dependency 'ruby_gntp', '~> 0.3.0'
end
spec.add_development_dependency 'pry', '~> 0.9.0'
spec.add_development_dependency 'yard', '~> 0.8.0'
spec.add_development_dependency 'redcarpet', '~> 2.3.0'
end

30
bin/aviator
View File

@ -1,30 +0,0 @@
#!/usr/bin/env ruby
require 'bundler/setup'
require 'thor'
require 'aviator'
require 'aviator/core/cli'
module Aviator
module CLI
class Main < Thor
desc 'describe [PROVIDER] [SERVICE] [API_VERSION ENDPOINT_TYPE REQUEST_NAME]', 'Describes various parts of Aviator.'
def describe(provider=nil, service=nil, api_version=nil, endpoint_type=nil, request=nil)
if request
puts Aviator::Describer.describe_request(provider, service, api_version, endpoint_type, request)
elsif service
puts Aviator::Describer.describe_service(provider, service)
elsif provider
puts Aviator::Describer.describe_provider(provider)
else
puts Aviator::Describer.describe_aviator
end
end
end
end
end
Aviator::CLI::Main.start(ARGV)

6
lib/aviator.rb
View File

@ -1,6 +0,0 @@
# Add the parent dir to the load path. This is for when
# Aviator is not installed as a gem
lib_path = File.dirname(__FILE__)
$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include? lib_path
require 'aviator/core'

34
lib/aviator/compatibility.rb
View File

@ -1,34 +0,0 @@
module Aviator
module Compatibility
RUBY_1_8_MODE = (not (RUBY_VERSION =~ /1\.8\.\d*/).nil?)
end
end
if Aviator::Compatibility::RUBY_1_8_MODE
class Module
alias_method :old_const_defined?, :const_defined?
def const_defined?(sym, ignore=nil)
old_const_defined?(sym)
end
alias_method :old_const_get, :const_get
def const_get(sym, ignore=nil)
old_const_get(sym)
end
alias_method :old_instance_methods, :instance_methods
def instance_methods(include_super=true)
old_instance_methods(include_super).map(&:to_sym)
end
end
end

14
lib/aviator/core.rb
View File

@ -1,14 +0,0 @@
require 'yaml'
require 'json'
require 'faraday'
require "aviator/string"
require "aviator/version"
require "aviator/compatibility"
require "aviator/hashish"
require "aviator/core/request"
require "aviator/core/request_builder"
require "aviator/core/response"
require "aviator/core/service"
require "aviator/core/session"
require "aviator/core/logger"

2
lib/aviator/core/cli.rb
View File

@ -1,2 +0,0 @@
require "terminal-table"
require "aviator/core/cli/describer"

146
lib/aviator/core/cli/describer.rb
View File

@ -1,146 +0,0 @@
module Aviator
class Describer
def self.describe_aviator
str = "Available providers:\n"
provider_names.each do |provider_name|
str << " #{ provider_name }\n"
end
str
end
def self.describe_provider(provider_name)
str = "Available services for #{ provider_name }:\n"
service_names(provider_name).each do |service_name|
str << " #{ service_name }\n"
end
str
end
def self.describe_request(provider_name, service_name, api_version, endpoint_type, request_name)
service = Aviator::Service.new :provider => provider_name, :service => service_name
request_class = "Aviator::#{ provider_name.camelize }::#{ service_name.camelize }::"\
"#{ api_version.camelize }::#{ endpoint_type.camelize }::#{ request_name.camelize }".constantize
display = ":Request => #{ request_name }\n"
# Build the parameters
params = request_class.optional_params.map{|p| [p, false]} +
request_class.required_params.map{|p| [p, true]}
aliases = request_class.param_aliases
if params.length > 0
display << "\n"
headings = ['NAME', 'REQUIRED?']
headings << 'ALIAS' if aliases.length > 0
rows = []
params.sort{|a,b| a[0].to_s <=> b[0].to_s }.each do |param|
row = [ param[0], param[1] ? 'Y' : 'N' ]
if aliases.length > 0
row << (aliases.find{|a,p| p == param[0] } || [''])[0]
end
rows << row
end
widths = [
rows.map{|row| row[0].to_s.length }.max,
rows.map{|row| row[1].to_s.length }.max
]
widths << rows.map{|row| row[2].to_s.length }.max if aliases.length > 0
table = Terminal::Table.new(:headings => headings, :rows => rows)
table.align_column(1, :center)
display << "Parameters:\n"
display << " " + table.to_s.split("\n").join("\n ")
display << "\n"
end
# Build the sample code
display << "\nSample Code:\n"
display << " session.#{ service_name }_service.request(:#{ request_name })"
if params && params.length > 0
display << " do |params|\n"
params.each do |pair|
display << " params.#{ (aliases.find{|a,p| p == pair[0] } || pair)[0] } = value\n"
end
display << " end"
end
display << "\n"
# Build the links
if request_class.links && request_class.links.length > 0
display << "\nLinks:\n"
request_class.links.each do |link|
display << " #{ link[:rel] }:\n"
display << " #{ link[:href] }\n"
end
end
display
end
def self.describe_service(provider_name, service_name)
str = "Available requests for #{ provider_name } #{ service_name }_service:\n"
request_classes(provider_name, service_name).each do |klass|
str << " #{ klass.api_version } #{ klass.endpoint_type } #{ klass.name.split('::').last.underscore }\n"
end
str
end
class <<self
private
def provider_names
Pathname.new(__FILE__) \
.join('..', '..', '..') \
.children \
.select{|c| c.directory? && c.basename.to_s != 'core' } \
.map{|c| c.basename.to_s }
end
def request_classes(provider_name, service_name)
service = Aviator::Service.new(:provider => provider_name, :service => service_name)
service.request_classes
end
def service_names(provider_name)
Pathname.new(__FILE__) \
.join('..', '..', '..', provider_name) \
.children \
.select{|c| c.directory? } \
.map{|c| c.basename.to_s }
end
end
end
end

55
lib/aviator/core/logger.rb
View File

@ -1,55 +0,0 @@
module Aviator
class Logger < Faraday::Response::Middleware
extend Forwardable
def initialize(app, logger=nil)
super(app)
@logger = logger || begin
require 'logger'
::Logger.new(self.class::LOG_FILE_PATH)
end
end
def_delegators :@logger, :debug, :info, :warn, :error, :fatal
def call(env)
info(env[:method].to_s.upcase) { env[:url].to_s }
debug('REQ_HEAD') { dump_headers env[:request_headers] }
debug('REQ_BODY') { dump_body env[:body] }
super
end
def on_complete(env)
info('STATUS') { env[:status].to_s }
debug('RES_HEAD') { dump_headers env[:response_headers] }
debug('RES_BODY') { dump_body env[:body] }
end
def self.configure(log_file_path)
# Return a subclass with its logfile path set. This
# must be done so that different sessions can log to
# different paths.
Class.new(self) { const_set('LOG_FILE_PATH', log_file_path) }
end
private
def dump_body(body)
return if body.nil?
# :TODO => Make this configurable
body.gsub(/["']password["']:["']\w*["']/, '"password":[FILTERED_VALUE]')
end
def dump_headers(headers)
headers.map { |k, v| "#{k}: #{v.inspect}" }.join("; ")
end
end
end

229
lib/aviator/core/request.rb
View File

@ -1,229 +0,0 @@
module Aviator
class Request
class ApiVersionNotDefinedError < StandardError
def initialize
super "api_version is not defined."
end
end
class EndpointTypeNotDefinedError < StandardError
def initialize
super "endpoint_type is not defined."
end
end
class PathNotDefinedError < StandardError
def initialize
super "path is not defined."
end
end
def initialize(session_data=nil)
@session_data = session_data
params = self.class.params_class.new if self.class.params_class
if params
yield(params) if block_given?
validate_params(params)
end
@params = params
end
def anonymous?
self.class.anonymous?
end
def body?
self.class.body?
end
def headers?
self.class.headers?
end
def links
self.class.links
end
def optional_params
self.class.optional_params
end
def params
@params.dup
end
def required_params
self.class.required_params
end
def session_data
@session_data
end
def session_data?
!session_data.nil?
end
def querystring?
self.class.querystring?
end
def url?
self.class.url?
end
private
def validate_params(params)
required_params = self.class.required_params
required_params.each do |name|
raise ArgumentError.new("Missing parameter #{ name }.") if params.send(name).nil?
end
end
# NOTE that, because we are defining the following as class methods, when they
# are called, all 'instance' variables are actually defined in the descendant class,
# not in the instance/object. This is by design since we want to keep these attributes
# within the class and because they don't change between instances anyway.
class << self
def anonymous?
respond_to?(:anonymous) && anonymous == true
end
def body?
instance_methods.include? :body
end
def headers?
instance_methods.include? :headers
end
def links
@links ||= []
end
def param_aliases
@param_aliases ||= {}
end
def params_class
all_params = required_params + optional_params
if all_params.length > 0 && @params_class.nil?
@params_class = build_params_class(all_params, self.param_aliases)
end
@params_class
end
def optional_params
@optional_params ||= []
end
def querystring?
instance_methods.include? :querystring
end
def required_params
@required_params ||= []
end
def url?
instance_methods.include? :url
end
private
def build_params_class(all_params, param_aliases)
Struct.new(*all_params) do
alias :param_getter :[]
alias :param_setter :[]=
define_method :[] do |key|
key = param_aliases[key.to_sym] if param_aliases.keys.include? key.to_sym
param_getter(key)
end
define_method :[]= do |key, value|
key = param_aliases[key.to_sym] if param_aliases.keys.include? key.to_sym
param_setter(key, value)
end
param_aliases.each do |param_alias, param_name|
define_method param_alias do
param_getter(param_name)
end
define_method "#{ param_alias }=" do |value|
param_setter(param_name, value)
end
end
end
end
def link(rel, href)
links << { :rel => rel, :href => href }
end
def meta(attr_name, attr_value)
eigenclass = class << self; self; end
eigenclass.send(:define_method, attr_name) do
attr_value
end
define_method(attr_name) do
self.class.send(attr_name)
end
end
def param(param_name, opts={})
opts = Hashish.new(opts)
list = (opts[:required] == false ? optional_params : required_params)
list << param_name unless optional_params.include?(param_name)
if opts[:alias]
self.param_aliases[opts[:alias]] = param_name
end
end
end
end
end

89
lib/aviator/core/request_builder.rb
View File

@ -1,89 +0,0 @@
module Aviator
class BaseRequestNotFoundError < StandardError
attr_reader :base_request_hierarchy
def initialize(base_hierarchy)
@base_request_hierarchy = base_hierarchy
super("#{ base_request_hierarchy } could not be found!")
end
end
class RequestAlreadyDefinedError < StandardError
attr_reader :namespace,
:request_name
def initialize(namespace, request_name)
@namespace = namespace
@request_name = request_name
super("#{ namespace }::#{ request_name } is already defined")
end
end
class RequestBuilder
class << self
def define_request(root_namespace, request_name, options, &block)
base_klass = get_request_class(root_namespace, options[:inherit])
klass = Class.new(base_klass, &block)
namespace_arr = [
klass.provider,
klass.service,
klass.api_version,
klass.endpoint_type
]
namespace = namespace_arr.inject(root_namespace) do |namespace, sym|
const_name = sym.to_s.camelize
namespace.const_set(const_name, Module.new) unless namespace.const_defined?(const_name, false)
namespace.const_get(const_name, false)
end
klassname = request_name.to_s.camelize
if namespace.const_defined?(klassname, false)
raise RequestAlreadyDefinedError.new(namespace, klassname)
end
namespace.const_set(klassname, klass)
end
def get_request_class(root_namespace, request_class_arr)
request_class_arr.inject(root_namespace) do |namespace, sym|
namespace.const_get(sym.to_s.camelize, false)
end
rescue NameError => e
arr = ['..', '..'] + request_class_arr
arr[-1,1] = arr.last.to_s + '.rb'
path = Pathname.new(__FILE__).join(*arr.map{|i| i.to_s }).expand_path
if path.exist?
require path
request_class_arr.inject(root_namespace) do |namespace, sym|
namespace.const_get(sym.to_s.camelize, false)
end
else
raise BaseRequestNotFoundError.new(request_class_arr)
end
end
end
end
class << self
def define_request(request_name, options={ :inherit => [:request] }, &block)
RequestBuilder.define_request self, request_name, options, &block
end
end # class << self
end

39
lib/aviator/core/response.rb
View File

@ -1,39 +0,0 @@
module Aviator
class Response
extend Forwardable
def_delegators :@response, :headers, :status
attr_reader :request
def initialize(response, request)
@response = response
@request = request
end
def body
if raw_body.length > 0
if Aviator::Compatibility::RUBY_1_8_MODE
clean_body = raw_body.gsub(/\\ /, ' ')
else
clean_body = raw_body
end
Hashish.new(JSON.parse(clean_body))
else
Hashish.new({})
end
end
private
def raw_body
@response.body
end
end
end

197
lib/aviator/core/service.rb
View File

@ -1,197 +0,0 @@
module Aviator
class Service
class AccessDetailsNotDefinedError < StandardError
def initialize
super ":access_details is not defined."
end
end
class ProviderNotDefinedError < StandardError
def initialize
super ":provider is not defined."
end
end
class ServiceNameNotDefinedError < StandardError
def initialize
super ":service is not defined."
end
end
class SessionDataNotProvidedError < StandardError
def initialize
super "default_session_data is not initialized and no session data was "\
"provided in the method call."
end
end
class UnknownRequestError < StandardError
def initialize(request_name)
super "Unknown request #{ request_name }."
end
end
class MissingServiceEndpointError < StandardError
def initialize(service_name, request_name)
request_name = request_name.to_s.split('::').last.underscore
super "The session's service catalog does not have an entry for the #{ service_name } "\
"service. Therefore, I don't know to which base URL the request should be sent. "\
"This may be because you are using a default or unscoped token. If this is not your "\
"intention, please authenticate with a scoped token. If using a default token is your "\
"intention, make sure to provide a base url when you call the request. For :example => \n\n"\
"session.#{ service_name }_service.request :#{ request_name }, :base_url => 'http://myenv.com:9999/v2.0' do |params|\n"\
" params[:example1] = 'example1'\n"\
" params[:example2] = 'example2'\n"\
"end\n\n"
end
end
attr_accessor :default_session_data
attr_reader :service,
:provider
def initialize(opts={})
@provider = opts[:provider] || (raise ProviderNotDefinedError.new)
@service = opts[:service] || (raise ServiceNameNotDefinedError.new)
@log_file = opts[:log_file]
@default_session_data = opts[:default_session_data]
load_requests
end
def request(request_name, options={}, &params)
session_data = options[:session_data] || default_session_data
raise SessionDataNotProvidedError.new unless session_data
[:base_url].each do |k|
session_data[k] = options[k] if options[k]
end
request_class = find_request(request_name, session_data, options[:endpoint_type])
raise UnknownRequestError.new(request_name) unless request_class
request = request_class.new(session_data, &params)
response = http_connection.send(request.http_method) do |r|
r.url request.url
r.headers.merge!(request.headers) if request.headers?
r.query = request.querystring if request.querystring?
r.body = JSON.generate(request.body) if request.body?
end
Aviator::Response.send(:new, response, request)
end
def request_classes
@request_classes
end
private
def http_connection
@http_connection ||= Faraday.new do |conn|
conn.use Logger.configure(log_file) if log_file
conn.adapter Faraday.default_adapter
conn.headers['Content-Type'] = 'application/json'
end
end
# Candidate for extraction to aviator/openstack
def find_request(name, session_data, endpoint_type=nil)
endpoint_types = if endpoint_type
[endpoint_type.to_s.camelize]
else
['Public', 'Admin']
end
namespace = Aviator.const_get(provider.camelize) \
.const_get(service.camelize)
version = infer_version(session_data, name).to_s.camelize
return nil unless version && namespace.const_defined?(version)
namespace = namespace.const_get(version, name)
endpoint_types.each do |endpoint_type|
name = name.to_s.camelize
next unless namespace.const_defined?(endpoint_type)
next unless namespace.const_get(endpoint_type).const_defined?(name)
return namespace.const_get(endpoint_type).const_get(name)
end
nil
end
# Candidate for extraction to aviator/openstack
def infer_version(session_data, request_name='sample_request')
if session_data.has_key?(:auth_service) && session_data[:auth_service][:api_version]
session_data[:auth_service][:api_version].to_sym
elsif session_data.has_key?(:auth_service) && session_data[:auth_service][:host_uri]
m = session_data[:auth_service][:host_uri].match(/(v\d+)\.?\d*/)
return m[1].to_sym unless m.nil?
elsif session_data.has_key? :base_url
m = session_data[:base_url].match(/(v\d+)\.?\d*/)
return m[1].to_sym unless m.nil?
elsif session_data.has_key? :access
service_spec = session_data[:access][:serviceCatalog].find{|s| s[:type] == service }
raise MissingServiceEndpointError.new(service.to_s, request_name) unless service_spec
version = service_spec[:endpoints][0][:publicURL].match(/(v\d+)\.?\d*/)
version ? version[1].to_sym : :v1
end
end
def load_requests
# :TODO => This should be determined by a provider-specific module.
# e.g. Aviator::OpenStack::requests_base_dir
request_file_paths = Dir.glob(Pathname.new(__FILE__).join(
'..',
'..',
provider.to_s,
service.to_s,
'**',
'*.rb'
).expand_path
)
request_file_paths.each{ |path| require path }
constant_parts = request_file_paths \
.map{|rf| rf.to_s.match(/#{provider}\/#{service}\/([\w\/]+)\.rb$/) } \
.map{|rf| rf[1].split('/').map{|c| c.camelize }.join('::') }
@request_classes = constant_parts.map do |cp|
"Aviator::#{provider.camelize}::#{service.camelize}::#{cp}".constantize
end
end
def log_file
@log_file
end
end
end

204
lib/aviator/core/session.rb
View File

@ -1,204 +0,0 @@
module Aviator
class Session
class AuthenticationError < StandardError
def initialize(last_auth_body)
super("Authentication failed. The server returned #{ last_auth_body }")
end
end
class EnvironmentNotDefinedError < ArgumentError
def initialize(path, env)
super("The environment '#{ env }' is not defined in #{ path }.")
end
end
class InitializationError < StandardError
def initialize
super("The session could not find :session_dump, :config_file, and " \
":config in the constructor arguments provided")
end
end
class InvalidConfigFilePathError < ArgumentError
def initialize(path)
super("The config file at #{ path } does not exist!")
end
end
class NotAuthenticatedError < StandardError
def initialize
super("Session is not authenticated. Please authenticate before proceeding.")
end
end
class ValidatorNotDefinedError < StandardError
def initialize
super("The validator request name is not defined for this session object.")
end
end
def initialize(opts={})
if opts.has_key? :session_dump
initialize_with_dump(opts[:session_dump])
elsif opts.has_key? :config_file
initialize_with_config(opts[:config_file], opts[:environment])
elsif opts.has_key? :config
initialize_with_hash(opts[:config])
else
raise InitializationError.new
end
@log_file = opts[:log_file]
end
def authenticate(&block)
block ||= lambda do |params|
environment[:auth_credentials].each do |key, value|
params[key] = value
end
end
response = auth_service.request environment[:auth_service][:request].to_sym, &block
if response.status == 200
@auth_info = response.body
update_services_session_data
else
raise AuthenticationError.new(response.body)
end
end
def authenticated?
!auth_info.nil?
end
def dump
JSON.generate({
:environment => environment,
:auth_info => auth_info
})
end
def load(session_dump)
initialize_with_dump(session_dump)
update_services_session_data
self
end
def method_missing(name, *args, &block)
service_name_parts = name.to_s.match(/^(\w+)_service$/)
if service_name_parts
get_service_obj(service_name_parts[1])
else
super name, *args, &block
end
end
def self.load(session_dump, opts={})
opts[:session_dump] = session_dump
new(opts)
end
def validate
raise NotAuthenticatedError.new unless authenticated?
raise ValidatorNotDefinedError.new unless environment[:auth_service][:validator]
auth_with_bootstrap = auth_info.merge({ :auth_service => environment[:auth_service] })
response = auth_service.request environment[:auth_service][:validator].to_sym, :session_data => auth_with_bootstrap
response.status == 200 || response.status == 203
end
private
def auth_info
@auth_info
end
def auth_service
@auth_service ||= Service.new(
:provider => environment[:provider],
:service => environment[:auth_service][:name],
:default_session_data => { :auth_service => environment[:auth_service] },
:log_file => log_file
)
end
def environment
@environment
end
def get_service_obj(service_name)
raise NotAuthenticatedError.new unless self.authenticated?
@services ||= {}
@services[service_name] ||= Service.new(
:provider => environment[:provider],
:service => service_name,
:default_session_data => auth_info,
:log_file => log_file
)
@services[service_name]
end
def initialize_with_config(config_path, environment)
raise InvalidConfigFilePathError.new(config_path) unless Pathname.new(config_path).file?
config = Hashish.new(YAML.load_file(config_path))
raise EnvironmentNotDefinedError.new(config_path, environment) unless config[environment]
@environment = config[environment]
end
def initialize_with_dump(session_dump)
session_info = Hashish.new(JSON.parse(session_dump))
@environment = session_info[:environment]
@auth_info = session_info[:auth_info]
end
def initialize_with_hash(hash_obj)
@environment = Hashish.new(hash_obj)
end
def log_file
@log_file
end
def update_services_session_data
return unless @services
@services.each do |name, obj|
obj.default_session_data = auth_info
end
end
end
end

111
lib/aviator/hashish.rb
View File

@ -1,111 +0,0 @@
# Hash-ish!
#
# This class is implemented using composition rather than inheritance so
# that we have control over what operations it exposes to peers.
class Hashish
include Enumerable
def initialize(hash={})
@hash = hash
hashishify_values
end
def ==(other_obj)
other_obj.class == self.class &&
other_obj.hash == self.hash
end
def [](key)
@hash[normalize(key)]
end
def []=(key, value)
@hash[normalize(key)] = value
end
def each(&block)
@hash.each(&block)
end
def empty?
@hash.empty?
end
def has_key?(name)
@hash.has_key? normalize(name)
end
def hash
@hash
end
def keys
@hash.keys
end
def length
@hash.length
end
def merge(other_hash)
Hashish.new(@hash.merge(other_hash))
end
def merge!(other_hash)
@hash.merge! other_hash
self
end
def to_json(obj)
@hash.to_json(obj)
end
def to_s
str = "{"
@hash.each do |key, value|
if value.kind_of? String
value = "'#{value}'"
elsif value.nil?
value = "nil"
elsif value.kind_of? Array
value = "[#{value.join(", ")}]"
end
str += " #{key}: #{value},"
end
str = str[0...-1] + " }"
str
end
private
# Hashishify all the things!
def hashishify_values
@hash.each do |key, value|
if @hash[key].kind_of? Hash
@hash[key] = Hashish.new(value)
elsif @hash[key].kind_of? Array
@hash[key].each_index do |index|
element = @hash[key][index]
if element.kind_of? Hash
@hash[key][index] = Hashish.new(element)
end
end
end
end
end
def normalize(key)
if @hash.has_key? key
key
elsif key.is_a? String
key.to_sym
elsif key.is_a? Symbol
key.to_s
else
key
end
end
end

9
lib/aviator/openstack/common/v2/admin/base.rb
View File

@ -1,9 +0,0 @@
module Aviator
define_request :base, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :endpoint_type, :admin
end
end

47
lib/aviator/openstack/common/v2/public/base.rb
View File

@ -1,47 +0,0 @@
module Aviator
define_request :base do
meta :provider, :openstack
meta :service, :common
meta :api_version, :v2
meta :endpoint_type, :public
def headers
{}.tap do |h|
h['X-Auth-Token'] = session_data[:access][:token][:id] unless self.anonymous?
end
end
private
def base_url
if session_data[:base_url]
session_data[:base_url]
elsif service_spec = session_data[:access][:serviceCatalog].find { |s| s[:type] == service.to_s }
service_spec[:endpoints][0]["#{ endpoint_type }URL".to_sym]
elsif session_data[:auth_service] && session_data[:auth_service][:host_uri] && session_data[:auth_service][:api_version]
"#{ session_data[:auth_service][:host_uri] }/v2.0"
elsif session_data[:auth_service] && session_data[:auth_service][:host_uri]
session_data[:auth_service][:host_uri]
else
raise Aviator::Service::MissingServiceEndpointError.new(service.to_s, self.class)
end
end
def params_to_querystring(param_names)
filters = []
param_names.each do |param_name|
filters << "#{ param_name }=#{ params[param_name] }" if params[param_name]
end
filters.empty? ? "" : "?#{ filters.join('&') }"
end
end
end

36
lib/aviator/openstack/compute/v2/admin/confirm_server_resize.rb
View File

@ -1,36 +0,0 @@
module Aviator
define_request :confirm_server_resize, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Confirm_Resized_Server-d1e3868.html'
param :id, :required => true
def body
{
:confirmResize => nil
}
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

56
lib/aviator/openstack/compute/v2/admin/create_network.rb
View File

@ -1,56 +0,0 @@
module Aviator
define_request :create_network, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :compute
link 'documentation',
'http://api.openstack.org/api-ref-compute.html#ext-os-networks'
param :label, :required => true
param :bridge, :required => false
param :bridge_interface, :required => false
param :cidr, :required => false
param :cidr_v6, :required => false
param :dns1, :required => false
param :dns2, :required => false
param :gateway, :required => false
param :gateway_v6, :required => false
param :multi_host, :required => false
param :project_id, :required => false
param :vlan, :required => false
def body
p = {
:network => {
:label => params[:label]
}
}
optional_params.each do |key|
p[:network][key] = params[key] if params[key]
end
p
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/os-networks"
end
end
end

29
lib/aviator/openstack/compute/v2/admin/get_host_details.rb
View File

@ -1,29 +0,0 @@
module Aviator
define_request :get_host_details, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :compute
link 'documentation',
'http://api.openstack.org/api-ref.html#ext-os-hosts'
param :host_name, :required => true
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/os-hosts/#{ params[:host_name] }"
end
end
end

44
lib/aviator/openstack/compute/v2/admin/list_hosts.rb
View File

@ -1,44 +0,0 @@
module Aviator
define_request :list_hosts, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :compute
link 'documentation',
'http://api.openstack.org/api-ref.html#ext-os-hosts'
link 'documentation bug',
'https://bugs.launchpad.net/nova/+bug/1224763'
param :service, :required => false
param :zone, :required => false
def headers
super
end
def http_method
:get
end
def url
url = "#{ base_url }/os-hosts"
filters = []
optional_params.each do |param_name|
filters << "#{ param_name }=#{ params[param_name] }" if params[param_name]
end
url += "?#{ filters.join('&') }" unless filters.empty?
url
end
end
end

34
lib/aviator/openstack/compute/v2/admin/lock_server.rb
View File

@ -1,34 +0,0 @@
module Aviator
define_request :lock_server, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/POST_lock_v2__tenant_id__servers__server_id__action_ext-os-admin-actions.html'
param :id, :required => true
def body
{ :lock => nil }
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

34
lib/aviator/openstack/compute/v2/admin/migrate_server.rb
View File

@ -1,34 +0,0 @@
module Aviator
define_request :migrate_server, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/POST_migrate_v2__tenant_id__servers__server_id__action_ext-os-admin-actions.html'
param :id, :required => true
def body
{ :migrate => nil }
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

39
lib/aviator/openstack/compute/v2/admin/reset_server.rb
View File

@ -1,39 +0,0 @@
module Aviator
define_request :reset_server, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/POST_os-resetState_v2__tenant_id__servers__server_id__action_ext-os-admin-actions.html'
param :id, :required => true
param :state, :required => true
def body
{
'os-resetState' => {
'state' => params[:state]
}
}
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

41
lib/aviator/openstack/compute/v2/admin/resize_server.rb
View File

@ -1,41 +0,0 @@
module Aviator
define_request :resize_server, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Resize_Server-d1e3707.html'
param :id, :required => true
param :name, :required => true
param :flavorRef, :required => true, :alias => :flavor_ref
def body
{
:resize => {
:name => params[:name],
:flavorRef => params[:flavorRef]
}
}
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

46
lib/aviator/openstack/compute/v2/admin/revert_server_resize.rb
View File

@ -1,46 +0,0 @@
module Aviator
define_request :revert_server_resize do
meta :provider, :openstack
meta :service, :compute
meta :api_version, :v2
meta :endpoint_type, :admin
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Revert_Resized_Server-d1e4024.html'
param :id, :required => true
def body
{
:revertResize => nil
}
end
def headers
h = {}
unless self.anonymous?
h['X-Auth-Token'] = session_data[:access][:token][:id]
end
h
end
def http_method
:post
end
def url
service_spec = session_data[:access][:serviceCatalog].find{|s| s[:type] == service.to_s }
"#{ service_spec[:endpoints][0][:adminURL] }/servers/#{ params[:id] }/action"
end
end
end

34
lib/aviator/openstack/compute/v2/admin/unlock_server.rb
View File

@ -1,34 +0,0 @@
module Aviator
define_request :unlock_server, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/POST_unlock_v2__tenant_id__servers__server_id__action_ext-os-admin-actions.html'
param :id, :required => true
def body
{ :unlock => nil }
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

44
lib/aviator/openstack/compute/v2/public/change_admin_password.rb
View File

@ -1,44 +0,0 @@
module Aviator
define_request :change_admin_password, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Change_Password-d1e3234.html'
link 'additional spec',
'https://answers.launchpad.net/nova/+question/228462'
param :adminPass, :required => true, :alias => :admin_pass
param :id, :required => true
def body
p = {
:changePassword => {
:adminPass => params[:adminPass]
}
}
p
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

46
lib/aviator/openstack/compute/v2/public/create_image.rb
View File

@ -1,46 +0,0 @@
module Aviator
define_request :create_image, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Create_Image-d1e4655.html'
param :id, :required => true
param :metadata, :required => false
param :name, :required => true
def body
p = {
:createImage => {
:name => params[:name]
}
}
[:metadata].each do |key|
p[:createImage][key] = params[key] if params[key]
end
p
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

54
lib/aviator/openstack/compute/v2/public/create_server.rb
View File

@ -1,54 +0,0 @@
module Aviator
define_request :create_server, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/CreateServers.html'
param :accessIPv4, :required => false, :alias => :access_ipv4
param :accessIPv6, :required => false, :alias => :access_ipv6
param :adminPass, :required => false, :alias => :admin_pass
param :imageRef, :required => true, :alias => :image_ref
param :flavorRef, :required => true, :alias => :flavor_ref
param :metadata, :required => false
param :name, :required => true
param :networks, :required => false
param :personality, :required => false
def body
p = {
:server => {
:flavorRef => params[:flavorRef],
:imageRef => params[:imageRef],
:name => params[:name]
}
}
[:adminPass, :metadata, :personality, :networks, :accessIPv4, :accessIPv6].each do |key|
p[:server][key] = params[key] if params[key]
end
p
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers"
end
end
end

29
lib/aviator/openstack/compute/v2/public/delete_image.rb
View File

@ -1,29 +0,0 @@
module Aviator
define_request :delete_image, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Delete_Image-d1e4957.html'
param :id, :required => true
def headers
super
end
def http_method
:delete
end
def url
"#{ base_url }/images/#{ params[:id]}"
end
end
end

31
lib/aviator/openstack/compute/v2/public/delete_image_metadata_item.rb
View File

@ -1,31 +0,0 @@
module Aviator
define_request :delete_image_metadata_item, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Delete_Metadata_Item-d1e5790.html'
param :id, :required => true
param :key, :required => true
def headers
super
end
def http_method
:delete
end
def url
"#{ base_url }/images/#{ params[:id] }/metadata/#{ params[:key] }"
end
end
end

29
lib/aviator/openstack/compute/v2/public/delete_server.rb
View File

@ -1,29 +0,0 @@
module Aviator
define_request :delete_server, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Delete_Server-d1e2883.html'
param :id, :required => true
def headers
super
end
def http_method
:delete
end
def url
"#{ base_url }/servers/#{ params[:id] }"
end
end
end

31
lib/aviator/openstack/compute/v2/public/delete_server_metadata_item.rb
View File

@ -1,31 +0,0 @@
module Aviator
define_request :delete_server_metadata_item, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Delete_Metadata_Item-d1e5790.html'
param :id, :required => true
param :key, :required => true
def headers
super
end
def http_method
:delete
end
def url
"#{ base_url }/servers/#{ params[:id] }/metadata/#{ params[:key] }"
end
end
end

29
lib/aviator/openstack/compute/v2/public/get_flavor_details.rb
View File

@ -1,29 +0,0 @@
module Aviator
define_request :get_flavor_details, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Get_Flavor_Details-d1e4317.html'
param :id, :required => true
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/flavors/#{ params[:id] }"
end
end
end

29
lib/aviator/openstack/compute/v2/public/get_image_details.rb
View File

@ -1,29 +0,0 @@
module Aviator
define_request :get_image_details, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Get_Image_Details-d1e4848.html'
param :id, :required => true
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/images/#{ params[:id]}"
end
end
end

31
lib/aviator/openstack/compute/v2/public/get_image_metadata_item.rb
View File

@ -1,31 +0,0 @@
module Aviator
define_request :get_image_metadata_item, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Get_Metadata_Item-d1e5507.html'
param :id, :required => true
param :key, :required => true
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/images/#{ params[:id] }/metadata/#{ params[:key] }"
end
end
end

30
lib/aviator/openstack/compute/v2/public/get_network_details.rb
View File

@ -1,30 +0,0 @@
module Aviator
define_request :get_network_details, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://api.openstack.org/api-ref-compute.html#ext-os-networks'
param :id, :required => true
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/os-networks/#{ params[:id] }"
end
end
end

28
lib/aviator/openstack/compute/v2/public/get_server.rb
View File

@ -1,28 +0,0 @@
module Aviator
define_request :get_server, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Get_Server_Details-d1e2623.html'
param :id, :required => true
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/servers/#{ params[:id] }"
end
end
end

31
lib/aviator/openstack/compute/v2/public/get_server_metadata_item.rb
View File

@ -1,31 +0,0 @@
module Aviator
define_request :get_server_metadata_item, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Get_Metadata_Item-d1e5507.html'
param :id, :required => true
param :key, :required => true
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/servers/#{ params[:id] }/metadata/#{ params[:key] }"
end
end
end

36
lib/aviator/openstack/compute/v2/public/list_addresses.rb
View File

@ -1,36 +0,0 @@
module Aviator
define_request :list_addresses, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/List_Addresses-d1e3014.html'
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/List_Addresses_by_Network-d1e3118.html'
param :id, :required => true
param :networkID, :required => false, :alias => :network_id
def headers
super
end
def http_method
:get
end
def url
url = "#{ base_url }/servers/#{ params[:id] }/ips"
url += "/#{ params[:networkID] }" if params[:networkID]
url
end
end
end

35
lib/aviator/openstack/compute/v2/public/list_flavors.rb
View File

@ -1,35 +0,0 @@
module Aviator
define_request :list_flavors, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/List_Flavors-d1e4188.html'
param :details, :required => false
param :minDisk, :required => false, :alias => :min_disk
param :minRam, :required => false, :alias => :min_ram
param :marker, :required => false
param :limit, :required => false
def headers
super
end
def http_method
:get
end
def url
str = "#{ base_url }/flavors"
str += "/detail" if params[:details]
str += params_to_querystring(optional_params + required_params - [:details])
end
end
end

30
lib/aviator/openstack/compute/v2/public/list_image_metadata.rb
View File

@ -1,30 +0,0 @@
module Aviator
define_request :list_image_metadata, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/List_Metadata-d1e5089.html'
param :id, :required => true
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/images/#{ params[:id] }/metadata"
end
end
end

38
lib/aviator/openstack/compute/v2/public/list_images.rb
View File

@ -1,38 +0,0 @@
module Aviator
define_request :list_images, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/List_Images-d1e4435.html'
param :details, :required => false
param :server, :required => false
param :name, :required => false
param :status, :required => false
param 'changes-since', :required => false, :alias => :changes_since
param :marker, :required => false
param :limit, :required => false
param :type, :required => false
def headers
super
end
def http_method
:get
end
def url
str = "#{ base_url }/images"
str += "/detail" if params[:details]
str += params_to_querystring(optional_params + required_params - [:details])
end
end
end

27
lib/aviator/openstack/compute/v2/public/list_networks.rb
View File

@ -1,27 +0,0 @@
module Aviator
define_request :list_networks, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://api.openstack.org/api-ref-compute.html#ext-os-networks'
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/os-networks"
end
end
end

30
lib/aviator/openstack/compute/v2/public/list_server_metadata.rb
View File

@ -1,30 +0,0 @@
module Aviator
define_request :list_server_metadata, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/List_Metadata-d1e5089.html'
param :id, :required => true
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/servers/#{ params[:id] }/metadata"
end
end
end

58
lib/aviator/openstack/compute/v2/public/list_servers.rb
View File

@ -1,58 +0,0 @@
module Aviator
define_request :list_servers, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/List_Servers-d1e2078.html'
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/GET_listServers_v2__tenant_id__servers_compute_servers.html'
link 'github :issue => getting all servers',
'https://github.com/aviator/aviator/issues/35'
link 'related mailing list discussion',
'https://lists.launchpad.net/openstack/msg24695.html'
param :all_tenants, :required => false
param :details, :required => false
param :flavor, :required => false
param :image, :required => false
param :limit, :required => false
param :marker, :required => false
param :server, :required => false
param :status, :required => false
param 'changes-since', :required => false, :alias => :changes_since
def headers
super
end
def http_method
:get
end
def url
str = "#{ base_url }/servers"
str += "/detail" if params[:details]
filters = []
(optional_params + required_params - [:details]).each do |param_name|
value = param_name == :all_tenants && params[param_name] ? 1 : params[param_name]
filters << "#{ param_name }=#{ value }" if value
end
str += "?#{ filters.join('&') }" unless filters.empty?
str
end
end
end

34
lib/aviator/openstack/compute/v2/public/pause_server.rb
View File

@ -1,34 +0,0 @@
module Aviator
define_request :pause_server, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/POST_pause_v2__tenant_id__servers__server_id__action_ext-os-admin-actions.html'
param :id, :required => true
def body
{ :pause => nil }
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

41
lib/aviator/openstack/compute/v2/public/reboot_server.rb
View File

@ -1,41 +0,0 @@
module Aviator
define_request :reboot_server, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Reboot_Server-d1e3371.html'
param :id, :required => true
param :type, :required => false
def body
p = {
:reboot => {
:type => params[:type] || 'SOFT'
}
}
p
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

53
lib/aviator/openstack/compute/v2/public/rebuild_server.rb
View File

@ -1,53 +0,0 @@
module Aviator
define_request :rebuild_server, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Rebuild_Server-d1e3538.html'
param :accessIPv4, :required => false, :alias => :access_ipv4
param :accessIPv6, :required => false, :alias => :access_ipv6
param :adminPass, :required => true, :alias => :admin_pass
param :id, :required => true
param :imageRef, :required => true, :alias => :image_ref
param :metadata, :required => false
param :name, :required => true
param :personality, :required => false
def body
p = {
:rebuild => {
:adminPass => params[:adminPass],
:imageRef => params[:imageRef],
:name => params[:name]
}
}
[:accessIPv4, :accessIPv6, :metadata, :personality].each do |key|
p[:rebuild][key] = params[key] if params[key]
end
p
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

34
lib/aviator/openstack/compute/v2/public/resume_server.rb
View File

@ -1,34 +0,0 @@
module Aviator
define_request :resume_server, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/POST_resume_v2__tenant_id__servers__server_id__action_ext-os-admin-actions.html'
param :id, :required => true
def body
{ :resume => nil }
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

24
lib/aviator/openstack/compute/v2/public/root.rb
View File

@ -1,24 +0,0 @@
module Aviator
define_request :root, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
def headers
super
end
def http_method
:get
end
def url
uri = URI(base_url)
"#{ uri.scheme }://#{ uri.host }:#{ uri.port.to_s }/v2/"
end
end
end

38
lib/aviator/openstack/compute/v2/public/set_image_metadata.rb
View File

@ -1,38 +0,0 @@
module Aviator
define_request :set_image_metadata, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Create_or_Replace_Metadata-d1e5358.html'
param :id, :required => true
param :metadata, :required => true
def body
{
:metadata => params[:metadata]
}
end
def headers
super
end
def http_method
:put
end
def url
"#{ base_url }/images/#{ params[:id] }/metadata"
end
end
end

38
lib/aviator/openstack/compute/v2/public/set_server_metadata.rb
View File

@ -1,38 +0,0 @@
module Aviator
define_request :set_server_metadata, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Create_or_Replace_Metadata-d1e5358.html'
param :id, :required => true
param :metadata, :required => true
def body
{
:metadata => params[:metadata]
}
end
def headers
super
end
def http_method
:put
end
def url
"#{ base_url }/servers/#{ params[:id] }/metadata"
end
end
end

34
lib/aviator/openstack/compute/v2/public/suspend_server.rb
View File

@ -1,34 +0,0 @@
module Aviator
define_request :suspend_server, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/POST_suspend_v2__tenant_id__servers__server_id__action_ext-os-admin-actions.html'
param :id, :required => true
def body
{ :suspend => nil }
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

34
lib/aviator/openstack/compute/v2/public/unpause_server.rb
View File

@ -1,34 +0,0 @@
module Aviator
define_request :unpause_server, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/POST_unpause_v2__tenant_id__servers__server_id__action_ext-os-admin-actions.html'
param :id, :required => true
def body
{ :unpause => nil }
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/action"
end
end
end

38
lib/aviator/openstack/compute/v2/public/update_image_metadata.rb
View File

@ -1,38 +0,0 @@
module Aviator
define_request :update_image_metadata, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Update_Metadata-d1e5208.html'
param :id, :required => true
param :metadata, :required => true
def body
{
:metadata => params[:metadata]
}
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/images/#{ params[:id] }/metadata"
end
end
end

45
lib/aviator/openstack/compute/v2/public/update_server.rb
View File

@ -1,45 +0,0 @@
module Aviator
define_request :update_server, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/ServerUpdate.html'
param :accessIPv4, :required => false, :alias => :access_ipv4
param :accessIPv6, :required => false, :alias => :access_ipv6
param :id, :required => true
param :name, :required => false
def body
p = {
:server => { }
}
[:name, :accessIPv4, :accessIPv6].each do |key|
p[:server][key] = params[key] if params[key]
end
p
end
def headers
super
end
def http_method
:put
end
def url
"#{ base_url }/servers/#{ params[:id] }"
end
end
end

38
lib/aviator/openstack/compute/v2/public/update_server_metadata.rb
View File

@ -1,38 +0,0 @@
module Aviator
define_request :update_server_metadata, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :compute
link 'documentation',
'http://docs.openstack.org/api/openstack-compute/2/content/Update_Metadata-d1e5208.html'
param :id, :required => true
param :metadata, :required => true
def body
{
:metadata => params[:metadata]
}
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/servers/#{ params[:id] }/metadata"
end
end
end

33
lib/aviator/openstack/identity/v2/admin/add_role_to_user_on_tenant.rb
View File

@ -1,33 +0,0 @@
module Aviator
define_request :add_role_to_user_on_tenant, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :identity
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/PUT_addRolesToUserOnTenant_v2.0_tenants__tenantId__users__userId__roles_OS-KSADM__roleId__.html'
param :tenant_id, :required => true
param :user_id, :required => true
param :role_id, :required => true
def headers
super
end
def http_method
:put
end
def url
p = params
"#{ base_url }/tenants/#{ p[:tenant_id] }/users/#{ p[:user_id] }/roles/OS-KSADM/#{ p[:role_id] }"
end
end
end

43
lib/aviator/openstack/identity/v2/admin/create_tenant.rb
View File

@ -1,43 +0,0 @@
module Aviator
define_request :create_tenant, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :identity
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/'
param :name, :required => true
param :description, :required => true
param :enabled, :required => true
def body
{
:tenant => {
:name => params[:name],
:description => params[:description],
:enabled => params[:enabled]
}
}
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/tenants"
end
end
end

66
lib/aviator/openstack/identity/v2/admin/create_user.rb
View File

@ -1,66 +0,0 @@
module Aviator
define_request :create_user do
meta :provider, :openstack
meta :service, :identity
meta :api_version, :v2
meta :endpoint_type, :admin
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/POST_addUser_v2.0_users_.html'
link 'documentation bug',
'https://bugs.launchpad.net/keystone/+bug/1110435'
link 'documentation bug',
'https://bugs.launchpad.net/keystone/+bug/1226466'
param :name, :required => true
param :password, :required => true
param :email, :required => false
param :enabled, :required => false
param :tenantId, :required => false, :alias => :tenant_id
def body
p = {
:user => {}
}
(required_params + optional_params).each do |key|
p[:user][key] = params[key] if params[key]
end
p
end
def headers
h = {}
unless self.anonymous?
h['X-Auth-Token'] = session_data[:access][:token][:id]
end
h
end
def http_method
:post
end
def url
service_spec = session_data[:access][:serviceCatalog].find{|s| s[:type] == 'identity' }
"#{ service_spec[:endpoints][0][:adminURL] }/users"
end
end
end

34
lib/aviator/openstack/identity/v2/admin/delete_role_from_user_on_tenant.rb
View File

@ -1,34 +0,0 @@
module Aviator
define_request :delete_role_from_user_on_tenant, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :identity
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/DELETE_deleteRoleFromUserOnTenant_v2.0_tenants__tenantId__users__userId__roles_OS-KSADM__roleId__.html'
param :tenant_id, :required => true
param :user_id, :required => true
param :role_id, :required => true
def headers
super
end
def http_method
:delete
end
def url
p = params
"#{ base_url }/tenants/#{ p[:tenant_id] }/users/#{ p[:user_id] }/roles/OS-KSADM/#{ p[:role_id] }"
end
end
end

29
lib/aviator/openstack/identity/v2/admin/delete_tenant.rb
View File

@ -1,29 +0,0 @@
module Aviator
define_request :delete_tenant, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :identity
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/DELETE_deleteTenant_v2.0_tenants__tenantId__.html'
param :id, :required => true
def headers
super
end
def http_method
:delete
end
def url
"#{ base_url }/tenants/#{ params[:id]}"
end
end
end

39
lib/aviator/openstack/identity/v2/admin/delete_user.rb
View File

@ -1,39 +0,0 @@
module Aviator
define_request :delete_user do
meta :provider, :openstack
meta :service, :identity
meta :api_version, :v2
meta :endpoint_type, :admin
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/DELETE_deleteUser_v2.0_users__userId__.html'
param :id, :required => true
def headers
h = {}
unless self.anonymous?
h['X-Auth-Token'] = session_data[:access][:token][:id]
end
h
end
def http_method
:delete
end
def url
service_spec = session_data[:access][:serviceCatalog].find{|s| s[:type] == service.to_s }
"#{ service_spec[:endpoints][0][:adminURL] }/users/#{ params[:id]}"
end
end
end

30
lib/aviator/openstack/identity/v2/admin/get_tenant_by_id.rb
View File

@ -1,30 +0,0 @@
module Aviator
define_request :get_tenant_by_id, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :identity
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/GET_listUsers_v2.0_users_.html'
param :id, :required => true
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/tenants/#{ params[:id] }"
end
end
end

35
lib/aviator/openstack/identity/v2/admin/list_tenants.rb
View File

@ -1,35 +0,0 @@
module Aviator
define_request :list_tenants, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :identity
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/GET_listTenants_v2.0_tenants_Tenant_Operations.html'
link 'documentation bug',
'https://bugs.launchpad.net/keystone/+bug/1218601'
param :marker, :required => false
param :limit, :required => false
def headers
super
end
def http_method
:get
end
def url
str = "#{ base_url }/tenants"
str += params_to_querystring(optional_params + required_params)
end
end
end

37
lib/aviator/openstack/identity/v2/admin/list_users.rb
View File

@ -1,37 +0,0 @@
module Aviator
define_request :list_users do
meta :provider, :openstack
meta :service, :identity
meta :api_version, :v2
meta :endpoint_type, :admin
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/GET_listUsers_v2.0_users_.html'
def headers
h = {}
unless self.anonymous?
h['X-Auth-Token'] = session_data[:access][:token][:id]
end
h
end
def http_method
:get
end
def url
service_spec = session_data[:access][:serviceCatalog].find{|s| s[:type] == 'identity' }
"#{ service_spec[:endpoints][0][:adminURL] }/users"
end
end
end

47
lib/aviator/openstack/identity/v2/admin/update_tenant.rb
View File

@ -1,47 +0,0 @@
module Aviator
define_request :update_tenant, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :identity
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/POST_updateTenant_v2.0_tenants__tenantId__.html'
param :id, :required => true
param :name, :required => false
param :enabled, :required => false
param :description, :required => false
def body
p = {
:tenant => {}
}
[:name, :enabled, :description].each do |key|
p[:tenant][key] = params[key] if params[key]
end
p
end
def headers
super
end
def http_method
:put
end
def url
"#{ base_url }/tenants/#{ params[:id] }"
end
end
end

61
lib/aviator/openstack/identity/v2/admin/update_user.rb
View File

@ -1,61 +0,0 @@
module Aviator
define_request :update_user do
meta :provider, :openstack
meta :service, :identity
meta :api_version, :v2
meta :endpoint_type, :admin
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/POST_updateUser_v2.0_users__userId__.html'
link 'bug',
'https://bugs.launchpad.net/keystone/+bug/1226475'
param :id, :required => true
param :name, :required => false
param :password, :required => false
param :email, :required => false
param :enabled, :required => false
param :tenantId, :required => false, :alias => :tenant_id
def body
p = {
:user => {}
}
optional_params.each do |key|
p[:user][key] = params[key] if params[key]
end
p
end
def headers
h = {}
unless self.anonymous?
h['X-Auth-Token'] = session_data[:access][:token][:id]
end
h
end
def http_method
:put
end
def url
service_spec = session_data[:access][:serviceCatalog].find { |s| s[:type] == service.to_s }
"#{ service_spec[:endpoints][0][:adminURL] }/users/#{ params[:id] }"
end
end
end

62
lib/aviator/openstack/identity/v2/public/create_token.rb
View File

@ -1,62 +0,0 @@
module Aviator
define_request :create_token, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :anonymous, true
meta :service, :identity
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/POST_authenticate_v2.0_tokens_.html'
link 'documentation bug',
'https://bugs.launchpad.net/keystone/+bug/1208607'
param :username, :required => false
param :password, :required => false
param :tokenId, :required => false, :alias => :token_id
param :tenantName, :required => false, :alias => :tenant_name
param :tenantId, :required => false, :alias => :tenant_id
def body
p = if params[:tokenId]
{
:auth => {
:token => {
:id => params[:tokenId]
}
}
}
else
{
:auth => {
:passwordCredentials => {
:username => params[:username],
:password => params[:password]
}
}
}
end
p[:auth][:tenantName] = params[:tenantName] if params[:tenantName]
p[:auth][:tenantId] = params[:tenantId] if params[:tenantId]
p
end
def http_method
:post
end
def url
url = session_data[:auth_service][:host_uri]
url += '/v2.0' if (URI(url).path =~ /^\/?\w+/).nil?
url += "/tokens"
end
end
end

35
lib/aviator/openstack/identity/v2/public/list_tenants.rb
View File

@ -1,35 +0,0 @@
module Aviator
define_request :list_tenants, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :identity
link 'documentation',
'http://docs.openstack.org/api/openstack-identity-service/2.0/content/GET_listTenants_v2.0_tokens_tenants_.html'
link 'documentation bug',
'https://bugs.launchpad.net/keystone/+bug/1218601'
param :marker, :required => false
param :limit, :required => false
def url
str = "#{ base_url }/tenants"
str += params_to_querystring(optional_params + required_params)
end
def headers
super
end
def http_method
:get
end
end
end

25
lib/aviator/openstack/identity/v2/public/root.rb
View File

@ -1,25 +0,0 @@
module Aviator
define_request :root, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :identity
def headers
super
end
def http_method
:get
end
def url
uri = URI(base_url)
"#{ uri.scheme }://#{ uri.host }:#{ uri.port.to_s }/v2.0/"
end
end
end

45
lib/aviator/openstack/image/v1/public/list_public_images.rb
View File

@ -1,45 +0,0 @@
module Aviator
define_request :list_public_images, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :image
meta :api_version, :v1
link 'documentation', 'http://docs.openstack.org/api/openstack-image-service/1.1/content/requesting-a-list-of-public-vm-images.html'
param :name, :required => false
param :container_format, :required => false
param :disk_format, :required => false
param :status, :required => false
param :size_min, :required => false
param :size_max, :required => false
param :sort_key, :required => false
param :sort_dir, :required => false
def headers
super
end
def http_method
:get
end
def url
uri = URI(base_url)
url = "#{ uri.scheme }://#{ uri.host }:#{ uri.port.to_s }/v1/images"
filters = []
optional_params.each do |param_name|
filters << "#{ param_name }=#{ params[param_name] }" if params[param_name]
end
url += "?#{ filters.join('&') }" unless filters.empty?
url
end
end
end

25
lib/aviator/openstack/image/v1/public/root.rb
View File

@ -1,25 +0,0 @@
module Aviator
define_request :root, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :image
meta :api_version, :v1
def headers
super
end
def http_method
:get
end
def url
uri = URI(base_url)
"#{ uri.scheme }://#{ uri.host }:#{ uri.port.to_s }/v1/"
end
end
end

27
lib/aviator/openstack/metering/v1/admin/list_projects.rb
View File

@ -1,27 +0,0 @@
module Aviator
define_request :list_projects, :inherit => [:openstack, :common, :v2, :admin, :base] do
meta :service, :metering
meta :api_version, :v1
meta :endpoint_type, :admin
def headers
super
end
def http_method
:get
end
def url
uri = URI(base_url)
"#{ uri.scheme }://#{ uri.host }:#{ uri.port.to_s }/v1/projects"
end
end
end

47
lib/aviator/openstack/volume/v1/public/create_volume.rb
View File

@ -1,47 +0,0 @@
module Aviator
define_request :create_volume, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :volume
meta :api_version, :v1
link 'documentation', 'http://docs.rackspace.com/cbs/api/v1.0/cbs-devguide/content/POST_createVolume_v1__tenant_id__volumes_v1__tenant_id__volumes.html'
param :display_name, :required => true
param :display_description, :required => true
param :size, :required => true
param :volume_type, :required => false
param :availability_zone, :required => false
param :snapshot_id, :required => false
param :metadata, :required => false
def body
p = {
:volume => {
:display_name => params[:display_name],
:display_description => params[:display_description],
:size => params[:size]
}
}
optional_params.each do |key|
p[:volume][key] = params[key] if params[key]
end
p
end
def headers
super
end
def http_method
:post
end
def url
"#{ base_url }/volumes"
end
end
end

25
lib/aviator/openstack/volume/v1/public/delete_volume.rb
View File

@ -1,25 +0,0 @@
module Aviator
define_request :delete_volume, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :volume
meta :api_version, :v1
link 'documentation', 'http://docs.rackspace.com/cbs/api/v1.0/cbs-devguide/content/DELETE_deleteVolume_v1__tenant_id__volumes__volume_id__v1__tenant_id__volumes.html'
param :id, :required => true
def headers
super
end
def http_method
:delete
end
def url
"#{ base_url }/volumes/#{ params[:id] }"
end
end
end

28
lib/aviator/openstack/volume/v1/public/get_volume.rb
View File

@ -1,28 +0,0 @@
module Aviator
define_request :get_volume, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :provider, :openstack
meta :service, :volume
meta :api_version, :v1
meta :endpoint_type, :public
link 'documentation', 'http://docs.rackspace.com/cbs/api/v1.0/cbs-devguide/content/GET_getVolume_v1__tenant_id__volumes__volume_id__v1__tenant_id__volumes.html'
param :id, :required => true
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/volumes/#{ params[:id] }"
end
end
end

29
lib/aviator/openstack/volume/v1/public/list_volume_types.rb
View File

@ -1,29 +0,0 @@
module Aviator
define_request :list_volume_types, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :provider, :openstack
meta :service, :volume
meta :api_version, :v1
meta :endpoint_type, :public
link 'documentation', 'http://docs.rackspace.com/cbs/api/v1.0/cbs-devguide/content/GET_getVolumeTypes_v1__tenant_id__types_v1__tenant_id__types.html'
param :extra_specs, :required => false
param :name, :required => false
def headers
super
end
def http_method
:get
end
def url
"#{ base_url }/types"
end
end
end

48
lib/aviator/openstack/volume/v1/public/list_volumes.rb
View File

@ -1,48 +0,0 @@
module Aviator
define_request :list_volumes, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :volume
meta :api_version, :v1
link 'documentation', 'http://docs.rackspace.com/cbs/api/v1.0/cbs-devguide/content/GET_getVolumesSimple_v1__tenant_id__volumes_v1__tenant_id__volumes.html'
param :all_tenants, :required => false
param :details, :required => false
param :status, :required => false
param :availability_zone, :required => false
param :bootable, :required => false
param :display_name, :required => false
param :display_description, :required => false
param :volume_type, :required => false
param :snapshot_id, :required => false
param :size, :required => false
def headers
super
end
def http_method
:get
end
def url
str = "#{ base_url }/volumes"
str += "/detail" if params[:details]
filters = []
(optional_params + required_params - [:details]).each do |param_name|
value = param_name == :all_tenants && params[param_name] ? 1 : params[param_name]
filters << "#{ param_name }=#{ value }" if value
end
str += "?#{ filters.join('&') }" unless filters.empty?
str
end
end
end

26
lib/aviator/openstack/volume/v1/public/root.rb
View File

@ -1,26 +0,0 @@
module Aviator
define_request :root, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :volume
meta :api_version, :v1
def headers
super
end
def http_method
:get
end
def url
uri = URI(base_url)
"#{ uri.scheme }://#{ uri.host }:#{ uri.port.to_s }/v1/"
end
end
end

43
lib/aviator/openstack/volume/v1/public/update_volume.rb
View File

@ -1,43 +0,0 @@
module Aviator
define_request :update_volume, :inherit => [:openstack, :common, :v2, :public, :base] do
meta :service, :volume
meta :api_version, :v1
link 'documentation', 'http://docs.rackspace.com/cbs/api/v1.0/cbs-devguide/content/PUT_renameVolume_v1__tenant_id__volumes__volume_id__v1__tenant_id__volumes.html'
param :id, :required => true
param :display_name, :required => false
param :display_description, :required => false
def body
p = { :volume => {} }
[:display_name, :display_description].each do |key|
p[:volume][key] = params[key] if params[key]
end
p
end
def headers
super
end
def http_method
:put
end
def url
"#{ base_url }/volumes/#{ params[:id] }"
end
end
end

24
lib/aviator/string.rb
View File

@ -1,24 +0,0 @@
class String
unless instance_methods.include? 'camelize'
define_method :camelize do
word = self.slice(0,1).capitalize + self.slice(1..-1)
word.gsub(/_([a-zA-Z\d])/) { "#{$1.capitalize}" }
end
end
unless instance_methods.include? 'constantize'
define_method :constantize do
self.split("::").inject(Object) do |namespace, sym|
namespace.const_get(sym.to_s.camelize, false)
end
end
end
unless instance_methods.include? 'underscore'
define_method :underscore do
self.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
end
end
end

3
lib/aviator/version.rb
View File

@ -1,3 +0,0 @@
module Aviator
VERSION = "0.0.7"
end

262
test/aviator/core/cli/describer_test.rb
View File

@ -1,262 +0,0 @@
require 'test_helper'
class Aviator::Test
describe 'aviator/core/cli/describer' do
def build_request(provider_name, service_name, request_name, &block)
base_name = :sample_base
base_ver = :v999
base_ept = :public
unless @base
request_path = [provider_name, service_name, base_ver, base_ept, base_name]
@base = request_path.inject(Aviator) do |namespace, sym|
const_name = sym.to_s.camelize
if namespace && namespace.const_defined?(const_name, false)
namespace.const_get(const_name, false)
else
nil
end
end
@base ||= Aviator.define_request base_name do
meta :provider, provider_name
meta :service, service_name
meta :api_version, base_ver
meta :endpoint_type, base_ept
end
end
inherit = [provider_name.to_sym, service_name.to_sym, base_ver, base_ept, base_name]
Aviator.define_request request_name, :inherit => inherit, &block
end
def klass
Aviator::Describer
end
def provider_names
klass.send(:provider_names)
end
def request_classes(provider_name, service_name)
klass.send(:request_classes, provider_name, service_name)
end
def service_names(provider_name)
klass.send(:service_names, provider_names.first)
end
describe '::describe_aviator' do
it 'shows a list of providers' do
expected = "Available providers:\n"
expected << provider_names.map{|p| " #{ p }" }.join("\n") + "\n"
klass.describe_aviator.must_equal expected
end
end # describe '::describe_aviator'
describe '::describe_provider' do
it 'shows a list of available provider services' do
provider = provider_names.first
expected = "Available services for #{ provider }:\n"
expected << service_names(provider).map{|s| " #{ s }" }.join("\n") + "\n"
klass.describe_provider(provider).must_equal expected
end
end # describe '::describe_provider'
describe '::describe_service' do
it 'shows a list of available service requests' do
provider = provider_names.first
service = service_names(provider).first
requests = request_classes(provider, service)
expected = "Available requests for #{ provider } #{ service }_service:\n"
requests.each do |klass|
expected << " #{ klass.api_version } #{ klass.endpoint_type } #{ klass.name.split('::').last.underscore }\n"
end
klass.describe_service(provider, service).must_equal expected
end
end # describe '::describe_service'
describe '::describe_request' do
it 'shows the request name and sample code' do
provider = provider_names.first
service = service_names(provider).first
request_name = 'sample_request1'
request_class = build_request(provider, service, request_name)
expected = <<-EOF
:Request => #{ request_name }
Sample Code:
session.#{ service }_service.request(:#{ request_name })
EOF
output = klass.describe_request(
provider,
service,
request_class.api_version.to_s,
request_class.endpoint_type.to_s,
request_name.to_s
)
output.must_equal expected
end
it "shows parameters when provided" do
provider = provider_names.first
service = service_names(provider).first
request_name = 'sample_request2'
request_class = build_request(provider, service, request_name) do
param :theParam, :required => true
param :another, :required => false
end
expected = <<-EOF
:Request => #{ request_name }
Parameters:
+----------+-----------+
| NAME | REQUIRED? |
+----------+-----------+
| another | N |
| theParam | Y |
+----------+-----------+
Sample Code:
session.#{ service }_service.request(:#{ request_name }) do |params|
params.another = value
params.theParam = value
end
EOF
output = klass.describe_request(
provider,
service,
request_class.api_version.to_s,
request_class.endpoint_type.to_s,
request_name.to_s
)
output.must_equal expected
end
it "display aliases when available" do
provider = provider_names.first
service = service_names(provider).first
request_name = 'sample_request3'
request_class = build_request(provider, service, request_name) do
param :theParam, :required => true, :alias => :the_param
param :anotherParam, :required => false, :alias => :another_param
end
expected = <<-EOF
:Request => #{ request_name }
Parameters:
+--------------+-----------+---------------+
| NAME | REQUIRED? | ALIAS |
+--------------+-----------+---------------+
| anotherParam | N | another_param |
| theParam | Y | the_param |
+--------------+-----------+---------------+
Sample Code:
session.#{ service }_service.request(:#{ request_name }) do |params|
params.another_param = value
params.the_param = value
end
EOF
output = klass.describe_request(
provider,
service,
request_class.api_version.to_s,
request_class.endpoint_type.to_s,
request_name.to_s
)
output.must_equal expected
end
it "display links when available" do
provider = provider_names.first
service = service_names(provider).first
request_name = 'sample_request4'
request_class = build_request(provider, service, request_name) do
param :theParam, :required => true, :alias => :the_param
param :anotherParam, :required => false, :alias => :another_param
link 'link1', 'http://www.link.com'
end
expected = <<-EOF
:Request => #{ request_name }
Parameters:
+--------------+-----------+---------------+
| NAME | REQUIRED? | ALIAS |
+--------------+-----------+---------------+
| anotherParam | N | another_param |
| theParam | Y | the_param |
+--------------+-----------+---------------+
Sample Code:
session.#{ service }_service.request(:#{ request_name }) do |params|
params.another_param = value
params.the_param = value
end
Links:
link1:
http://www.link.com
EOF
output = klass.describe_request(
provider,
service,
request_class.api_version.to_s,
request_class.endpoint_type.to_s,
request_name.to_s
)
output.must_equal expected
end
end # describe '::describe_request'
end # describe 'aviator/core/cli/describe'
end # class Aviator::Test

182
test/aviator/core/request_builder_test.rb
View File

@ -1,182 +0,0 @@
require 'test_helper'
class Aviator::Test
describe 'aviator/core/request_builder' do
def builder
Aviator
end
describe '::define_request' do
it 'places the request class in the right namespace' do
provider = :dopenstack
service = :supermega
api_ver = :v999
ep_type = :uber
_name_ = :sample
builder.define_request _name_ do
meta :provider, provider
meta :service, service
meta :api_version, api_ver
meta :endpoint_type, ep_type
end
[provider, service, api_ver, ep_type, _name_].inject(builder) do |namespace, sym|
const_name = sym.to_s.camelize
namespace.const_defined?(const_name, false).must_equal true
namespace.const_get(const_name, false)
end
end
it 'does not get confused when a similar name is defined up in the namespace hierarchy' do
provider = :aws
service = :amazing
api_ver = :fixnum # This is on purpose and is critical to this test.
ep_type = :awesome
_name_ = :this_request
builder.define_request _name_ do
meta :provider, provider
meta :service, service
meta :api_version, api_ver
meta :endpoint_type, ep_type
end
[provider, service, api_ver, ep_type, _name_].inject(builder) do |namespace, sym|
const_name = sym.to_s.camelize
namespace.const_defined?(const_name, false).must_equal true,
"Expected #{ const_name } to be defined in #{ namespace }"
namespace.const_get(const_name, false)
end
end
it 'understands request inheritance' do
base = {
:provider => :another_provider,
:service => :base_service,
:api_ver => :base_api_ver,
:ep_type => :base_ep_type,
:name => :base_name
}
builder.define_request base[:name] do
meta :provider, base[:provider]
meta :service, base[:service]
meta :api_version, base[:api_ver]
meta :endpoint_type, base[:ep_type]
end
base_request = [
base[:provider],
base[:service],
base[:api_ver],
base[:ep_type],
base[:name]
]
builder.define_request :child_request, :inherit => base_request do; end
child_req_hierarchy = [
base[:provider],
base[:service],
base[:api_ver],
base[:ep_type],
:child_request
]
child_request = child_req_hierarchy.inject(builder) do |namespace, sym|
namespace.const_get(sym.to_s.camelize, false)
end
child_request.wont_be_nil
child_request.provider.must_equal base[:provider]
child_request.service.must_equal base[:service]
child_request.api_version.must_equal base[:api_ver]
child_request.endpoint_type.must_equal base[:ep_type]
end
it 'raises a BaseRequestNotFoundError if base request does not exist' do
non_existent_base = [:none, :existent, :base]
the_method = lambda do
builder.define_request :child, :inherit => non_existent_base do; end
end
the_method.must_raise Aviator::BaseRequestNotFoundError
error = the_method.call rescue $!
error.message.wont_be_nil
error.base_request_hierarchy.wont_be_nil
error.base_request_hierarchy.must_equal non_existent_base
end
it 'raises a RequestAlreadyDefinedError if the request is already defined' do
request = {
:provider => :existing_provider,
:service => :base_service,
:api_ver => :base_api_ver,
:ep_type => :base_ep_type,
:name => :base_name
}
builder.define_request request[:name] do
meta :provider, request[:provider]
meta :service, request[:service]
meta :api_version, request[:api_ver]
meta :endpoint_type, request[:ep_type]
end
the_method = lambda do
builder.define_request request[:name] do
meta :provider, request[:provider]
meta :service, request[:service]
meta :api_version, request[:api_ver]
meta :endpoint_type, request[:ep_type]
end
end
the_method.must_raise Aviator::RequestAlreadyDefinedError
error = the_method.call rescue $!
error.message.wont_be_nil
error.request_name.must_equal request[:name].to_s.camelize
end
it 'automatically attempts to load the base class if it\'s not yet loaded' do
base_arr = [:openstack, :identity, :v2, :public, :root]
child_arr = base_arr.first(base_arr.length - 1) + [:child]
builder.define_request child_arr.last, :inherit => base_arr do; end
base_klass = base_arr.inject(builder) do |namespace, sym|
namespace.const_get(sym.to_s.camelize, false)
end
child_klass = child_arr.inject(builder) do |namespace, sym|
namespace.const_get(sym.to_s.camelize, false)
end
base_klass.wont_be_nil
child_klass.wont_be_nil
end
end
end
end

381
test/aviator/core/request_test.rb
View File

@ -1,381 +0,0 @@
require 'test_helper'
class Aviator::Test
describe 'aviator/core/request' do
describe '::new' do
it 'raises an error when a required param is not provided' do
klass = Class.new(Aviator::Request) do
param :someparamname, :required => true
end
the_method = lambda { klass.new }
the_method.must_raise ArgumentError
error = the_method.call rescue $!
error.message.wont_be_nil
error.message.must_include "someparamname"
end
it 'does not raise any error when the required param is provided' do
klass = Class.new(Aviator::Request) do
param :someparamname, :required => true
end
obj = klass.new do |params|
params.someparamname = 'something'
end
end
end
describe '::anonymous?' do
it 'is false by default' do
klass = Class.new(Aviator::Request)
klass.anonymous?.must_equal false
end
it 'returns true if specified as such' do
klass = Class.new(Aviator::Request) do
meta :anonymous, true
end
klass.anonymous?.must_equal true
end
end
describe '#anonymous?' do
it 'is false by default' do
klass = Class.new(Aviator::Request)
klass.new.anonymous?.must_equal false
end
it 'returns true if specified as such' do
klass = Class.new(Aviator::Request) do
meta :anonymous, true
end
klass.new.anonymous?.must_equal true
end
end
describe '::api_version' do
it 'returns the api version' do
klass = Class.new(Aviator::Request) do
meta :api_version, :v2
end
klass.api_version.must_equal :v2
end
end
describe '#api_version' do
it 'returns the api version' do
klass = Class.new(Aviator::Request) do
meta :api_version, :v2
end
klass.new.api_version.must_equal :v2
end
end
describe '::body?' do
it 'returns false if the body method is not defined' do
klass = Class.new(Aviator::Request)
klass.body?.must_equal false
end
it 'returns true if the body method is defined' do
klass = Class.new(Aviator::Request) do
def body; end
end
klass.body?.must_equal true
end
end
describe '#body?' do
it 'returns false if the body method is not defined' do
klass = Class.new(Aviator::Request)
klass.new.body?.must_equal false
end
it 'returns true if the body method is defined' do
klass = Class.new(Aviator::Request) do
def body; end
end
klass.new.body?.must_equal true
end
end
describe '::endpoint_type' do
it 'returns the endpoint type' do
klass = Class.new(Aviator::Request) do
meta :endpoint_type, :public
end
klass.endpoint_type.must_equal :public
end
end
describe '#endpoint_type' do
it 'returns the endpoint type' do
klass = Class.new(Aviator::Request) do
meta :endpoint_type, :whatever
end
klass.new.endpoint_type.must_equal :whatever
end
end
describe '#http_method' do
it 'returns the http method if it is defined' do
klass = Class.new(Aviator::Request) do
def http_method; :post; end
end
klass.new.http_method.must_equal :post
end
end
describe '::link' do
it 'adds a link to Request::links' do
rel = 'documentation'
href = 'http://x.y.z'
klass = Class.new(Aviator::Request) do
link rel, href
end
expected = [
{ :rel => rel, :href => href }
]
klass.links.must_equal expected
klass.new.links.must_equal expected
end
end
describe '::param' do
it 'is a private class method' do
private_method = lambda { Aviator::Request.param }
private_method.must_raise NoMethodError
error = private_method.call rescue $!
error.message.wont_be_nil
error.message.must_include "private method"
end
it 'accepts an alias for a given parameter' do
klass = Class.new(Aviator::Request) do
param :the_param, :required => true, :alias => :the_alias
end
param_val = 999
req = klass.new do |params|
params.the_param = param_val
end
req.params.the_param.must_equal param_val
req.params.the_alias.must_equal param_val
end
it 'makes the param alias assignable' do
klass = Class.new(Aviator::Request) do
param :the_param, :required => true, :alias => :the_alias
end
param_val = 999
req = klass.new do |params|
params.the_alias = param_val
end
req.params.the_param.must_equal param_val
req.params.the_alias.must_equal param_val
end
it 'allows aliases to be accessible as symbols' do
klass = Class.new(Aviator::Request) do
param :the_param, :required => true, :alias => :the_alias
end
param_val = 999
req = klass.new do |params|
params[:the_alias] = param_val
end
req.params[:the_param].must_equal param_val
req.params[:the_alias].must_equal param_val
end
it 'allows aliases to be accessible as strings' do
klass = Class.new(Aviator::Request) do
param :the_param, :required => true, :alias => :the_alias
end
param_val = 999
req = klass.new do |params|
params['the_alias'] = param_val
end
req.params['the_param'].must_equal param_val
req.params['the_alias'].must_equal param_val
end
end
describe '::optional_params' do
it 'returns an array' do
klass = Class.new(Aviator::Request) do
param :whatever, :required => false
end
klass.optional_params.must_equal [:whatever]
end
end
describe '#optional_params' do
it 'returns an array' do
klass = Class.new(Aviator::Request) do
param :whatever, :required => false
end
klass.new.optional_params.must_equal [:whatever]
end
end
describe '::required_params' do
it 'returns an array' do
klass = Class.new(Aviator::Request) do
param :whatever, :required => true
end
klass.required_params.must_equal [:whatever]
end
end
describe '#required_params' do
it 'returns an array' do
klass = Class.new(Aviator::Request) do
param :whatever, :required => true
end
request = klass.new do |params|
params[:whatever] = 'something'
end
request.required_params.must_equal [:whatever]
end
end
describe '::url?' do
it 'returns false if the url method is not defined' do
klass = Class.new(Aviator::Request)
klass.url?.must_equal false
end
it 'returns true if the url method is defined' do
klass = Class.new(Aviator::Request) do
def url; end
end
klass.url?.must_equal true
end
end
describe '#url?' do
it 'returns false if the url method is not defined' do
klass = Class.new(Aviator::Request)
klass.new.url?.must_equal false
end
it 'returns true if the url method is defined' do
klass = Class.new(Aviator::Request) do
def url; end
end
klass.new.url?.must_equal true
end
end
end
end

187
test/aviator/core/service_test.rb
View File

@ -1,187 +0,0 @@
require 'test_helper'
class Aviator::Test
describe 'aviator/core/service' do
def config
Environment.openstack_admin
end
def do_auth_request
request_name = config[:auth_service][:request].to_sym
bootstrap = {
:auth_service => config[:auth_service]
}
service.request request_name, :session_data => bootstrap do |params|
config[:auth_credentials].each do |k,v|
params[k] = v
end
end
end
def klass
Aviator::Service
end
def service(default_session_data=nil)
options = {
:provider => config[:provider],
:service => config[:auth_service][:name]
}
options[:default_session_data] = default_session_data unless default_session_data.nil?
klass.new(options)
end
describe '#request' do
it 'can find the correct request based on bootstrapped session data' do
response = do_auth_request
response.must_be_instance_of Aviator::Response
response.request.api_version.must_equal config[:auth_service][:api_version].to_sym
end
it 'can find the correct request if api version is not defined but can be inferred from host_uri' do
request_name = config[:auth_service][:request].to_sym
bootstrap = {
:auth_service => {
:name => 'identity',
:host_uri => 'http://devstack:5000/v2.0',
:request => 'create_token'
}
}
response = service.request request_name, :session_data => bootstrap do |params|
config[:auth_credentials].each do |k,v|
params[k] = v
end
end
response.must_be_instance_of Aviator::Response
response.request.api_version.must_equal :v2
response.status.must_equal 200
end
it 'raises an error if session data does not have the endpoint information' do
request_name = config[:auth_service][:request].to_sym
bootstrap = Hashish.new(JSON.parse('{"access": {"token": {"issued_at": "2013-09-25T20:21:55.453783",
"expires": "2013-09-26T02:21:55Z", "id": "2f6bdec6cd0f49b4a60ede0cd4bf2c0d"},
"serviceCatalog": [], "user": {"username": "bogus",
"roles_links": [], "id": "447527294dae4a1788d36beb0db99c00", "roles": [],
"name": "bogus"}, "metadata": {"is_admin": 0, "roles":
[]}}}'))
s = service(bootstrap)
the_method = lambda { s.request request_name }
the_method.must_raise Aviator::Service::MissingServiceEndpointError
end
it 'can find the correct request based on non-bootstrapped session data' do
session_data = do_auth_request.body
response = service.request :list_tenants, :session_data => session_data
response.status.must_equal 200
end
it 'uses the default session data if session data is not provided' do
default_session_data = do_auth_request.body
s = service(default_session_data)
response = s.request :list_tenants
response.status.must_equal 200
end
it 'raises a SessionDataNotProvidedError if there is no session data' do
the_method = lambda do
service.request :list_tenants
end
the_method.must_raise Aviator::Service::SessionDataNotProvidedError
error = the_method.call rescue $!
error.message.wont_be_nil
end
it 'accepts an endpoint type option for selecting a specific request' do
default_session_data = do_auth_request.body
s = service(default_session_data)
response1 = s.request :list_tenants, :endpoint_type => 'admin'
response2 = s.request :list_tenants, :endpoint_type => 'public'
response1.request.url.wont_equal response2.request.url
end
end
describe '#request_classes' do
it 'returns an array of the request classes' do
provider_name = config[:provider]
service_name = config[:auth_service][:name]
service_path = Pathname.new(__FILE__).join(
'..', '..', '..', '..', 'lib', 'aviator', provider_name, service_name
).expand_path
request_files = Pathname.glob(service_path.join('**', '*.rb')) \
.map{|rf| rf.to_s.match(/#{provider_name}\/#{service_name}\/([\w\/]+)\.rb$/) } \
.map{|rf| rf[1].split('/').map{|c| c.camelize }.join('::') }
classes = request_files.map do |rf|
"Aviator::#{provider_name.camelize}::#{service_name.camelize}::#{rf}".constantize
end
service.request_classes.must_equal classes
end
end
describe '#default_session_data=' do
it 'sets the service\'s default session data' do
bootstrap = {
:auth_service => {
:name => 'identity',
:host_uri => 'http://devstack:5000/v2.0',
:request => 'create_token'
}
}
svc = service(bootstrap)
session_data_1 = svc.default_session_data
session_data_2 = do_auth_request.body
svc.default_session_data = session_data_2
svc.default_session_data.wont_equal session_data_1
svc.default_session_data.must_equal session_data_2
end
end
end
end

282
test/aviator/core/session_test.rb
View File

@ -1,282 +0,0 @@
require 'test_helper'
class Aviator::Test
describe 'aviator/core/session' do
def config
Environment
end
def klass
Aviator::Session
end
def log_file_path
Pathname.new(__FILE__).expand_path.join('..', '..', '..', '..', 'tmp', 'aviator.log')
end
def new_session
Aviator::Session.new(
:config_file => config.path,
:environment => 'openstack_admin',
:log_file => log_file_path
)
end
describe '#authenticate' do
it 'authenticates against the auth service indicated in the config file' do
session = new_session
session.authenticate
session.authenticated?.must_equal true
end
it 'authenticates against the auth service using the credentials in the given block' do
session = new_session
credentials = config.openstack_admin[:auth_credentials]
session.authenticate do |c|
c[:username] = credentials[:username]
c[:password] = credentials[:password]
end
session.authenticated?.must_equal true
end
it 'raises an AuthenticationError when authentication fails' do
session = new_session
credentials = config.openstack_admin[:auth_credentials]
the_method = lambda do
session.authenticate do |c|
c[:username] = 'invalidusername'
c[:password] = 'invalidpassword'
end
end
the_method.must_raise Aviator::Session::AuthenticationError
end
it 'updates the session data of its service objects' do
session = new_session
session.authenticate
keystone = session.identity_service
session_data_1 = keystone.default_session_data
session.authenticate
session.identity_service.must_equal keystone
new_token = session.identity_service.default_session_data[:access][:token][:id]
new_token.wont_equal session_data_1[:access][:token][:id]
keystone.default_session_data[:access][:token][:id].must_equal new_token
end
end # describe '#authenticate'
describe '#dump' do
it 'serializes the session data for caching' do
session = new_session
session.authenticate
str = session.dump
expected = JSON.generate({
:environment => session.send(:environment),
:auth_info => session.send(:auth_info)
})
str.must_equal expected
end
end
describe '#load' do
it 'returns itself' do
session = new_session
session.authenticate
str = session.dump
session.load(str).must_equal session
end
it 'updates the session data of its service objects' do
session1 = new_session
session1.authenticate
keystone1 = session1.identity_service
session2 = new_session
session2.authenticate
keystone2 = session2.identity_service
session1.load(session2.dump)
keystone1.wont_equal keystone2
keystone1.default_session_data.must_equal keystone2.default_session_data
end
end # describe '#load'
describe '::load' do
it 'creates a new instance from the given session dump' do
session = new_session
session.authenticate
str = session.dump
session = Aviator::Session.load(str)
expected = Hashish.new(JSON.parse(str))
session.authenticated?.must_equal true
# This is bad testing practice (testing a private method) but
# I'll go ahead and do it anyway just to be sure.
session.send(:environment).must_equal expected[:environment]
session.send(:auth_info).must_equal expected[:auth_info]
end
it 'uses the loaded auth info for its services' do
session = new_session
session.authenticate
expected = Hashish.new(JSON.parse(session.dump))
session = Aviator::Session.load(session.dump)
service = session.identity_service
service.default_session_data.must_equal expected[:auth_info]
end
end
describe '::new' do
it 'can accept a hash object as configuration' do
config = {
:provider => 'openstack',
:auth_service => {
:name => 'identity',
:host_uri => 'http://devstack:5000/v2.0',
:request => 'create_token',
:validator => 'list_tenants'
},
:auth_credentials => {
:username => 'myusername',
:password => 'mypassword',
:tenant_name => 'myproject'
}
}
session = klass.new(:config => config)
session.send(:environment).must_equal Hashish.new(config)
auth_service = session.send(:auth_service)
auth_service.send(:service).must_equal config[:auth_service][:name]
end
it 'directs log entries to the given log file' do
log_file_path.delete if log_file_path.file?
session = new_session
session.authenticate
log_file_path.file?.must_equal true
end
it 'raises an error when constructor keys are missing' do
the_method = lambda { klass.new }
the_method.must_raise Aviator::Session::InitializationError
error = the_method.call rescue $!
error.message.wont_be_nil
end
end
describe '#validate' do
it 'returns true if session is still valid' do
session = new_session
session.authenticate
session.validate.must_equal true
end
it 'returns false if session is no longer valid' do
session = new_session
session.authenticate
session.send(:auth_info)[:access][:token][:id] = 'invalidtokenid'
session.validate.must_equal false
end
it 'raises an error if called before authenticating' do
the_method = lambda { new_session.validate }
the_method.must_raise Aviator::Session::NotAuthenticatedError
end
it 'returns true even when a default token is used' do
session = new_session
credentials = config.openstack_admin[:auth_credentials]
session.authenticate do |c|
c[:username] = credentials[:username]
c[:password] = credentials[:password]
end
session.validate.must_equal true
end
end
describe '#xxx_service' do
it 'raises a NotAuthenticatedError if called without authenticating first' do
the_method = lambda { new_session.identity_service }
the_method.must_raise Aviator::Session::NotAuthenticatedError
end
it 'returns an instance of the indicated service' do
session = new_session
session.authenticate
session.identity_service.wont_be_nil
end
end
end # describe 'aviator/core/service'
end # class Aviator::Test

109
test/aviator/openstack/common/v2/public/base_test.rb
View File

@ -1,109 +0,0 @@
require 'test_helper'
class Aviator::Test
describe 'aviator/openstack/common/v2/public/base' do
def create_request(session_data = get_session_data, &block)
block ||= lambda do |params|
params[:tenant_id] = 0
params[:role_id] = 0
params[:user_id] = 0
end
klass.new(session_data, &block)
end
def get_session_data
session.send :auth_info
end
def helper
Aviator::Test::RequestHelper
end
def klass
@klass ||= helper.load_request('openstack', 'common', 'v2', 'public', 'base.rb')
end
def session
unless @session
@session = Aviator::Session.new(
:config_file => Environment.path,
:environment => 'openstack_admin'
)
@session.authenticate
end
@session
end
validate_attr :anonymous? do
klass.anonymous?.must_equal false
end
validate_attr :api_version do
klass.api_version.must_equal :v2
end
validate_attr :endpoint_type do
klass.endpoint_type.must_equal :public
end
validate_attr :headers do
headers = { 'X-Auth-Token' => get_session_data[:access][:token][:id] }
request = create_request
request.headers.must_equal headers
end
describe '::base_url' do
it 'must throw a MissingServiceEndpointError when the service\'s endpoint can\'t be found' do
default_session_data = Hashish.new(JSON.parse('{"access": {"token": {"issued_at": "2013-09-25T20:21:55.453783",
"expires": "2013-09-26T02:21:55Z", "id": "2f6bdec6cd0f49b4a60ede0cd4bf2c0d"},
"serviceCatalog": [], "user": {"username": "bogus",
"roles_links": [], "id": "447527294dae4a1788d36beb0db99c00", "roles": [],
"name": "bogus"}, "metadata": {"is_admin": 0, "roles":
[]}}}'))
request = klass.new(default_session_data)
the_method = lambda { request.send(:base_url) }
the_method.must_raise Aviator::Service::MissingServiceEndpointError
end
it 'must use the base_url value if provided.' do
default_session_data = Hashish.new(JSON.parse('{"access": {"token": {"issued_at": "2013-09-25T20:21:55.453783",
"expires": "2013-09-26T02:21:55Z", "id": "2f6bdec6cd0f49b4a60ede0cd4bf2c0d"},
"serviceCatalog": [], "user": {"username": "bogus",
"roles_links": [], "id": "447527294dae4a1788d36beb0db99c00", "roles": [],
"name": "bogus"}, "metadata": {"is_admin": 0, "roles":
[]}}}'))
base_url = 'http://sample'
default_session_data.merge!({ :base_url => base_url })
request = klass.new(default_session_data)
request.send(:base_url).must_equal base_url
end
end
end
end

145
test/aviator/openstack/compute/v2/admin/confirm_server_resize_test.rb
View File

@ -1,145 +0,0 @@
require 'test_helper'
class Aviator::Test
describe 'aviator/openstack/compute/v2/admin/confirm_server_resize' do
def create_request(session_data = get_session_data)
klass.new(session_data) do |params|
params[:id] = server[:id]
end
end
def get_session_data
session.send :auth_info
end
def helper
Aviator::Test::RequestHelper
end
def klass
@klass ||= helper.load_request('openstack', 'compute', 'v2', 'admin', 'confirm_server_resize.rb')
end
def session
unless @session
@session = Aviator::Session.new(
:config_file => Environment.path,
:environment => 'openstack_admin'
)
@session.authenticate
end
@session
end
def server
unless @server
response = session.compute_service.request(:list_servers) do |params|
params[:details] = true
params[:all_tenants] = true
end
current_tenant = get_session_data[:access][:token][:tenant]
resized_servers = response.body[:servers].select do |server|
server[:status] == 'VERIFY_RESIZE' && server[:tenant_id] == current_tenant[:id]
end
raise "\n\nProject '#{ current_tenant[:name] }' should have at least 1 server with "\
"a status of VERIFY_RESIZE\n\n" if resized_servers.empty?
@server = resized_servers.first
end
@server
end
validate_attr :anonymous? do
klass.anonymous?.must_equal false
end
validate_attr :api_version do
klass.api_version.must_equal :v2
end
validate_attr :body do
request = create_request
klass.body?.must_equal true
request.body?.must_equal true
request.body.wont_be_nil
end
validate_attr :endpoint_type do
klass.endpoint_type.must_equal :admin
end
validate_attr :headers do
headers = { 'X-Auth-Token' => get_session_data[:access][:token][:id] }
request = create_request
request.headers.must_equal headers
end
validate_attr :http_method do
create_request.http_method.must_equal :post
end
validate_attr :required_params do
klass.required_params.must_equal [:id]
end
validate_attr :url do
service_spec = get_session_data[:access][:serviceCatalog].find{|s| s[:type] == 'compute' }
url = "#{ service_spec[:endpoints][0][:publicURL] }/servers/#{ server[:id] }/action"
request = create_request do |params|
params[:id] = server[:id]
end
request.url.must_equal url
end
validate_response 'parameters are provided' do
response = session.compute_service.request :confirm_server_resize do |params|
params[:id] = server[:id]
end
response.status.must_equal 204
response.headers.wont_be_nil
end
validate_response 'the id parameter is invalid' do
response = session.compute_service.request :confirm_server_resize do |params|
params[:id] = 'invalidvalue'
end
response.status.must_equal 404
response.body.wont_be_nil
response.headers.wont_be_nil
end
end
end

Some files were not shown because too many files have changed in this diff Show More