misty 1.3.3 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30d8058b1a66f781f30b8f23300c44a68389bda7
-  data.tar.gz: 3a092c09a00946956a67dbb44bfdaffbe8d92c07
+  metadata.gz: ec633eb5c336342f8a86380b8c9b624520ac1e2b
+  data.tar.gz: 51a3e89f79256a33c926ed55800135084ab1e0e3
 SHA512:
-  metadata.gz: 500690a8ae8ae47b13f89f6489d4a5aea4e9d46f6f6b23b8e517ad4880e1076e4cf116cab52fa8c301dda67e901c939eab38dcee81691512d32c2f4ab894e466
-  data.tar.gz: 8579eea3d1c537fa84ea91724bbd7bb9971a86a848b901f724265aadb8cccc7d85b69e3f29db7d8bf8e6fd28961917d3a3db0ad65c671f70560fe46e1a3cdb65
+  metadata.gz: 0bcb3e7a8b98d4b599700e65d59d89ff83d44fe86c3badee004f6579e4cd3939950c397f042d9c629c92d25ffde06b690a782d4cee803e0886a2861146e2361e
+  data.tar.gz: 5360efb6444ee46248d0f4d7467f90d33bf930985044082b7519e1e57935512feb90dd4039ce3ecc6aed4dffa33c60ed28cc82f826ace38082f0f1948a219dda

data/README.md

@@ -1,103 +1,264 @@
 # Introduction
-Misty is a HTTP client for OpenStack APIs, aiming to be fast, flexible and exhaustive.
-Misty acts as a conduit to OpenStack APIs by handling requests as transparently as possible.
-
-## Features
-* Flexible Openstack APIs integration
-* Standardized Openstack APIs: [Based upon API-ref](https://developer.openstack.org/api-guide/quick-start/)
-* Automatically generated API schemas - Any request can be overridden
-* Versions and Microversions
-* Transparent Request data hanlding
-* Response data format of choice: JSON or raw (Ruby)
+Misty is a HTTP client for OpenStack APIs, aiming to be slick and dynamic.
+
+Misty handles OpenStack APIs requests as Transparently as possible by:
+* Directly submitting request to Openstack Service endpoints
+* Or by using APIs Schema defined functions which are dynamically extracted from OpenStackAPI reference.
+
+## Main features
+* Standardized OpenStack APIs: [Based upon API-ref](https://developer.openstack.org/api-guide/quick-start/) offering
+  flexibility to easily integrate new OpenStack services. Any request can be overridden or completed
+* Microversions & Legacy Versions
+* Transparent request data handling and response data format of choice: JSON or Hash
 * Custom HTTP Methods for special needs
-* On demand services - Auto loads required versions
-* Low dependency - Use standard Net/HTTP and JSON gem only
-* Persistent HTTP connections (default since HTTP 1.1 anyway)
-
-## A solid KISS
-For REST transactions Misty relies on standard Net/HTTP library.  
-No other gems are required besides 'json'.  
-
-Not having to use the help of a more complex HTTP framework is a choice that reduces dependencies.  
-Meanwhile a better reason would be because Openstack offers a common modus operandi across all APIs.  
-The authentication process provides a Service Catalog serving all available APIs entry points.
-
-## APIs Definitions
-The rich variety of OpenStack projects requires lots of Application Program Interfaces to handle.  
-Maintaining and extending those APIs implies a structural complexity challenge.  
-Therefore the more automated the process, the better.  
-Thanks to the help of Phoenix project [OpenStack API-ref](https://developer.openstack.org/api-guide/quick-start/)
-providing the latest standard of OpenStack APIs.  
-The APIs interface definitions are generated automatically from the API-ref reference manuals (misty-builder) which
-allows:
-* More consistent APIs
-* More recent APIs definitions
-* Easier addition of a new service's API
-
-[1] https://developer.openstack.org/api-guide/quick-start/
-
-# Install & Use
-
-## Fetch and install
+* And also: Lazy service loading, Low gem dependency (use only Net/HTTP and JSON), Persistent HTTP connections (default since HTTP 1.1 anyway)
+
+### Current Microversion support
+* Cinder
+  v3.44
+* Ironic
+  v1.32
+* Magnum
+  v1.4
+* Manilla
+  v2.40
+* Nova
+  v2.60
+
+
+# How To
+Fetch and install
 ``` ruby
 gem install misty
 ```
+## Get started
+Create a `Misty::Cloud` object with mandatory `:auth` parameter such as:
 
-## Quick start
 ```ruby
 require 'misty'
+cloud = Misty::Cloud.new(
+  :auth => {
+    :url                => 'http://localhost:5000',
+    :user               => 'admin',
+    :password           => 'secret',
+    :domain             => 'default',
+    :project            => 'admin',
+    :project_domain_id  => 'default'
+  })
+  ```
+
+  Then requets can be made against OpenStack services:
 
-auth_v3 = {
-  :url      => 'http://localhost:5000',
-  :user               => 'admin',
-  :password           => 'secret',
-  :domain             => 'default',
-  :project            => 'admin',
-  :project_domain_id  => 'default'
+```
+  servers = cloud.compute.list_servers.body
+  networks = cloud.networking.list_networks
+  first_network_id = networks.body['networks'][0]['id']
+  first_network = cloud.networking.show_network_details(first_network_id)
+  network = Misty.to_json(:network => {:name => 'misty-example'})
+  cloud.network.create_network(network)
+  v1 = cloud.baremetal.show_v1_api
+```
+## Configuration
+To provide the maximum flexibility, there are 4 levels of configuration which are always propagated from top to bottom.
+* The Cloud global defaults
+* The Cloud global parameters
+* The service level parameters
+* The request level ephemeral parameters
+
+No global parameters provided, the defaults are applied.
+```ruby
+cloud = Misty::Cloud.new(:auth => { ... })
+```
+
+Some provided global parameters, which override respective global and apply at service level.
+```ruby
+cloud = Misty::Cloud.new(:auth => { ... }, :log_file => './misty.log', :headers => {"x-tra:" => "value"})
+```
+
+Provided service level parameters are applied for all service requests.  
+Some such as the headers are cumulative.  
+Others such as the microversion feature, don't have global definition.
+```ruby
+cloud = Misty::Cloud.new(:auth => { ... }, compute {:version => 2.60})
+# All following requests are going to be with version 2.60, unless overridden at request level
+cloud.compute.list_servers
+```
+
+And finally, at requests level, provided parameters are ephemeral
+```ruby
+cloud = Misty::Cloud.new(:auth => { ... })
+cloud.compute(:version => 'latest', :content_type => :json, :headers => {"key" => "value"}).list_servers
+# Back to defaults (since there are no global or service level parameters provided)
+cloud.compute.list_servers
+```
+
+### Authentication
+Openstack Identity service Keystone version 3 is the default, version 2.0, although deprecated, is available.
+
+#### Parameters
+The following parameters can be used:
+To authenticate with credentials details:
+* `:context` - Allow to provide already authenticated context(catalog, token, expiry time). Used for v2.0 only.
+  Exclusive with other parameters.
+* `:domain_id` - Domain id, default: "default"
+* `:domain` - Domain name, default: "Default"
+* `:password` - User password. Exclusive with :token.
+* `:project_id` - Project id
+* `:project` - Project name
+* `:project_domain_id` - Project domain id
+* `:project_domain` - Project domain name
+* `:ssl_verify_mode` - Boolean flag for SSL client verification. SSL is defined when URI scheme => "https://".
+* `:tenant_id` - Tenant id, used for v2.0 only.
+* `:tenant` - Tenant name, used for v2.0 only.
+* `:token` - Allow to provide unscoped token.
+* `:user_id` - User id
+* `:user` - User name
+* `:user_domain_id` - User domain id
+* `:user_domain` - User domain name
+
+##### Keystone v3
+Version 3 relies on the concept of domain name or id to authenticates
+
+`Misty::AuthV3` is used by default unless authentication credentials contains a tenant name or id in wich case it
+will use on `Misty::AuthV2`.
+
+The credentials are a combination of "id" and "name" used to uniquely identify projects, users and their domains.
+When using only the name, a domain must be specified to guarantee a unique record from the Identity service.
+
+###### Examples
+```ruby
+auth = {
+  :url            => 'http://localhost:5000',
+  :user           => 'admin',
+  :user_domain    => 'default',
+  :password       => 'secret',
+  :project        => 'admin',
+  :project_domain => 'default'
+  }
 }
+cloud = Misty::Cloud.new(:auth => auth_v3)
+# The API requests are of course specific to this version:
+cloud.identity.list_projects
+```
 
-openstack = Misty::Cloud.new(:auth => auth_v3)
+Using IDs:
+```ruby
+auth = {
+  :url        => 'http://localhost:5000',
+  :user_id    => '48985e6b8da145699d411f12a3459fca',
+  :password   => 'secret',
+  :project_id => '8e1e232f6cbb4116bbef715d8a0afe6e',
+  }
+}
+```
 
-puts openstack.compute.list_servers.body
-puts openstack.compute.list_flavors.body
-networks = openstack.network.list_networks
-network_id = networks.body['networks'][0]['id']
-network = openstack.network.show_network_details(network_id)
-puts network.body
+Or alternatively using a context
+```ruby
+context = { :context => { :token => token_id, :catalog => service_catalog, :expires => expire_date } }
+cloud = Misty::Cloud.new(:auth => context)
 ```
 
-## Services
-Once a Misty::Cloud object is created, the Openstack services can be used.
+##### Keystone v2.0
+By providing tenant details Misty will detect it's using v2.0 for authentication:
+
+```ruby
+auth = {
+  :url      => 'http://localhost:5000',
+  :user     => 'admin',
+  :password => 'secret',
+  :tenant   => 'admin',
+}
+cloud = Misty::Cloud.new(:auth => auth_v2)
+# The API requests are of course specific to this version:
+cloud.identity.list_tenants
+```
+
+##### Note
+It's possible to authenticate against Keystone V3 and use the identity service v2.0, for instance:
+In which case API set for v2.0 applies: tenants are available but not the projects.
+```ruby
+cloud = Misty::Cloud.new(:auth => auth_v3)
+cloud.identity(:api_version => 'v2.0')
+```
 
-The Cloud object is authenticated by the identity server (bootstrap) and is provided with a service catalog.
-When an OpenStack API service is required, the catalog entry's endpoint is used and the service is dynamically called.
+### Global configuration options
+The configuration parameters used to initialize `Misty::Cloud` are global. They are optionals and Misty::Config
+defaults are applied if needed.
+
+* `:auth` - Authentication credentials hash containing 'auth_url' and user context. See `Misty::Auth`.
+* `:content_type` - HTTP responses body format. :json or :hash structures. Default is `Misty::Config::CONTENT_TYPE`.
+* `:headers` - Hash of extra HTTP headers to be applied to all services
+* `:interface` - Endpoint interface, allowed values are: "public", "internal", "admin".
+* `:log_file` - Log destination, Value is either file path (./misty.log) or IO object (SDOUT). Default is '/dev/null'
+* `:log_level` - Value is Fixnum - Default is 1 (Logger::INFO) - See Logger from Ruby standard Library
+* `:region_id` - Alternative Region identifier. Default is `Misty::Config::REGION_ID`
+   Default is `Misty::Config::INTERFACE`
+* `:ssl_verify_mode` - Boolean flag for SSL client verification. SSL is defined when URI scheme => "https://".
+   Default is `Misty::Config::SSL_VERIFY_MODE`
+   See `Misty::Config` for more details
 
-Each service name (i.e. `compute`) is the object handling API requests.
+### Headers
+Headers are cumulative, applied from Cloud top level, then at Service level and finally at request level.
+
+HTTP headers can effectively be optionally added to any request.
+An Header object must be created and passed as the last parameter of a request.
 
- ```ruby
-openstack = Misty::Cloud.new(:auth => { ... })
-openstack.compute.list_servers
-openstack.network.list_networks
-data = Misty.to_json('network': {'name': 'my-network'})
-openstack.network.create_network(data)
+For example for an already initialized cloud:
+```ruby
+header = Misty::HTTP::Header.new(
+  'x-container-meta-web-listings' => false,
+  'x-container-meta-quota-count'  => "",
+  'x-container-meta-quota-bytes'  => nil,
+  'x-versions-location'           => "",
+  'x-container-meta-web-index'    => ""
+)
+openstack.object_storage.create_update_or_delete_container_metadata(container_name, header)
 ```
 
-To obtain the list of supported services:
+### Service and Request levels configuration parameters
+The same parameters used at the global configuration variables can be applied at Service level or at a Request level.
+ The global values passed from `Misty::Cloud` level are then overridden at the Service level.
+
+The following parameters can be also used:
+* `:api_version` - String for specifying Openstack API service version to use. Default is latest supported version.
+  Applies only at service level as it's needed for service creation.
+* `:base_path` - Allows to force the base path for every URL requests Default nil.
+* `:base_url` - Allows to force the base URL for every requests. Default nil.
+* `:version` - Version to be used when microversion is supported by the service. Default: `nil`
+  Allowed values: `'latest'`, or a version number such as '2.10'
+
+#### Examples
+Initialize cloud
+```ruby
+cloud = Misty::Cloud.new(:auth => { ... }, region_id => 'regionOne', :log_level => 0)
+```
+
+Then use different options, for example, the identify service, therefore overriding respective global defaults or
+specified values
 ```ruby
-> require 'misty'
-> puts Misty.services
+ cloud.identity => {:region_id => 'regionTwo', :interface => 'admin'}
+Provide service specific option
+ cloud.compute  => {:version => '2.27'})
+```
+
+## Services
+The latest list of supported service can be obtain from `Misty.services`:
+```
+require 'misty'
+puts Misty.services
+=>
 application_catalog: murano, versions: ["v1"]
 alarming: aodh, versions: ["v2"]
 backup: freezer, versions: ["v1"]
-baremetal: ironic, microversion: v1
-block_storage: cinder, versions: ["v2", "v1"], microversion: v3
+baremetal: ironic, versions: ["v1"], microversion: v1
+block_storage: cinder, versions: ["v3", "v2", "v1"], microversion: v3
 clustering: senlin, versions: ["v1"]
-compute: nova, microversion: v2.1
-container_infrastructure_management: magnum, microversion: v1
+compute: nova, versions: ["v2.1"], microversion: v2.1
+container_infrastructure_management: magnum, versions: ["v1"], microversion: v1
 data_processing: sahara, versions: ["v1.1"]
 data_protection_orchestration: karbor, versions: ["v1"]
 database: trove, versions: ["v1.0"]
-domain_name_server: designate, versions: ["v2"]
+dns: designate, versions: ["v2"]
 identity: keystone, versions: ["v3", "v2.0"]
 image: glance, versions: ["v2", "v1"]
 load_balancer: octavia, versions: ["v2.0"]
@@ -108,35 +269,25 @@ nfv_orchestration: tacker, versions: ["v1.0"]
 object_storage: swift, versions: ["v1"]
 orchestration: heat, versions: ["v1"]
 search: searchlight, versions: ["v1"]
-shared_file_systems: manila, microversion: v2
+shared_file_systems: manila, versions: ["v2"], microversion: v2
 ```
 
-### Headers
-HTTP headers can be defined at 3 different levels:
-* Global headers are applied across all services, see `:headers` in "Global parameters" section.
-* Service level headers are applied on every request of an involved service, see "Services options" section.
-* Request level header are passed on per request basis.
-
-The Headers are cumulative, therefore a request level header will be added on top of the global and Service levels
-headers.
-
-### Prefixes
+### Service Prefix
 A shorter name can be used to call a service only if it's unique among all services.
-For instance `net` or `network` can be used instead of `networking`.
+For instance `net` or `network` can be used instead of `networking` because it's not ambiguous.
 Meanwhile `data` doesn't work because it's ambiguous between `data_processing` and `data_protection_orchestration`
 
 ### Aliases  
-* `dns` is an alias for `domain_name_server`  
-* `volume` is an alias for `block_storage`  
-
-## Openstack service name
-Different service names can be used for a specific Openstack Service by using the :service_names option (see below).
+* `domain_name_server` is an alias for `dns`
+* `volume` is an alias for `block_storage`
 
-## Requests
-The #requests method provides the available requests for a service, for example:
-```ruby
-openstack.compute.requests
+### Requests
+The exhaustive list of requests, extracted from the current service API's and cumulated with Misty service defined
+requests if any, is available as follow:
 
+#### Example (Output truncated)
+```
+cloud.compute.requests
 => [:add_a_single_tag,
  :add_associate_fixed_ip_addfixedip_action_deprecated,
  :add_associate_floating_ip_addfloatingip_action_deprecated,
@@ -159,204 +310,118 @@ openstack.compute.requests
  :create_cell,
  :create_cloudpipe,
  :create_console,
-.../...
 ```
 
-## Setup
-
-### Authentication information parameter
-The URL and credentials details are necessary to authenticate with the identity server (Keystone).
-
-The credentials are a combination of "id" and "name" used to uniquely identify projects, users and their domains.
-When using only the name, a domain must be specified to guarantee a unique record from the Identity service.
-
-The following parameters can be used:  
-* `:domain_id`  
-  Domain id used for authentication scope  
-  Default: `"default"`  
-* `:domain`  
-  Domain name used for authentication scope  
-  Default: `"Default"`  
-* `:project_id`  
-  Project id  
-* `:project`  
-  Project name  
-* `:project_domain_id`  
-  Project domain id
-* `:project_domain`  
-  Project domain name  
-* `:tenant_id`  
-  Tenant id, used only for Keystone v2.0  
-* `:tenant`  
-  Tenant name, used only for Keystone v2.0  
-* `:user_id`  
-  User id  
-* `:user`  
-  User name  
-* `:user_domain_id`  
-  User domain id
-* `:user_domain`  
-  User domain name  
-* `:password`  
-  Password for user. Cannot be used together with `:token`.
-* `:token`  
-  User provided token, overrides all user and password parameters.
-* `:context`  
-  Bypass the authentication by providing a proper context with `token id`, `service catalog` and `expire date`.
-  Overrides all user and password parameters  
-  Example: ``{:context => { :token => token_id, :catalog => service_catalog, :expires => expire_date }}``
-
-#### Keystone v3
-Keystone v3 is default recommended version:
-
+### Direct HTTP requests to REST resources
+To send requests directly use the 'get', 'delete', 'post' and 'put' methods directly:
 ```ruby
-auth = {
-  :url            => 'http://localhost:5000',
-  :user           => 'admin',
-  :user_domain    => 'default',
-  :password       => 'secret',
-  :project        => 'admin',
-  :project_domain => 'default'
-  }
-}
+openstack.network.post('/v2.0/qos/policies/48985e6b8da145699d411f12a3459fca/dscp_marking_rules', data)
 ```
 
-Alternatively, using IDs:
-
+### Orchestration
+#### Example
 ```ruby
-auth = {
-  :url         => 'http://localhost:5000',
-  :user_id    => '48985e6b8da145699d411f12a3459fca',
-  :password   => 'secret',
-  :project_id => '8e1e232f6cbb4116bbef715d8a0afe6e',
-  }
+heat_template = {
+  "files": {},
+  "disable_rollback": true,
+  "parameters": {
+    "flavor": "m1.tiny"
+  },
+  "stack_name": "test_stack",
+  "template": {
+    "heat_template_version": "2013-05-23",
+    "description": "Template to test heat",
+    "parameters": {
+      "flavor": {
+        "default": "m1.small",
+        "type": "string"
+      }
+    },
+    "resources": {
+      "hello_world": {
+        "type": "OS::Nova::Server",
+        "properties": {
+          "flavor": { "get_param": "flavor" },
+          "image": "50fd6f2b-d9f0-41b6-b0a9-4482bfe61914",
+          "user_data": "/bin/bash -xv\necho \"hello world\" > /root/hello-world.txt\n"
+        }
+      }
+    }
+  },
+  "timeout_mins": 60
 }
-```
-#### Keystone v2.0
-Provide the tenant details, Misty will detect it's using v2.0 for authentication:
 
-```ruby
-auth = {
-  :url      => 'http://localhost:5000',
-  :user     => 'admin',
-  :password => 'secret',
-  :tenant   => 'admin',
-}
+require 'misty'
+require 'pp'
+cloud = Misty::Cloud.new(:auth => { ... })
+data_heat_template = Misty.to_json(heat_template)
+response = cloud.orchestration.create_stack(data_heat_template)
+id = response.body['stack']['id']
+stack = cloud.orchestration.show_stack_details('test_stack', id)
+pp stack.body
 ```
-### Logging parameters
-* :log_file  
-  File name and path for log file.  
-  Value is file path or IO object - Default is `./misty.log`.  
-  For example: use STDOUT for terminal output or alternatively use '/dev/null' to avoid the logs entirely.
-* :log_level  
-  Value is Fixnum - Default is 1 (Logger::INFO) - See Logger from Ruby standard Library
 
+#### Some usage examples
 ```ruby
-openstack = Misty::Cloud.new(:auth => auth, :content_type => :ruby, :log_file => STDOUT)
+cloud = Misty::Cloud.new(:auth => { ... })
+pp cloud.compute.versions
+=> [{"status"=>"SUPPORTED",
+"updated"=>"2011-01-21T11:33:21Z",
+"links"=>[{"href"=>"http://192.0.2.1:8774/v2/", "rel"=>"self"}],
+"min_version"=>"",
+"version"=>"",
+"id"=>"v2.0"},
+{"status"=>"CURRENT",
+"updated"=>"2013-07-23T11:33:21Z",
+"links"=>[{"href"=>"http://192.0.2.1:8774/v2.1/", "rel"=>"self"}],
+"min_version"=>"2.1",
+"version"=>"2.53",
+"id"=>"v2.1"}]
 ```
 
-#### Global parameters
-The following options are applied to each service unless specifically provided for a service.
-
-* :content_type  
-  Format of the body of the successful HTTP responses to be JSON or Ruby structures.  
-  Type: Symbol  
-  Allowed values: `:json`, `:ruby`  
-  Default: `:ruby`
-* :headers  
-  HTTP Headers to be applied to all services
-  Type: Hash  
-  Default: {}
-* :region_id  
-  Type: String  
-  Default: "regionOne"  
-* :interface  
-  Type: String  
-  Allowed values: "public", "internal", "admin"  
-  Default: "public"  
-* :ssl_verify_mode  
-  When using SSL mode (defined by URI scheme => "https://")  
-  Type: Boolean  
-  Default: `true`  
-
-### Services Options
-Each service can have specific parameters.
-
 ```ruby
-openstack = Misty::Cloud.new(:auth => auth, :identity => {}, :compute => {})
+cloud.compute(:version => '2.25')
+data_keypair = Misty.to_json('keypair': {'name': 'admin-keypair'})
+admin_keypair = cloud.compute.create_or_import_keypair(data_keypair)
+user_id = admin_keypair.body['keypair']['user_id']
+keypairs = cloud.compute.list_keypairs
+pp keypairs.body
 ```
 
-The following options are available:
-* :api_version  
-  Type: String  
-  Default: The latest supported version - See Misty.services for other versions.  
-* :base_path  
-  Allows to force the base path for every URL requests.  
-  Type: String  
-* :base_url  
-  Allows to force the base URL for every requests.  
-  Type: String        
-* :headers
-  Optional headers
-  Type: Hash
-* :interface  
-  Allows to provide an alternate interface. Allowed values are "public", "internal" or "admin"  
-  Type: String  
-  Default: Determined from global value  
-* :region_id  
-  Type: String  
-  Default: Determined from global value  
-* :service_names  
-  Allows to use a difference name for the service. For instance "identity3" for the identity service.  
-  Type: String  
-  Default: Determined from Misty.services  
-* :ssl_verify_mode  
-  Type: Boolean  
-  Default: Determined from global value  
-* :version  
-  Version to be used when microversion is supported by the service.  
-  Type: String  
-  Allowed values: "CURRENT", "LATEST", "SUPPORTED", or a version number such as "2.0" or "3"  
-  Default: `"CURRENT"`  
-
-Example:
+Nova version 2.10+, a keypair name can be filtered by user_id
 ```ruby
-openstack = Misty::Cloud.new(:auth => auth, :log_level => 0, :identity => {:region_id => 'regionTwo'}, :compute => {:version => '2.27', :interface => 'admin'})
+user_id=1e50c2f0995446fd9b135a1a549cabdb
+cloud.compute(:version => '2.10').show_keypair_details("admin-keypair?user_id=#{user_id}")
 ```
 
-### Services Headers
-HTTP headers can be optionally added to any request.
-A Header object must be created and passed as the last parameter of a request.
-
-For example for an already initialized cloud:
+With Nova version 2.2+, the type field is also returned when showing keypair details
 ```ruby
-header = Misty::HTTP::Header.new(
-  'x-container-meta-web-listings' => false,
-  'x-container-meta-quota-count'  => "",
-  'x-container-meta-quota-bytes'  => nil,
-  'x-versions-location'           => "",
-  'x-container-meta-web-index'    => ""
-)
-
-openstack.object_storage.create_update_or_delete_container_metadata(container_name, header)
+cloud.compute(:version => '2.2')
+pp admin_keypair.body
+=> {'keypair'=>
+    {'public_key'=>
+      'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDjenEe7B87OQHYjZAdJWmaY13mF0N3VooviHypEXaSDfEmFj4GinXorKD0kdXAL30orT0wgAVtpAvRhH2iFTPF2VKCdq4VMzLuai60e3oB3vsTWdZQIJtvaW0mpTNVUQKczbFhRFUi4CNsAijjmGJJgxhihd6rAfynFtalLO0yNn3dKtEMbsvs7KeMxT9SXbfLmEXD4reAK/WXQBVjrEjJIgpC3+SXOO6vsavaOTFu7/Nbha/p4g4yJ3rHUU+7lj79a7iy0sNeExBSZ2aKTq7FQ5XDmtZjjpUeas16kMMX5HdxISYkbq3QnG9iTrIy+GEAYKkZPzhuAa76Qpze35aV Generated-by-Nova\n',
+     'user_id'=>'1e50c2f0995446fd9b135a1a549cabdb',
+     'name'=>'admin-keypair',
+     'deleted'=>false,
+     'created_at'=>'2016-11-23T01:23:53.000000',
+     'updated_at'=>nil,
+     'fingerprint'=>'4e:db:2d:bd:93:70:01:b8:61:17:96:23:e0:78:e2:69',
+     'deleted_at'=>nil,
+     'type'=>'ssh',
+     'id'=>8}}
 ```
 
-## Direct REST HTTP Methods
-To send requests directly use the 'get', 'delete', 'post' and 'put' methods directly:
-```ruby
-openstack.network.post('/v2.0/qos/policies/48985e6b8da145699d411f12a3459fca/dscp_marking_rules', data)
-```
-# Requirements
+# OpenstackAPI notes
+## Neutron
+Driver Vendor Passthru (drivers) has 2 methods call with same name.
+One for Node Vendor Passthru and one for Drivers Passthru.
+They are respectively associated with the methods #call_a_vendor_method and #call_a_driver_method.
 
-## Ruby versions tested
+# Ruby versions tested
+* Ruby MRI 2.5.0
 * Ruby MRI 2.4.2
-* Ruby MRI 2.4.1
-* Ruby MRI 2.4.0
 * Ruby MRI 2.3.4
-* Ruby MRI 2.3.3
-* Ruby MRI 2.3.2
-* Ruby MRI 2.3.1
-* Ruby MRI 2.3.0
 
 # Contributing
 Contributors are welcome and must adhere to the [Contributor covenant code of conduct](http://contributor-covenant.org/).