xnode-keystone 0.2.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: adc3e9bf385d47c72169139ac971474022b4ed3c
-  data.tar.gz: 6871e8c9b7296d0b4e78a94ce0b2fcc3791f5aae
+  metadata.gz: b398540f03b56c036f706e2674154f35de43746b
+  data.tar.gz: a168bbeb4a24112e145f515284034329660a5250
 SHA512:
-  metadata.gz: 692a46ca48e1a3e19d21b5f1ac245f28acdedf146079a7053112724ba997fae5d98aecf70b6f1f32c183bfc48bd2aa2c97752293209218b5d1aec05ff096358b
-  data.tar.gz: b40275fded79a6f94f8418c5f6aaee84455d269a4569099653874736a2e9e323d605c926c9dec221e5f4d533332693351d7813b4e2e321db37fe2a5b694bd8b9
+  metadata.gz: 0864c1ec3472ddd68f0c1fada42557e0215431b62b85e7c0e7f55faffc90830405e5ea40ecae5f2d2c9959c9b66c93de262ac817fe38405e7148f994b87e8c9b
+  data.tar.gz: 21cbdfc5daa6227941adcbffddae47bf06fd45b142b6ad35296c2e586a28f31c650ce04435ab09cacf8b8d387af11d992f9d253e3ad1aeae181f8104c087aab7

data/.travis.yml

@@ -1,4 +1,15 @@
 language: ruby
 rvm:
+  - 1.9.3-p551
+  - 2.0.0-p598
+  - 2.1.0
+  - 2.1.1
+  - 2.1.2
+  - 2.1.3
+  - 2.1.4
+  - 2.1.5
+  - 2.1.6
+  - 2.2.0
+  - 2.2.1
   - 2.2.2
 before_install: gem install bundler -v 1.10.5

data/README.md

@@ -1,11 +1,11 @@
 # Xnode::Keystone
 
-![Build Status](https://travis-ci.org/xnoder/xnode-keystone.svg)
-[![Gem Version](https://badge.fury.io/rb/xnode-keystone.svg)](http://badge.fury.io/rb/xnode-keystone)
+[![Build Status](https://travis-ci.org/xnoder/xnode-keystone.svg)](https://travis-ci.org/xnoder/xnode-keystone)
+[![Gem Version](https://badge.fury.io/rb/xnode-keystone.svg)](https://rubygems.org/gems/xnode-keystone)
 
 `xnode-keystone` provides methods that allow you to interact with the Keystone Identity service provided by an OpenStack
-cloud. It covers your authentication, and depending on your rights within the cloud, the ability to query and manipulate
-users and tenants.
+cloud. It covers your authentication, as well as retrieving other OpenStack API endpoints exposed by your cloud
+administrators.
 
 ## Installation
 
@@ -25,22 +25,35 @@ Or install it yourself as:
 
 ## Usage
 
-Basic usage is as follows. You need to have an openrc file somewhere that looks something like this:
+Basic usage is as follows. You need to have an `openrc` file somewhere that looks something like this:
 
 ```
 export OS_USERNAME=demo
 export OS_PASSWORD=supas33krit
 export OS_TENANT_NAME=Demo
 export OS_AUTH_URL=https://controller:5000/v2.0
+export OS_AUTH_URL=https://controller:5000/v3
 ```
 
 Source it with `. openrc.sh` to load the environment variables. `xnode-keystone` needs these to find your creds.
 
+There are modules for both `v2.0` and `v3` of the Keystone Identity service. These are called as follows:
+
+For `v2.0`:
+
+`Xnode::Keystone::V2::Authenticate.new`
+
+and for `v3`:
+
+`Xnode::Keystone::V3::Authenticate.new`
+
+Below is an example that is for `V2`:
+
 ```ruby
-require 'xnode-keystone'
+require 'xnode/keystone'
 
 # Initialise a new instance of the base class
-auth = Xnode::Keystone::Authenticate.new
+auth = Xnode::Keystone::V2::Authenticate.new
 
 # Send an authentication request, and get a JSON response back that's been decoded bash into a Hash
 request = auth.request
@@ -57,11 +70,43 @@ keystone = endpoints['identity']['public']
 tenants = auth.tenants(keystone, token)
 ```
 
+And finally, an example for `V3`:
+
+```ruby
+require 'xnode/keystone'
+
+# Initialise a new instance of the base class
+auth = Xnode::Keystone::V3::Authenticate.new
+
+# Send an authentication request, and get a JSON response back that's been decoded bash into a Hash
+request = auth.request
+
+# To extract a token from the request...
+token = auth.get_token
+
+# And to get the public compute API endpoint back...
+endpoints = auth.catalog(request)
+compute = endpoints['compute']['public']
+
+# If you want a list of tenants...
+keystone = endpoints['identity']['public']
+tenants = auth.tenants(keystone, token)
+```
+
+Both are almost syntactically identical, but require some tweaks internally to manipulate the way that the data needed
+is returned to the user. The *major* difference is in the `get_token` method. In `V2`, you need to pass in the response
+body, as the token is contained within the `JSON` response returned by the API. In `V3`, you just need to call the
+method without any parameters, as the token is actually returned as a header in the form of `X-Subject-Token`, which
+I just write to an instance variable, which is accessed by `get_token` when called.
+
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can
+also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the
+version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version,
+push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/lib/xnode/keystone.rb

@@ -8,73 +8,133 @@
 # License:: Distributed under the MIT license.
 
 require "xnode/keystone/version"
-require "xnode/keystone/http"
 require "xnode/keystone/utils"
 
 require 'json'
+require 'rest-client'
 
 module Xnode
   module Keystone
 
-    # This class sets up an authenticated session with the OpenStack API's via Keystone, and exposes methods for
-    # interacting the Identity service.
-    #
-    # ==== Example
-    #
-    # => auth = Xnode::Keystone::Authenticate.new
-    # => request = auth.request
-    # => token = auth.get_token(request)
-    # => catalog = auth.catalog(request)
-    # => keystone_endpoint = catalog['identity']['public']
-    # => tenants = auth.tenants(keystone_endpoint, token)
-    class Authenticate
-
-      # Set accessors for credentials
-      attr_accessor :username, :password, :tenant, :baseurl, :url
-
-      # Authenticates against the OpenStack Identity API endpoint on 5000/tcp or 35357/tcp via HTTP/S.
-      # Uses environment variables to set your authentication credentials.
-      def initialize
-        @username  = ENV['OS_USERNAME']
-        @password  = ENV['OS_PASSWORD']
-        @tenant    = ENV['OS_TENANT_NAME']
-        @baseurl   = ENV['OS_AUTH_URL']
-      end
+    # Provide support for v2.0 of the Keystone Identity Service
+    module V2
 
-      # Uses a private post method (keystone/http.rb) to send an HTTP POST request to OpenStack. The JSON response is
-      # automatically decoded into a Ruby Hash for later manipulation. The response body remains untouched otherwise,
-      # so everything you'd expect to find in the response is within the Hash.
-      def request
-        url = @baseurl + '/tokens'
-        data = Xnode::Keystone.auth_data(@tenant, @username, @password).to_json
-        response  = Xnode::Keystone.post(url, data)
-      end
+      # This class sets up an authenticated session with the OpenStack API's via Keystone, and exposes methods for
+      # interacting the Identity service.
+      #
+      # ==== Example
+      #
+      # => auth = Xnode::Keystone::V2::Authenticate.new
+      # => request = auth.request
+      # => token = auth.get_token(request)
+      # => catalog = auth.catalog(request)
+      # => keystone_endpoint = catalog['identity']['public']
+      # => tenants = auth.tenants(keystone_endpoint, token)
+      class Authenticate
 
-      # Extracts the authentication token from the response, returning it as a String.
-      def get_token(data)
-        data['access']['token']['id']
-      end
+        # Set accessors for credentials
+        attr_accessor :username, :password, :tenant, :baseurl, :url
 
-      # Parses the serviceCatalog returned within the response, and writes it into a modified Hash that makes it
-      # easy to extract public, internal or admin URI's by service type.
-      def catalog(data)
-        mapendpoints = Hash.new
-        data['access']['serviceCatalog'].each do |key, value|
-          mapendpoints[key['type']] = {
-            'public' => key['endpoints'][0]['publicURL'],
-            'internal' => key['endpoints'][0]['internalURL'],
-            'admin' => key['endpoints'][0]['adminURL']
-          }
+        # Authenticates against the OpenStack Identity API endpoint on 5000/tcp or 35357/tcp via HTTP/S.
+        # Uses environment variables to set your authentication credentials.
+        def initialize
+          @username  = ENV['OS_USERNAME']
+          @password  = ENV['OS_PASSWORD']
+          @tenant    = ENV['OS_TENANT_NAME']
+          @baseurl   = ENV['OS_AUTH_URL']
+        end
+
+        # Uses a private post method (keystone/http.rb) to send an HTTP POST request to OpenStack. The JSON response is
+        # automatically decoded into a Ruby Hash for later manipulation. The response body remains untouched otherwise,
+        # so everything you'd expect to find in the response is within the Hash.
+        def request
+          url = "#{@baseurl}/tokens"
+          data = Xnode::Keystone.auth_data(@tenant, @username, @password).to_json
+          request   = RestClient.post "#{url}", data, :content_type => :json, :accept => :json
+          response  = JSON.parse(request)
         end
-        return mapendpoints
-      end
 
-      # Fetches a list of tenants from the platform and returns the data as a Hash
-      def tenants(baseurl, token)
-        url = baseurl + '/tenants'
-        response = Xnode::Keystone.get(url, token)
+        # Extracts the authentication token from the response, returning it as a String.
+        def get_token(data)
+          data['access']['token']['id']
+        end
+
+        # Parses the serviceCatalog returned within the response, and writes it into a modified Hash that makes it
+        # easy to extract public, internal or admin URI's by service type.
+        def catalog(data)
+          mapendpoints = Hash.new
+          data['access']['serviceCatalog'].each do |key, value|
+            mapendpoints[key['type']] = {
+              'public' => key['endpoints'][0]['publicURL'],
+              'internal' => key['endpoints'][0]['internalURL'],
+              'admin' => key['endpoints'][0]['adminURL']
+            }
+          end
+          return mapendpoints
+        end
       end
+    end
+
+    # Provide support for v3 of the Keystone Identity Service
+    module V3
+
+      # This class sets up an authenticated session with the OpenStack API's via Keystone, and exposes methods for
+      # interacting the Identity service.
+      #
+      # ==== Example
+      #
+      # => auth = Xnode::Keystone::V3::Authenticate.new
+      # => request = auth.request
+      # => token = auth.get_token(request)
+      # => catalog = auth.catalog(request)
+      # => keystone_endpoint = catalog['identity']['public']
+      # => tenants = auth.tenants(keystone_endpoint, token)
+      class Authenticate
 
+        # Set accessors for credentials
+        attr_accessor :username, :password, :tenant, :baseurl, :token
+
+        # Authenticates against the OpenStack Identity API endpoint on 5000/tcp or 35357/tcp via HTTP/S.
+        # Uses environment variables to set your authentication credentials.
+        def initialize
+          @username  = ENV['OS_USERNAME']
+          @password  = ENV['OS_PASSWORD']
+          @tenant    = ENV['OS_TENANT_NAME']
+          @baseurl   = ENV['OS_AUTH_URL_V3']
+        end
+
+        # Uses a private post method (keystone/http.rb) to send an HTTP POST request to OpenStack. The JSON response is
+        # automatically decoded into a Ruby Hash for later manipulation. The response body remains untouched otherwise,
+        # so everything you'd expect to find in the response is within the Hash.
+        def request
+          url = "#{@baseurl}/auth/tokens"
+          data = Xnode::Keystone.auth_data_v3(@username, @password).to_json
+          # TODO: fix this so that the generic :post method can be used.
+          response = RestClient.post "#{url}", data, :content_type => :json, :accept => :json
+          @token = response.headers[:x_subject_token]
+
+          return JSON.parse(response.body)
+        end
+
+        # Extracts the authentication token from the response, returning it as a String.
+        def get_token
+          @token
+        end
+
+        # Parses the serviceCatalog returned within the response, and writes it into a modified Hash that makes it
+        # easy to extract public, internal or admin URI's by service type.
+        def catalog(data)
+          mapendpoints = Hash.new
+          data['token']['catalog'].each do |key, value|
+            mapendpoints[key['type']] = Hash.new
+            key['endpoints'].each do |k, v|
+              mapendpoints[key['type']][k['interface']] = "#{k['url']}"
+            end
+          end
+          return mapendpoints
+        end
+
+      end
     end
   end
 end

data/lib/xnode/keystone/http.rb

@@ -1,46 +1 @@
-# This module manages the actual HTTP requests made throughout the gem. The methods are effectively wrappers around
-# other library calls, but allows the author to switch out and modify the requests without breaking the API, as
-# the request responses are dictated by the OpenStack platform, allowing some scope in modifying the request/response
-# features for speed or error handling proficiency.
-
-require 'rest-client'
-
-module Xnode
-  module Keystone
-
-    private
-
-    # Send an HTTP GET request to an OpenStack API endpoint.
-    def get(url, token)
-      request   = RestClient::Request.execute(
-                    method: :get,
-                    url: "#{url}",
-                    headers: {'X-Auth-Token': token, 'Content-Type': 'application/json', 'Accept': 'application/json'})
-      response  = JSON.parse(request.body)
-    end
-    module_function :get
-
-    # Send an HTTP POST request to an OpenStack API endpoint.
-    def post(url, data)
-      request   = RestClient.post "#{url}", data, :content_type => :json, :accept => :json
-      response  = JSON.parse(request.body)
-    end
-    module_function :post
-
-    # Send an HTTP DELETE request to an OpenStack API endpoint.
-    def delete
-    end
-    module_function :delete
-
-    # Send an HTTP PATCH request to an OpenStack API endpoint.
-    def patch
-    end
-    module_function :patch
-
-    # Send an HTTP PUT request to an OpenStack API endpoint.
-    def put
-    end
-    module_function :put
-
-  end
-end
+# STUB

data/lib/xnode/keystone/utils.rb

@@ -8,7 +8,7 @@ module Xnode
 
     # Set up a Keystone JSON request body for authentication purposes.
     def auth_data(tenant, username, password)
-      headers = {
+      payload = {
         :auth => {
           :tenantName => tenant,
           :passwordCredentials => {
@@ -20,5 +20,29 @@ module Xnode
     end
     module_function :auth_data
 
+    # Set up a Keystone V3 JSON request body for authentication purposes.
+    def auth_data_v3(username, password)
+      payload = {
+        :auth => {
+          :identity => {
+            :methods =>
+              [
+                :password
+              ],
+            :password => {
+              :user => {
+                :domain => {
+                  :id => :default
+                },
+                :name => username,
+                :password => password
+              }
+            }
+          }
+        }
+      }
+    end
+    module_function :auth_data_v3
+
   end
 end

data/lib/xnode/keystone/version.rb

@@ -2,6 +2,6 @@
 
 module Xnode
   module Keystone
-    VERSION = "0.2.0"
+    VERSION = "1.0.1"
   end
 end

data/xnode-keystone.gemspec

@@ -14,6 +14,8 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/xnoder/xnode-keystone"
   spec.license       = "MIT"
 
+  spec.required_ruby_version = '~> 1.9.3-p551'
+
   spec.add_runtime_dependency 'rest-client', "~> 1.8", ">= 1.8.0"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xnode-keystone
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Paul Stevens
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-08-07 00:00:00.000000000 Z
+date: 2015-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -130,9 +130,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3.pre.p551
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="