fog-openstack 0.1.19 → 0.1.20

data/lib/fog/network/openstack/requests/create_subnet_pool.rb

@@ -0,0 +1,56 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def create_subnet_pool(name, prefixes, options = {})
+          data = {
+            'subnetpool' => {
+              'name'     => name,
+              'prefixes' => prefixes
+            }
+          }
+
+          vanilla_options = [:description, :address_scope_id, :shared,
+                             :min_prefixlen, :max_prefixlen, :default_prefixlen]
+          vanilla_options.select { |o| options.key?(o) }.each do |key|
+            data['subnetpool'][key] = options[key]
+          end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => [201],
+            :method  => 'POST',
+            :path    => 'subnetpools'
+          )
+        end
+      end
+
+      class Mock
+        def create_subnet_pool(name, prefixes, options = {})
+          response = Excon::Response.new
+          response.status = 201
+          data = {
+            'id'                => Fog::Mock.random_numbers(6).to_s,
+            'name'              => name,
+            'prefixes'          => prefixes,
+            'description'       => options[:description],
+            'min_prefixlen'     => options[:min_prefixlen] || 64,
+            'max_prefixlen'     => options[:max_prefixlen] || 64,
+            'default_prefixlen' => options[:default_prefixlen] || 64,
+            'address_scope_id'  => options[:address_scope_id],
+            'default_quota'     => options[:default_quota],
+            'ip_version'        => options[:ip_version] || 4,
+            'shared'            => options[:shared].nil? ? false : options[:shared],
+            'is_default'        => options[:is_default].nil? ? false : options[:is_default],
+            'created_at'        => Time.now.to_s,
+            'updated_at'        => Time.now.to_s,
+            'tenant_id'         => Fog::Mock.random_hex(8).to_s
+          }
+          self.data[:subnet_pools][data['id']] = data
+          response.body = {'subnetpool' => data}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/network/openstack/requests/delete_subnet_pool.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def delete_subnet_pool(subnet_pool_id)
+          request(
+            :expects => 204,
+            :method  => 'DELETE',
+            :path    => "subnetpools/#{subnet_pool_id}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_subnet_pool(subnet_pool_id)
+          response = Excon::Response.new
+          if list_subnet_pools.body['subnetpools'].map { |r| r['id'] }.include? subnet_pool_id
+            data[:subnet_pools].delete(subnet_pool_id)
+            response.status = 204
+            response
+          else
+            raise Fog::Network::OpenStack::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/network/openstack/requests/get_subnet_pool.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def get_subnet_pool(subnet_pool_id)
+          request(
+            :expects => [200],
+            :method  => 'GET',
+            :path    => "subnetpools/#{subnet_pool_id}"
+          )
+        end
+      end
+
+      class Mock
+        def get_subnet_pool(subnet_pool_id)
+          data = self.data[:subnet_pools][subnet_pool_id]
+          if data
+            response = Excon::Response.new
+            response.status = 200
+            response.body = {'subnetpool' => data}
+            response
+          else
+            raise Fog::Network::OpenStack::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/network/openstack/requests/list_subnet_pools.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def list_subnet_pools(filters = {})
+          request(
+            :expects => 200,
+            :method  => 'GET',
+            :path    => 'subnetpools',
+            :query   => filters
+          )
+        end
+      end
+
+      class Mock
+        def list_subnet_pools(_filters = {})
+          Excon::Response.new(
+            :body   => {'subnetpools' => data[:subnet_pools].values},
+            :status => 200
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/network/openstack/requests/update_subnet_pool.rb

@@ -0,0 +1,46 @@
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def update_subnet_pool(subnet_pool_id, options = {})
+          data = {'subnetpool' => {}}
+
+          vanilla_options = [:name, :description, :prefixes, :address_scope_id,
+                             :min_prefixlen, :max_prefixlen, :default_prefixlen]
+          vanilla_options.select { |o| options.key?(o) }.each do |key|
+            data['subnetpool'][key] = options[key]
+          end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => 200,
+            :method  => 'PUT',
+            :path    => "subnetpools/#{subnet_pool_id}"
+          )
+        end
+      end
+
+      class Mock
+        def update_subnet_pool(subnet_pool_id, options = {})
+          subnet_pool = list_subnet_pools.body['subnetpools'].find { |s| s['id'] == subnet_pool_id }
+          if subnet_pool
+            subnet_pool['name']              = options[:name]
+            subnet_pool['description']       = options[:description]
+            subnet_pool['prefixes']          = options[:prefixes] || []
+            subnet_pool['min_prefixlen']     = options[:min_prefixlen] || 64
+            subnet_pool['max_prefixlen']     = options[:max_prefixlen] || 64
+            subnet_pool['default_prefixlen'] = options[:default_prefixlen] || 64
+            subnet_pool['address_scope_id']  = options[:address_scope_id]
+            subnet_pool['updated_at']        = Time.now.to_s
+            response = Excon::Response.new
+            response.body = {'subnetpool' => subnet_pool}
+            response.status = 200
+            response
+          else
+            raise Fog::Network::OpenStack::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack.rb

@@ -29,6 +29,10 @@ module Fog
     end
   end
 
+  module Event
+    autoload :OpenStack, File.expand_path('../event/openstack', __FILE__)
+  end
+
   module Identity
     autoload :OpenStack, File.expand_path('../identity/openstack', __FILE__)
 
@@ -51,6 +55,10 @@ module Fog
     autoload :OpenStack, File.expand_path('../introspection/openstack', __FILE__)
   end
 
+  module KeyManager
+    autoload :OpenStack, File.expand_path('../key_manager/openstack', __FILE__)
+  end
+
   module Metering
     autoload :OpenStack, File.expand_path('../metering/openstack', __FILE__)
   end
@@ -100,32 +108,29 @@ module Fog
     end
   end
 
-  module KeyManager
-    autoload :OpenStack, File.expand_path('../key_manager/openstack', __FILE__)
-  end
-
   module OpenStack
     extend Fog::Provider
 
+    service(:baremetal,          'Baremetal')
     service(:compute,            'Compute')
-    service(:image,              'Image')
+    service(:container_infra,    'ContainerInfra')
+    service(:dns,                'DNS')
+    service(:event,              'Event')
     service(:identity,           'Identity')
-    service(:network,            'Network')
-    service(:storage,            'Storage')
-    service(:volume,             'Volume')
+    service(:image,              'Image')
+    service(:introspection,      'Introspection')
+    service(:key,                'KeyManager')
     service(:metering,           'Metering')
     service(:metric,             'Metric')
-    service(:orchestration,      'Orchestration')
+    service(:monitoring,         'Monitoring')
+    service(:network,            'Network')
     service(:nfv,                'NFV')
-    service(:baremetal,          'Baremetal')
+    service(:orchestration,      'Orchestration')
     service(:planning,           'Planning')
-    service(:introspection,      'Introspection')
-    service(:monitoring,         'Monitoring')
-    service(:workflow,           'Workflow')
-    service(:dns,                'DNS')
-    service(:key,                'KeyManager')
     service(:shared_file_system, 'SharedFileSystem')
-    service(:container_infra,    'ContainerInfra')
+    service(:storage,            'Storage')
+    service(:volume,             'Volume')
+    service(:workflow,           'Workflow')
 
     @token_cache = {}
 
@@ -259,7 +264,7 @@ module Fog
 
     # Keystone Style Auth
     def self.authenticate_v3(options, connection_options = {})
-      uri = options[:openstack_auth_uri]
+      uri                   = options[:openstack_auth_uri]
       project_name          = options[:openstack_project_name]
       service_type          = options[:openstack_service_type]
       service_name          = options[:openstack_service_name]
@@ -302,6 +307,26 @@ module Fog
         service = get_service_v3(body, service_type, service_name, openstack_region, options)
       end
 
+      # If no identity endpoint is found, try the auth uri (slicing /auth/tokens)
+      # It covers the case where identityv3 endpoint is not present in the catalog but we have to use it
+      unless service
+        if service_type.include? "identity"
+          identity_uri = uri.to_s.sub('/auth/tokens', '')
+          response = Fog::Core::Connection.new(identity_uri, false, connection_options).request({:method => 'GET'})
+          if response.status == 200
+            service = {
+              "endpoints" => [{
+                 "url"       => identity_uri,
+                 "region"    => openstack_region,
+                 "interface" => endpoint_type
+              }],
+              "type"      => service_type,
+              "name"      => service_name
+            }
+          end
+        end
+      end
+
       unless service
         available_services = body['token']['catalog'].map { |service|
           service['type']
@@ -537,65 +562,27 @@ module Fog
     end
 
     def self.get_supported_version(supported_versions, uri, auth_token, connection_options = {})
-      connection = Fog::Core::Connection.new("#{uri.scheme}://#{uri.host}:#{uri.port}", false, connection_options)
-      response = connection.request({
-                                        :expects => [200, 204, 300],
-                                        :headers => {'Content-Type' => 'application/json',
-                                                     'Accept' => 'application/json',
-                                                     'X-Auth-Token' => auth_token},
-                                        :method => 'GET'
-                                    })
-
-      body = Fog::JSON.decode(response.body)
-      version = nil
-      unless body['versions'].empty?
-        versions = body['versions'].kind_of?(Array) ? body['versions'] : body['versions']['values']
-        supported_version = versions.find do |x|
-          x["id"].match(supported_versions) &&
-            (x["status"] == "CURRENT" || x["status"] == "SUPPORTED" || x["status"] == "stable")
-        end
-        version = supported_version["id"] if supported_version
-      end
-      if version.nil?
-        raise Fog::OpenStack::Errors::ServiceUnavailable.new(
-                  "OpenStack service only supports API versions #{supported_versions.inspect}")
-      end
+      supported_version = get_version(supported_versions, uri, auth_token, connection_options)
+      version = supported_version['id'] if supported_version
+      version_raise(supported_versions) if version.nil?
 
       version
     end
 
     def self.get_supported_version_path(supported_versions, uri, auth_token, connection_options = {})
-      # Find a version in the path (e.g. the v1 in /xyz/v1/tenantid/abc) and get the path up until that version (e.g. /xyz))
-      path_components = uri.path.split '/'
-      version_component_index = path_components.index{|comp| comp.match(/v[0-9].?[0-9]?/) }
-      versionless_path = (path_components.take(version_component_index).join '/' if version_component_index) || uri.path
-      connection = Fog::Core::Connection.new("#{uri.scheme}://#{uri.host}:#{uri.port}#{versionless_path}", false, connection_options)
-      response = connection.request({
-                                        :expects => [200, 204, 300],
-                                        :headers => {'Content-Type' => 'application/json',
-                                                     'Accept' => 'application/json',
-                                                     'X-Auth-Token' => auth_token},
-                                        :method => 'GET'
-                                    })
-
-      body = Fog::JSON.decode(response.body)
-      path = nil
-      unless body['versions'].empty?
-        versions = body['versions'].kind_of?(Array) ? body['versions'] : body['versions']['values']
-        supported_version = versions.find do |x|
-          x["id"].match(supported_versions) &&
-              (x["status"] == "CURRENT" || x["status"] == "SUPPORTED")
-        end
-        path = URI.parse(supported_version['links'].first['href']).path if supported_version
-      end
-      if path.nil?
-        raise Fog::OpenStack::Errors::ServiceUnavailable.new(
-                  "OpenStack service only supports API versions #{supported_versions.inspect}")
-      end
+      supported_version = get_version(supported_versions, uri, auth_token, connection_options)
+      link = supported_version['links'].find { |l| l['rel'] == 'self' } if supported_version
+      path = URI.parse(link['href']).path if link
+      version_raise(supported_versions) if path.nil?
 
       path.chomp '/'
     end
 
+    def self.get_supported_microversion(supported_versions, uri, auth_token, connection_options = {})
+      supported_version = get_version(supported_versions, uri, auth_token, connection_options)
+      supported_version['version'] if supported_version
+    end
+
     # CGI.escape, but without special treatment on spaces
     def self.escape(str, extra_exclude_chars = '')
       str.gsub(/([^a-zA-Z0-9_.-#{extra_exclude_chars}]+)/) do
@@ -614,6 +601,41 @@ module Fog
       end
 
     end
-  end
 
+    def self.get_version(supported_versions, uri, auth_token, connection_options = {})
+      version_cache = "#{uri}#{supported_versions}"
+      return @version[version_cache] if @version && @version[version_cache]
+      connection = Fog::Core::Connection.new("#{uri.scheme}://#{uri.host}:#{uri.port}", false, connection_options)
+      response = connection.request(
+        :expects => [200, 204, 300],
+        :headers => {'Content-Type' => 'application/json',
+                     'Accept'       => 'application/json',
+                     'X-Auth-Token' => auth_token},
+        :method  => 'GET'
+      )
+
+      body = Fog::JSON.decode(response.body)
+
+      @version                = {} unless @version
+      @version[version_cache] = extract_version_from_body(body, supported_versions)
+    end
+
+    def self.extract_version_from_body(body, supported_versions)
+      return nil if body['versions'].empty?
+      versions = body['versions'].kind_of?(Array) ? body['versions'] : body['versions']['values']
+      version = nil
+      # order is important, preffered status should be first
+      %w(CURRENT stable SUPPORTED DEPRECATED).each do |status|
+        version = versions.find { |x| x['id'].match(supported_versions) && (x['status'] == status) }
+        break if version
+      end
+
+      version
+    end
+
+    def self.version_raise(supported_versions)
+      raise Fog::OpenStack::Errors::ServiceUnavailable,
+            "OpenStack service only supports API versions #{supported_versions.inspect}"
+    end
+  end
 end

data/lib/fog/openstack/core.rb

@@ -50,9 +50,9 @@ module Fog
           @openstack_can_reauthenticate = true
         end
 
-        @current_user = options[:current_user]
+        @current_user    = options[:current_user]
         @current_user_id = options[:current_user_id]
-        @current_tenant = options[:current_tenant]
+        @current_tenant  = options[:current_tenant]
       end
 
       def credentials
@@ -79,11 +79,7 @@ module Fog
         retried = false
         begin
           response = @connection.request(params.merge(
-                                           :headers => {
-                                             'Content-Type' => 'application/json',
-                                             'Accept'       => 'application/json',
-                                             'X-Auth-Token' => @auth_token
-                                           }.merge!(params[:headers] || {}),
+                                           :headers => headers(params.delete(:headers)),
                                            :path    => "#{@path}/#{params[:path]}"
           ))
         rescue Excon::Errors::Unauthorized => error
@@ -119,6 +115,53 @@ module Fog
         # if the service supports multiple versions, do the selection here
       end
 
+      def set_microversion
+        @microversion_key          ||= 'Openstack-API-Version'.freeze
+        @microversion_service_type ||= @openstack_service_type.first
+
+        @microversion = Fog::OpenStack.get_supported_microversion(
+          @supported_versions,
+          @openstack_management_uri,
+          @auth_token,
+          @connection_options
+        ).to_s
+
+        # choose minimum out of reported and supported version
+        if microversion_newer_than?(@supported_microversion)
+          @microversion = @supported_microversion
+        end
+
+        # choose minimum out of set and wished version
+        if @fixed_microversion && microversion_newer_than?(@fixed_microversion)
+          @microversion = @fixed_microversion
+        elsif @fixed_microversion && @microversion != @fixed_microversion
+          Fog::Logger.warning("Microversion #{@fixed_microversion} not supported")
+        end
+      end
+
+      def microversion_newer_than?(version)
+        Gem::Version.new(version) < Gem::Version.new(@microversion)
+      end
+
+      def headers(additional_headers)
+        additional_headers ||= {}
+        if @microversion
+          microversion_value = if @microversion_key == 'Openstack-API-Version'
+                                 "#{@microversion_service_type} #{@microversion}"
+                               else
+                                 @microversion
+                               end
+          microversion_header = {@microversion_key => microversion_value}
+          additional_headers.merge!(microversion_header)
+        end
+
+        {
+          'Content-Type' => 'application/json',
+          'Accept'       => 'application/json',
+          'X-Auth-Token' => @auth_token
+        }.merge!(additional_headers)
+      end
+
       def openstack_options
         options = {}
         # Create a hash of (:openstack_*, value) of all the @openstack_* instance variables
@@ -165,6 +208,9 @@ module Fog
           )
         end
 
+        # both need to be set in service's initialize for microversions to work
+        set_microversion if @supported_microversion && @supported_versions
+
         true
       end
     end